import * as $protobuf from "protobufjs";
export namespace POGOProtos {

    namespace Rpc {

        enum ARDKNominationType {
            regular = 0,
            provisional = 1
        }

        enum ARDKPlayerSubmissionTypeProto {
            type_unspecified = 0,
            poi_submission = 1,
            route_submission = 2,
            poi_image_submission = 3,
            poi_text_metadata_update = 4,
            poi_location_update = 5,
            poi_takedown_request = 6,
            poi_ar_video_submission = 7,
            sponsor_poi_report = 8,
            sponsor_poi_location_update = 9,
            poi_category_vote_submission = 10
        }

        enum ARDKPoiInvalidReason {
            invalid_reason_unspecified = 0,
            no_pedestrian_access = 1,
            obstructs_emergency_services = 2,
            private_residential_property = 3,
            ardk_school = 4,
            permanently_removed = 5,
            duplicate = 6
        }

        enum ARDKScanTag {
            default_scan = 0,
            ardk_public = 1,
            ardk_private = 2,
            wayspot_centric = 3,
            free_form = 4,
            experimental = 5
        }

        enum ARDKSponsorPoiInvalidReason {
            sponsor_poi_reason_unspecified = 0,
            sponsor_poi_reason_does_not_exist = 1,
            sponsor_poi_reason_not_safe = 2,
            sponsor_poi_reason_not_truthful = 3,
            sponsor_poi_reason_not_family_friendly = 4,
            sponsor_poi_reason_offensive_content = 5
        }

        enum ARDKUserType {
            player = 0,
            developer = 1,
            surveyor = 2,
            developer8_th_wall = 3
        }

        enum ASPermissionStatusTelemetryIds {
            AS_PERMISSION_STATUS_TELEMETRY_IDS_UNKNOWN = 0,
            AS_PERMISSION_STATUS_TELEMETRY_IDS_REQUESTED = 1,
            AS_PERMISSION_STATUS_TELEMETRY_IDS_GRANTED_IN_USE = 2,
            AS_PERMISSION_STATUS_TELEMETRY_IDS_GRANTED_ALWAYS = 3,
            AS_PERMISSION_STATUS_TELEMETRY_IDS_DENIED = 4
        }

        enum ASPermissionTelemetryIds {
            AS_PERMISSION_TELEMETRY_IDS_UNSET_PERMISSION = 0,
            AS_PERMISSION_TELEMETRY_IDS_LOCATION = 1,
            AS_PERMISSION_TELEMETRY_IDS_BACKGROUND_LOCATION = 2,
            AS_PERMISSION_TELEMETRY_IDS_ACTIVITY = 3,
            AS_PERMISSION_TELEMETRY_IDS_PRECISE_LOCATION = 4,
            AS_PERMISSION_TELEMETRY_IDS_FITNESS_PERMISSION = 5
        }

        enum ASServiceTelemetryIds {
            AS_SERVICE_TELEMETRY_IDS_UNSET_SERVICE = 0,
            AS_SERVICE_TELEMETRY_IDS_FITNESS = 1,
            AS_SERVICE_TELEMETRY_IDS_AWARENESS = 2,
            AS_SERVICE_TELEMETRY_IDS_BREADCRUMB = 3
        }

        enum AdResponseStatus {
            WASABI_AD_FOUND = 0,
            NO_CAMPAIGNS_FOUND = 1,
            USER_NOT_ELIGIBLE = 2,
            LOW_VALUE_WASABI_AD_FOUND = 3
        }

        enum AdType {
            AD_TYPE_UNKNOWN = 0,
            AD_TYPE_SPONSORED_GIFT = 1,
            AD_TYPE_SPONSORED_BALLOON = 2,
            AD_TYPE_SPONSORED_BALLOON_WASABI = 3,
            AD_TYPE_SPONSORED_BALLOON_GOOGLE_MANAGED_AD = 4,
            AD_TYPE_SPONSORED_BALLOON_AR_AD = 5,
            AD_TYPE_SPONSORED_BALLOON_VIDEO = 6,
            AD_TYPE_AR_AD_MARKON = 7
        }

        enum AnimationPlayPoint {
            UNSET_PLAY_POINT = 0,
            BEFORE_CM_ATTACKER = 1,
            AFTER_CM_ATTACKER = 2
        }

        enum AnimationTake {
            POKEMONGO_PLUS_ANIME_TAKE_SINGLE = 0,
            POKEMONGO_PLUS_ANIME_TAKE_BRANCHING = 1,
            POKEMONGO_PLUS_ANIME_TAKE_SEQUENCE = 2
        }

        enum ArContext {
            AR_CONTEXT_NONE = 0,
            AR_ENCOUNTER = 1,
            AR_SNAPSHOT = 2,
            SINGLEPLAYER_BUDDY = 3,
            MULTIPLAYER_BUDDY = 4
        }

        enum AssetTelemetryIds {
            ASSET_TELEMETRY_IDS_UNDEFINED_ASSET_EVENT = 0,
            ASSET_TELEMETRY_IDS_DOWNLOAD_START = 1,
            ASSET_TELEMETRY_IDS_DOWNLOAD_FINISHED = 2,
            ASSET_TELEMETRY_IDS_DOWNLOAD_FAILED = 3,
            ASSET_TELEMETRY_IDS_ASSET_RETRIEVED_FROM_CACHE = 4,
            ASSET_TELEMETRY_IDS_CACHE_THRASH = 5
        }

        enum AttractedPokemonContext {
            ATTRACTED_POKEMON_UNSET = 0,
            ATTRACTED_POKEMON_ROUTE = 1
        }

        enum AuthIdentityProvider {
            UNSET_IDENTITY_PROVIDER = 0,
            GOOGLE = 1,
            PTC = 2,
            FACEBOOK = 3,
            BACKGROUND = 4,
            INTERNAL = 5,
            SFIDA = 6,
            SUPER_AWESOME = 7,
            DEVELOPER = 8,
            SHARED_SECRET = 9,
            POSEIDON = 10,
            NINTENDO = 11,
            APPLE = 12,
            NIANTIC_SHARED_LOGIN_TOKEN = 13,
            GUEST_LOGIN_TOKEN = 14,
            EIGHTH_WALL = 15,
            PTC_OAUTH = 16
        }

        enum AutoModeConfigType {
            POKEMONGO_PLUS_CONFIG_TYPE_NO_AUTO_MODE = 0,
            POKEMONGO_PLUS_CONFIG_TYPE_SPIN_AUTO_MODE = 1,
            POKEMONGO_PLUS_CONFIG_TYPE_THROW_AUTO_MODE = 2
        }

        enum AvatarCustomizationTelemetryIds {
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_UNDEFINED_AVATAR_CUSTOMIZATION = 0,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_EQUIP_ITEM = 1,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_OPEN_FEATURES = 2,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_OPEN_STORE = 3,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_PURCHASE_ITEM = 4,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_PURCHASE_ERROR = 5,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_SELECT_ITEM_GROUP = 6,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_SELECT_SLOT = 7,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_SELECT_COLOR = 8,
            AVATAR_CUSTOMIZATION_TELEMETRY_IDS_SHOW_QUICK_SHOP = 9
        }

        enum AvatarGender {
            AVATAR_UNKNOWN = 0,
            AVATAR_MALE = 1,
            AVATAR_FEMALE = 2
        }

        enum AvatarSlot {
            AVATAR_SLOT_UNSET = 0,
            AVATAR_SLOT_HAIR = 1,
            AVATAR_SLOT_SHIRT = 2,
            AVATAR_SLOT_PANTS = 3,
            AVATAR_SLOT_HAT = 4,
            AVATAR_SLOT_SHOES = 5,
            AVATAR_SLOT_EYES = 6,
            AVATAR_SLOT_BACKPACK = 7,
            AVATAR_SLOT_GLOVES = 8,
            AVATAR_SLOT_SOCKS = 9,
            AVATAR_SLOT_BELT = 10,
            AVATAR_SLOT_GLASSES = 11,
            AVATAR_SLOT_NECKLACE = 12,
            AVATAR_SLOT_SKIN = 13,
            AVATAR_SLOT_POSE = 14,
            AVATAR_SLOT_FACE = 15,
            AVATAR_SLOT_PROP = 16,
            AVATAR_SLOT_FACE_PRESET = 17,
            AVATAR_SLOT_BODY_PRESET = 18,
            AVATAR_SLOT_EYEBROW = 19,
            AVATAR_SLOT_EYELASH = 20,
            AVATAR_SLOT_GRADIENT_SKIN = 21,
            AVATAR_SLOT_GRADIENT_EYES = 22,
            AVATAR_SLOT_GRADIENT_HAIR = 23
        }

        enum BattleExperiment {
            BASELINE_BATTLE_EXPERIMENT = 0,
            ATTACKER_ITEMS = 1,
            PARTY_POWER = 3
        }

        enum BattleHubSection {
            SECTION_UNSET = 0,
            SECTION_VS_SEEKER = 1,
            SECTION_CURR_SEASON = 2,
            SECTION_LAST_SEASON = 3,
            SECTION_NEARBY = 4,
            SECTION_TEAM_LEADERS = 5,
            SECTION_QR_CODE = 6
        }

        enum BattleHubSubsection {
            SUBSECTION_UNSET = 0,
            SUBSECTION_VS_CHARGING = 1,
            SUBSECTION_VS_FREE = 2,
            SUBSECTION_VS_PREMIUM = 3,
            SUBSECTION_NEARBY_TEAM_LEADERS = 4,
            SUBSECTION_NEARBY_QR_CODE = 5
        }

        enum BattlePartyTelemetryIds {
            BATTLE_PARTY_TELEMETRY_IDS_UNDEFINED_BATTLE_PARTY_EVENT = 0,
            BATTLE_PARTY_TELEMETRY_IDS_ADD = 1,
            BATTLE_PARTY_TELEMETRY_IDS_REMOVE = 2,
            BATTLE_PARTY_TELEMETRY_IDS_GYM_BATTLE = 3,
            BATTLE_PARTY_TELEMETRY_IDS_RAID_BATTLE = 4,
            BATTLE_PARTY_TELEMETRY_IDS_BATTLE_POKEMON_CHANGED = 5
        }

        enum BreadBattleEntryPoint {
            BREAD_BATTLE_ENTRY_POINT_STATION = 0,
            BREAD_BATTLE_ENTRY_POINT_SAVE_FOR_LATER = 1
        }

        enum BreadBattleLevel {
            BREAD_BATTLE_LEVEL_UNSET = 0,
            BREAD_BATTLE_LEVEL_1 = 1,
            BREAD_BATTLE_LEVEL_2 = 2,
            BREAD_BATTLE_LEVEL_3 = 3,
            BREAD_BATTLE_LEVEL_4 = 4,
            BREAD_BATTLE_LEVEL_5 = 5,
            BREAD_BATTLE_LEVEL_6 = 6,
            BREAD_DOUGH_BATTLE_LEVEL_1 = 7
        }

        enum BreadMoveLevels {
            LEVELS_UNSET = 0,
            LEVEL_1 = 1,
            LEVEL_2 = 2,
            LEVEL_3 = 3
        }

        enum BuddyActivity {
            BUDDY_ACTIVITY_UNSET = 0,
            BUDDY_ACTIVITY_FEED = 1,
            BUDDY_ACTIVITY_PET = 2,
            BUDDY_ACTIVITY_SNAPSHOT = 3,
            BUDDY_ACTIVITY_WALK = 4,
            BUDDY_ACTIVITY_NEW_POIS = 5,
            BUDDY_ACTIVITY_GYM_BATTLE = 6,
            BUDDY_ACTIVITY_RAID_BATTLE = 7,
            BUDDY_ACTIVITY_NPC_BATTLE = 8,
            BUDDY_ACTIVITY_PVP_BATTLE = 9,
            BUDDY_ACTIVITY_OPEN_SOUVENIRS = 10,
            BUDDY_ACTIVITY_OPEN_CONSUMABLES = 11,
            BUDDY_ACTIVITY_INVASION_GRUNT = 12,
            BUDDY_ACTIVITY_INVASION_LEADER = 13,
            BUDDY_ACTIVITY_INVASION_GIOVANNI = 14,
            BUDDY_ACTIVITY_ATTRACTIVE_POI = 15,
            BUDDY_ACTIVITY_VISIT_POWERED_UP_FORT = 16,
            BUDDY_ACTIVITY_WAINA_SLEEP = 17,
            BUDDY_ACTIVITY_ROUTE = 18
        }

        enum BuddyActivityCategory {
            BUDDY_CATEGORY_UNSET = 0,
            BUDDY_CATEGORY_FEED = 1,
            BUDDY_CATEGORY_CARE = 2,
            BUDDY_CATEGORY_SNAPSHOT = 3,
            BUDDY_CATEGORY_WALK = 4,
            BUDDY_CATEGORY_BATTLE = 5,
            BUDDY_CATEGORY_EXPLORE = 6,
            BUDDY_CATEGORY_BONUS = 7,
            BUDDY_CATEGORY_ROUTE = 8
        }

        enum BuddyAnimation {
            BUDDY_ANIMATION_UNSET = 0,
            BUDDY_ANIMATION_HAPPY = 1,
            BUDDY_ANIMATION_HATE = 2
        }

        enum BuddyEmotionLevel {
            BUDDY_EMOTION_LEVEL_UNSET = 0,
            BUDDY_EMOTION_LEVEL_0 = 1,
            BUDDY_EMOTION_LEVEL_1 = 2,
            BUDDY_EMOTION_LEVEL_2 = 3,
            BUDDY_EMOTION_LEVEL_3 = 4,
            BUDDY_EMOTION_LEVEL_4 = 5,
            BUDDY_EMOTION_LEVEL_5 = 6,
            BUDDY_EMOTION_LEVEL_6 = 7
        }

        enum BuddyLevel {
            BUDDY_LEVEL_UNSET = 0,
            BUDDY_LEVEL_0 = 1,
            BUDDY_LEVEL_1 = 2,
            BUDDY_LEVEL_2 = 3,
            BUDDY_LEVEL_3 = 4,
            BUDDY_LEVEL_4 = 5,
            BUDDY_LEVEL_5 = 6
        }

        enum CTAText {
            CTA_TEXT_LEARN_MORE = 0,
            CTA_TEXT_SHOP_NOW = 1,
            CTA_TEXT_GET_NOW = 2
        }

        enum CardType {
            CARD_TYPE_UNSET = 0,
            LOCATION_CARD = 1,
            SPECIAL_BACKGROUND = 2
        }

        enum CentralState {
            POKEMONGO_PLUS_CENTRAL_STATE_UNKNOWN = 0,
            POKEMONGO_PLUS_CENTRAL_STATE_RESETTING = 1,
            POKEMONGO_PLUS_CENTRAL_STATE_UNSUPPORTED = 2,
            POKEMONGO_PLUS_CENTRAL_STATE_UNAUTHORIZED = 3,
            POKEMONGO_PLUS_CENTRAL_STATE_POWERED_OFF = 4,
            POKEMONGO_PLUS_CENTRAL_STATE_POWERED_ON = 5
        }

        enum Channel {
            POKEMONGO_PLUS_CHANNEL_NOT_DEFINED = 0,
            POKEMONGO_PLUS_CHANNEL_NEWSFEED_MESSAGE_CHANNEL = 1,
            POKEMONGO_PLUS_CHANNEL_IN_APP_MESSAGE_CHANNEL = 2
        }

        enum ClientOperatingSystem {
            CLIENT_OPERATING_SYSTEM_OS_UNKNOWN = 0,
            CLIENT_OPERATING_SYSTEM_OS_ANDROID = 1,
            CLIENT_OPERATING_SYSTEM_OS_IOS = 2,
            CLIENT_OPERATING_SYSTEM_OS_DESKTOP = 3
        }

        enum CombatExperiment {
            BASELINE = 0,
            FAST_MOVE_ALWAYS_LEAK = 1,
            MINIGAME_FAST_MOVE_CLEAR = 2,
            SWAP_FAST_MOVE_CLEAR = 3,
            DOWNSTREAM_REDUNDANCY = 4,
            DEFENSIVE_ACK_CHECK = 5,
            SERVER_FLY_IN_FLY_OUT = 6,
            CLIENT_REOBSERVER_COMBAT_STATE = 7,
            FAST_MOVE_FLY_IN_CLIP = 8,
            CLIENT_FAST_MOVE_FLY_IN_CLIP_FALL_BACK = 9,
            COMBAT_REWARDS_INVOKE = 10,
            CLIENT_SWAP_WIDGET_DISMISS = 11,
            CLIENT_COMBAT_NULL_RPC_GUARD = 12,
            SWAP_DELAY_TY_GREIL = 13,
            FAST_MOVE_FAINT_DEFERRAL = 14,
            COMBAT_REWARDS_ASYNC = 15,
            ENABLE_FOG = 16
        }

        enum CombatHubEntranceTelemetryIds {
            COMBAT_HUB_ENTRANCE_TELEMETRY_IDS_UNDEFINED_EVENT = 0,
            COMBAT_HUB_ENTRANCE_TELEMETRY_IDS_CLICKED_COMBAT_HUB_BUTTON = 1
        }

        enum CombatPlayerFinishState {
            COMBAT_PLAYER_FINISH_STATE_WINNER = 0,
            COMBAT_PLAYER_FINISH_STATE_LOSER = 1,
            COMBAT_PLAYER_FINISH_STATE_DRAW = 2
        }

        enum CombatRewardStatus {
            COMBAT_REWARD_STATUS_UNSET_REWARD_STATUS = 0,
            COMBAT_REWARD_STATUS_REWARDS_GRANTED = 1,
            COMBAT_REWARD_STATUS_MAX_REWARDS_RECEIVED = 2,
            COMBAT_REWARD_STATUS_PLAYER_BAG_FULL = 3,
            COMBAT_REWARD_STATUS_NO_REWARDS = 4,
            COMBAT_REWARD_STATUS_REWARDS_ELIGIBLE = 5
        }

        enum CombatType {
            COMBAT_TYPE_UNSET = 0,
            COMBAT_TYPE_SOLO = 1,
            COMBAT_TYPE_QR_CODE = 2,
            COMBAT_TYPE_FRIENDS = 3,
            COMBAT_TYPE_NEARBY = 4,
            COMBAT_TYPE_SOLO_INVASION = 5,
            COMBAT_TYPE_VS_SEEKER = 6,
            COMBAT_TYPE_RAID = 7,
            COMBAT_TYPE_DMAX = 8,
            COMBAT_TYPE_GMAX = 9
        }

        enum ContestOccurrence {
            CONTEST_OCCURRENCE_UNSET = 0,
            DAILY = 1,
            TWO_DAYS = 2,
            THREE_DAYS = 3,
            WEEKLY = 4,
            SEASONAL = 5,
            HOURLY = 6,
            FIVE_MINUTES = 7,
            CUSTOM = 8
        }

        enum ContestPokemonMetric {
            CONTEST_POKEMON_METRIC_UNSET = 0,
            POKEMON_SIZE = 1
        }

        enum ContestRankingStandard {
            CONTEST_RANKING_STANDARD_UNSET = 0,
            MIN = 1,
            MAX = 2
        }

        enum ContestScoreComponentType {
            TYPE_UNSET = 0,
            HEIGHT = 1,
            WEIGHT = 2,
            IV = 3
        }

        enum ContributePartyItemResult {
            CONTRIBUTE_UNSET = 0,
            CONTRIBUTE_ERROR_UNKNOWN = 1,
            CONTRIBUTE_SUCCESS = 2,
            CONTRIBUTE_ERROR_INSUFFICIENT_INVENTORY = 3,
            CONTRIBUTE_ERROR_PLAYER_NOT_IN_PARTY = 4,
            CONTRIBUTE_ERROR_UNSANCTIONED_ITEM_TYPE = 5,
            CONTRIBUTE_ERROR_PARTY_UNABLE_TO_RECEIVE = 6
        }

        enum DeviceConnectState {
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_DISCONNECTED = 0,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_DISCONNECTING = 1,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_CONNECTED = 2,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_DISCOVERED = 3,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_USER_FIRST_CONNECT = 4,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_USER_DIALOG_FIRST_CONNECT = 5,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_USER_DIALOG_RECONNECT = 6,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_USER_DIALOG_RECONNECT_REJECT = 7,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_CERTIFIED = 8,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_SOFTWARE_UPDATE = 9,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_FAILED = 10,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_CONNECTING = 11,
            POKEMONGO_PLUS_DEVICE_CONNECT_STATE_REJECTED = 12
        }

        enum DeviceKind {
            POKEMONGO_PLUS_DEVICE_KING_POKEMON_GO_PLUS = 0,
            POKEMONGO_PLUS_DEVICE_KING_UNSET = -1,
            POKEMONGO_PLUS_DEVICE_KING_POKE_BALL_PLUS = 1,
            POKEMONGO_PLUS_DEVICE_KING_WAINA = 2
        }

        enum DeviceMappingAlgorithm {
            DEVICE_MAPPING_ALGORITHM_SLICK = 0
        }

        enum DeviceServiceTelemetryIds {
            DEVICE_SERVICE_TELEMETRY_IDS_UNDEFINED_DEVICE_SERVICE = 0,
            DEVICE_SERVICE_TELEMETRY_IDS_FITNESS = 1,
            DEVICE_SERVICE_TELEMETRY_IDS_SMART_WATCH = 2,
            DEVICE_SERVICE_TELEMETRY_IDS_SFIDA = 3,
            DEVICE_SERVICE_TELEMETRY_IDS_AWARENESS = 4,
            DEVICE_SERVICE_TELEMETRY_IDS_ADVENTURE_SYNC = 5,
            DEVICE_SERVICE_TELEMETRY_IDS_SENSOR = 6
        }

        enum DeviceType {
            NO_DEVICE = 0,
            WAINA = 1
        }

        enum DownstreamActionMethod {
            DOWNSTREAM_ACTION_UNKNOWN_DOWNSTREAM_ACTION = 0,
            DOWNSTREAM_ACTION_NEW_INBOX_MESSAGE_ACTION = 121000,
            DOWNSTREAM_ACTION_CUSTOM_DOWNSTREAM_ACTION = 121001,
            DOWNSTREAM_ACTION_CHAT_SIGNAL = 121002,
            DOWNSTREAM_ACTION_CHAT_MESSAGE = 121003
        }

        enum Edition {
            EDITION_UNKNOWN = 0,
            EDITION_1_TEST_ONLY = 1,
            EDITION_2_TEST_ONLY = 2,
            EDITION_PROTO2 = 998,
            EDITION_PROTO3 = 999,
            EDITION_2023 = 1000,
            EDITION_99997_TEST_ONLY = 99997,
            EDITION_99998_TEST_ONLY = 99998,
            EDITION_99999_TEST_ONLY = 99999
        }

        enum EggIncubatorType {
            INCUBATOR_UNSET = 0,
            INCUBATOR_DISTANCE = 1
        }

        enum EggSlotType {
            EGG_SLOT_DEFAULT = 0,
            EGG_SLOT_SPECIAL = 1
        }

        enum EncounterType {
            ENCOUNTER_TYPE_SPAWN_POINT = 0,
            ENCOUNTER_TYPE_INCENSE = 1,
            ENCOUNTER_TYPE_DISK = 2,
            ENCOUNTER_TYPE_POST_RAID = 3,
            ENCOUNTER_TYPE_STORY_QUEST = 4,
            ENCOUNTER_TYPE_QUEST_STAMP_CARD = 5,
            ENCOUNTER_TYPE_CHALLENGE_QUEST = 6,
            ENCOUNTER_TYPE_PHOTOBOMB = 7,
            ENCOUNTER_TYPE_INVASION = 8,
            ENCOUNTER_TYPE_VS_SEEKER_REWARD = 9,
            ENCOUNTER_TYPE_TIMED_STORY_QUEST = 10,
            ENCOUNTER_TYPE_DAILY_BONUS = 11,
            ENCOUNTER_TYPE_REFERRAL_QUEST = 12,
            ENCOUNTER_TYPE_TIMED_MINI_COLLECTION_QUEST = 13,
            ENCOUNTER_TYPE_POWER_UP_POKESTOP = 14,
            ENCOUNTER_TYPE_BUTTERFLY_COLLECTOR = 15,
            ENCOUNTER_TYPE_ROUTE = 17,
            ENCOUNTER_TYPE_PARTY_QUEST = 18,
            ENCOUNTER_TYPE_BADGE_REWARD = 19,
            ENCOUNTER_TYPE_STATION_ENCOUNTER = 20,
            ENCOUNTER_TYPE_POST_BREAD_BATTLE = 21,
            ENCOUNTER_TYPE_TUTORIAL_ENCOUNTER = 22,
            ENCOUNTER_TYPE_PERSONALIZED_RESEARCH = 23,
            ENCOUNTER_TYPE_STAMP_COLLECTION_REWARD = 24,
            ENCOUNTER_TYPE_EVENT_PASS_REWARD = 25,
            ENCOUNTER_TYPE_WEEKLY_CHALLENGE_REWARD = 26
        }

        enum EnterUsernameMode {
            UNDEFINED_USERNAME_ENTRY_MODE = 0,
            NEW_USER = 1,
            CHANGE_BANNED_NAME = 2,
            EXISTING_USER_CHANGE_NAME = 3
        }

        enum EntryPointForContestEntry {
            ENTRY_POINT_UNSET = 0,
            SUGGESTED_FROM_CONTEST_PAGE = 1,
            SWITCH_POKEMON_CONTEST_PAGE = 2,
            SUGGESTED_AFTER_POKEMON_CATCH = 3
        }

        enum EventRsvpType {
            UNSET_EVENT = 0,
            RAID = 1,
            MAX_BATTLE = 2
        }

        enum ExpressionUpdateBroadcastMethod {
            BROADCAST_METHOD_UNSET = 0,
            BROADCAST_TO_ALL_POKEMON = 1,
            BROADCAST_TO_SPECIFIED_POKEMON = 2
        }

        enum FeatureKind {
            KIND_UNDEFINED = 0,
            KIND_BASIN = 1,
            KIND_CANAL = 2,
            KIND_CEMETERY = 3,
            KIND_COMMERCIAL = 6,
            KIND_DITCH = 9,
            KIND_DRAIN = 11,
            KIND_FARM = 12,
            KIND_FARMLAND = 13,
            KIND_FOREST = 16,
            KIND_GARDEN = 17,
            KIND_GLACIER = 18,
            KIND_GOLF_COURSE = 19,
            KIND_GRASS = 20,
            KIND_HIGHWAY = 21,
            KIND_HOTEL = 23,
            KIND_INDUSTRIAL = 24,
            KIND_LAKE = 25,
            KIND_MAJOR_ROAD = 28,
            KIND_MEADOW = 29,
            KIND_MINOR_ROAD = 30,
            KIND_NATURE_RESERVE = 31,
            KIND_OCEAN = 32,
            KIND_PARK = 33,
            KIND_PARKING = 34,
            KIND_PATH = 35,
            KIND_PEDESTRIAN = 36,
            KIND_PITCH = 37,
            KIND_PLAYA = 39,
            KIND_PLAYGROUND = 40,
            KIND_QUARRY = 41,
            KIND_RAILWAY = 42,
            KIND_RECREATION_AREA = 43,
            KIND_RESIDENTIAL = 45,
            KIND_RETAIL = 46,
            KIND_RIVER = 47,
            KIND_RIVERBANK = 48,
            KIND_RUNWAY = 49,
            KIND_SCHOOL = 50,
            KIND_STREAM = 53,
            KIND_TAXIWAY = 54,
            KIND_WATER = 58,
            KIND_WETLAND = 59,
            KIND_WOOD = 60,
            KIND_OTHER = 63,
            KIND_COUNTRY = 64,
            KIND_REGION = 65,
            KIND_CITY = 66,
            KIND_TOWN = 67,
            KIND_AIRPORT = 68,
            KIND_BAY = 69,
            KIND_BOROUGH = 70,
            KIND_FJORD = 71,
            KIND_HAMLET = 72,
            KIND_MILITARY = 73,
            KIND_NATIONAL_PARK = 74,
            KIND_NEIGHBORHOOD = 75,
            KIND_PEAK = 76,
            KIND_PRISON = 77,
            KIND_PROTECTED_AREA = 78,
            KIND_REEF = 79,
            KIND_ROCK = 80,
            KIND_SAND = 81,
            KIND_SCRUB = 82,
            KIND_SEA = 83,
            KIND_STRAIT = 84,
            KIND_VALLEY = 85,
            KIND_VILLAGE = 86,
            KIND_LIGHT_RAIL = 87,
            KIND_PLATFORM = 88,
            KIND_STATION = 89,
            KIND_SUBWAY = 90,
            KIND_AGRICULTURAL = 91,
            KIND_EDUCATION = 92,
            KIND_GOVERNMENT = 93,
            KIND_HEALTHCARE = 94,
            KIND_LANDMARK = 95,
            KIND_RELIGIOUS = 96,
            KIND_SERVICES = 97,
            KIND_SPORTS = 98,
            KIND_TRANSPORTATION = 99,
            KIND_UNUSED = 100,
            KIND_BIOME = 101,
            KIND_PIER = 102,
            KIND_ORCHARD = 103,
            KIND_VINEYARD = 104
        }

        enum FeaturesFeatureKind {
            undefined = 0,
            basin = 1,
            canal = 2,
            cemetery = 3,
            commercial = 6,
            ditch = 9,
            drain = 11,
            farm = 12,
            farmland = 13,
            forest = 16,
            garden = 17,
            glacier = 18,
            golf_course = 19,
            grass = 20,
            highway = 21,
            hotel = 23,
            industrial = 24,
            lake = 25,
            major_road = 28,
            meadow = 29,
            minor_road = 30,
            nature_reserve = 31,
            ocean = 32,
            park = 33,
            parking = 34,
            path = 35,
            pedestrian = 36,
            pitch = 37,
            playa = 39,
            playground = 40,
            quarry = 41,
            railway = 42,
            recreation_area = 43,
            residential = 45,
            retail = 46,
            river = 47,
            riverbank = 48,
            runway = 49,
            school = 50,
            stream = 53,
            taxiway = 54,
            water = 58,
            wetland = 59,
            wood = 60,
            other = 63,
            country = 64,
            region = 65,
            city = 66,
            town = 67,
            airport = 68,
            bay = 69,
            borough = 70,
            fjord = 71,
            hamlet = 72,
            military = 73,
            national_park = 74,
            neighborhood = 75,
            peak = 76,
            prison = 77,
            protected_area = 78,
            reef = 79,
            rock = 80,
            sand = 81,
            scrub = 82,
            sea = 83,
            strait = 84,
            valley = 85,
            village = 86,
            light_rail = 87,
            platform = 88,
            station = 89,
            subway = 90,
            agricultural = 91,
            education = 92,
            government = 93,
            healthcare = 94,
            landmark = 95,
            religious = 96,
            services = 97,
            sports = 98,
            transportation = 99,
            unused = 100,
            biome = 101,
            pier = 102,
            orchard = 103,
            vineyard = 104
        }

        enum FortPowerUpLevel {
            FORT_POWER_UP_LEVEL_UNSET = 0,
            FORT_POWER_UP_LEVEL_0 = 1,
            FORT_POWER_UP_LEVEL_1 = 2,
            FORT_POWER_UP_LEVEL_2 = 3,
            FORT_POWER_UP_LEVEL_3 = 4
        }

        enum FortPowerUpLevelReward {
            FORT_POWER_UP_LEVEL_REWARD_UNSET = 0,
            FORT_POWER_UP_LEVEL_REWARD_BUDDY_BONUS_HEART = 1,
            FORT_POWER_UP_REWARD_BONUS_ITEM_ON_SPIN = 2,
            FORT_POWER_UP_REWARD_BONUS_SPAWN = 3,
            FORT_POWER_UP_REWARD_BONUS_RAID_POKEBALLS = 4
        }

        enum FortType {
            GYM = 0,
            CHECKPOINT = 1
        }

        enum FriendListSortDirection {
            ASCENDING = 0,
            DESCENDING = 1
        }

        enum FriendListSortType {
            UNSET = 0,
            NAME = 1,
            NICKNAME = 2,
            FRIENDSHIP_LEVEL = 3,
            GIFTS = 4,
            GIFTABLE = 5,
            ONLINE_STATUS = 6,
            DATE = 7,
            RAID_ACTIVITY = 8
        }

        enum FriendshipLevelMilestone {
            FRIENDSHIP_LEVEL_UNSET = 0,
            FRIENDSHIP_LEVEL_0 = 1,
            FRIENDSHIP_LEVEL_1 = 2,
            FRIENDSHIP_LEVEL_2 = 3,
            FRIENDSHIP_LEVEL_3 = 4,
            FRIENDSHIP_LEVEL_4 = 5
        }

        enum GameAccountRegistryActions {
            GAME_ACCOUNT_REGISTRY_ACTION_UNKNOWN_GAME_ACCOUNT_REGISTRY_ACTION = 0,
            GAME_ACCOUNT_REGISTRY_ACTION_ADD_LOGIN_ACTION = 600000,
            GAME_ACCOUNT_REGISTRY_ACTION_REMOVE_LOGIN_ACTION = 600001,
            GAME_ACCOUNT_REGISTRY_ACTION_LIST_LOGIN_ACTION = 600002,
            GAME_ACCOUNT_REGISTRY_ACTION_REPLACE_LOGIN_ACTION = 600003,
            GAME_ACCOUNT_REGISTRY_ACTION_SET_BIRTHDAY_ACTION = 600004,
            GAME_ACCOUNT_REGISTRY_ACTION_GAR_PROXY_ACTION = 600005,
            GAME_ACCOUNT_REGISTRY_ACTION_LINK_TO_ACCOUNT_LOGIN_ACTION = 600006
        }

        enum GameAdventureSyncAction {
            GAME_LOCATION_AWARENESS_ACTION_UNKNOWN_GAME_LOCATION_AWARENESS_ACTION = 0,
            GAME_LOCATION_AWARENESS_ACTION_REQUEST_GEOFENCE_UPDATES = 360000,
            GAME_LOCATION_AWARENESS_ACTION_UPDATE_PLAYER_LOCATION = 360001,
            GAME_LOCATION_AWARENESS_ACTION_BULK_UPDATE_PLAYER_LOCATION = 360002,
            GAME_LOCATION_AWARENESS_ACTION_UPDATE_BREADCRUMB_HISTORY = 361000,
            GAME_LOCATION_AWARENESS_ACTION_REFRESH_PROXIMITY_TOKENS = 362000,
            GAME_LOCATION_AWARENESS_ACTION_REPORT_PROXIMITY_CONTACTS = 362001
        }

        enum GameAnticheatAction {
            GAME_ANTICHEAT_ACTION_UNKNOWN_GAME_ANTICHEAT_ACTION = 0,
            GAME_ANTICHEAT_ACTION_GET_OUTSTANDING_WARNINGS = 200000,
            GAME_ANTICHEAT_ACTION_ACKNOWLEDGE_WARNINGS = 200001
        }

        enum GameAuthenticationActionMethod {
            GAME_AUTHENTICATION_ACTION_UNKNOWN_GAME_AUTHENTICATION_ACTION = 0,
            GAME_AUTHENTICATION_ACTION_ROTATE_GUEST_LOGIN_SECRET_TOKEN = 250011
        }

        enum GameBackgroundModeAction {
            GAME_BACKGROUND_MODE_ACTION_UNKNOWN_GAME_BACKGROUND_MODE_ACTION = 0,
            GAME_BACKGROUND_MODE_ACTION_REGISTER_BACKGROUND_SERVICE = 230000,
            GAME_BACKGROUND_MODE_ACTION_GET_CLIENT_BGMODE_SETTINGS = 230001,
            GAME_BACKGROUND_MODE_ACTION_GET_ADVENTURE_SYNC_PROGRESS = 230002
        }

        enum GameChatActions {
            GAME_CHAT_ACTION_UNKNOWN_GAME_CHAT_ACTION = 0,
            GAME_CHAT_ACTION_PROXY_CHAT_ACTION = 660000
        }

        enum GameCrmActions {
            CRM_ACTION_UNKNOWN_CRM_ACTION = 0,
            CRM_ACTION_CRM_PROXY_ACTION = 680000
        }

        enum GameFitnessAction {
            GAME_FITNESS_ACTION_UNKNOWN_GAME_FITNESS_ACTION = 0,
            GAME_FITNESS_ACTION_UPDATE_FITNESS_METRICS = 640000,
            GAME_FITNESS_ACTION_GET_FITNESS_REPORT = 640001,
            GAME_FITNESS_ACTION_GET_ADVENTURE_SYNC_SETTINGS = 640002,
            GAME_FITNESS_ACTION_UPDATE_ADVENTURE_SYNC_SETTINGS = 640003,
            GAME_FITNESS_ACTION_UPDATE_ADVENTURE_SYNC_FITNESS = 640004,
            GAME_FITNESS_ACTION_GET_ADVENTURE_SYNC_FITNESS_REPORT = 640005
        }

        enum GameGmTemplatesAction {
            GAME_GM_TEMPLATES_ACTION_UNKNOWN_GAME_GM_TEMPLATES_ACTION = 0,
            GAME_GM_TEMPLATES_ACTION_DOWNLOAD_GAME_MASTER_TEMPLATES = 340000
        }

        enum GameIapAction {
            GAME_IAP_ACTION_UNKNOWN_GAME_IAP_ACTION = 0,
            GAME_IAP_ACTION_PURCHASE_SKU = 310000,
            GAME_IAP_ACTION_GET_AVAILABLE_SKUS_AND_BALANCES = 310001,
            GAME_IAP_ACTION_SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 310002,
            GAME_IAP_ACTION_PURCHASE_WEB_SKU = 310003,
            GAME_IAP_ACTION_REDEEM_GOOGLE_RECEIPT = 310100,
            GAME_IAP_ACTION_REDEEM_APPLE_RECEIPT = 310101,
            GAME_IAP_ACTION_REDEEM_DESKTOP_RECEIPT = 310102,
            GAME_IAP_ACTION_REDEEM_SAMSUNG_RECEIPT = 310103,
            GAME_IAP_ACTION_GET_AVAILABLE_SUBSCRIPTIONS = 310200,
            GAME_IAP_ACTION_GET_ACTIVE_SUBSCRIPTIONS = 310201,
            GAME_IAP_ACTION_GET_REWARD_TIERS = 310300,
            GAME_IAP_ACTION_CLAIM_REWARDED_SPEND_TIER = 310301,
            GAME_IAP_ACTION_REDEEM_XSOLLA_RECEIPT = 311100,
            GAME_IAP_ACTION_GET_WEBSTORE_USER = 311101,
            GAME_IAP_ACTION_REFUND_IAP_RECEIPT = 311102,
            GAME_IAP_ACTION_GET_AVAILABLE_SKUS_ANONYMOUS = 311103,
            GAME_IAP_ACTION_REDEEM_WEBSTORE_RECEIPT = 311104
        }

        enum GameNotificationAction {
            GAME_NOTIFICATION_ACTION_UNKNOWN_GAME_NOTIFICATION_ACTION = 0,
            GAME_NOTIFICATION_ACTION_UPDATE_NOTIFICATION_STATUS = 350000
        }

        enum GamePasscodeAction {
            GAME_PASSCODE_ACTION_UNKNOWN_GAME_PASSCODE_ACTION = 0,
            GAME_PASSCODE_ACTION_REDEEM_PASSCODE = 330000
        }

        enum GamePingAction {
            GAME_PING_ACTION_UNKNOWN_GAME_PING_ACTION = 0,
            GAME_PING_ACTION_PING = 220000,
            GAME_PING_ACTION_PING_ASYNC = 220001,
            GAME_PING_ACTION_PING_DOWNSTREAM = 220002,
            GAME_PING_ACTION_PING_OPEN = 221000
        }

        enum GamePlayerAction {
            GAME_PLAYER_ACTION_UNKNOWN_GAME_PLAYER_ACTION = 0,
            GAME_PLAYER_ACTION_GET_INVENTORY = 380000
        }

        enum GamePoiAction {
            GAME_POI_ACTION_UNKNOWN_GAME_POI_ACTION = 0,
            GAME_POI_ACTION_ADD_NEW_POI = 620000,
            GAME_POI_ACTION_GET_AVAILABLE_SUBMISSIONS = 620001,
            GAME_POI_ACTION_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 620002,
            GAME_POI_ACTION_GET_PLAYER_SUBMISSION_VALIDATION_SETTINGS = 620003,
            GAME_POI_ACTION_SUBMIT_POI_IMAGE = 620100,
            GAME_POI_ACTION_SUBMIT_POI_TEXT_METADATA_UPDATE = 620101,
            GAME_POI_ACTION_SUBMIT_POI_LOCATION_UPDATE = 620102,
            GAME_POI_ACTION_SUBMIT_POI_TAKEDOWN_REQUEST = 620103,
            GAME_POI_ACTION_SUBMIT_SPONSOR_POI_REPORT = 620104,
            GAME_POI_ACTION_SUBMIT_SPONSOR_POI_LOCATION_UPDATE = 620105,
            GAME_POI_ACTION_ADD_NEW_ROUTE = 620200,
            GAME_POI_ACTION_GENERATE_GMAP_SIGNED_URL = 620300,
            GAME_POI_ACTION_GET_GMAP_SETTINGS = 620301,
            GAME_POI_ACTION_SUBMIT_POI_AR_VIDEO_METADATA = 620400,
            GAME_POI_ACTION_GET_GRAPESHOT_FILE_UPLOAD_URL = 620401,
            GAME_POI_ACTION_ASYNC_FILE_UPLOAD_COMPLETE = 620402
        }

        enum GamePushNotificationAction {
            GAME_PUSH_NOTIFICATION_ACTION_UNKNOWN_GAME_PUSH_NOTIFICATION_ACTION = 0,
            GAME_PUSH_NOTIFICATION_ACTION_REGISTER_PUSH_NOTIFICATION = 320000,
            GAME_PUSH_NOTIFICATION_ACTION_UNREGISTER_PUSH_NOTIFICATION = 320001,
            GAME_PUSH_NOTIFICATION_ACTION_OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 320002,
            GAME_PUSH_NOTIFICATION_ACTION_REGISTER_PUSH_NOTIFICATION_TOKEN = 320003,
            GAME_PUSH_NOTIFICATION_ACTION_UNREGISTER_PUSH_NOTIFICATION_TOKEN = 320004,
            GAME_PUSH_NOTIFICATION_ACTION_OPT_OUT_PUSH_NOTIFICATION_TOKEN_CATEGORY = 320005
        }

        enum GameSocialAction {
            GAME_SOCIAL_ACTION_UNKNOWN_GAME_SOCIAL_ACTION = 0,
            GAME_SOCIAL_ACTION_PROXY_SOCIAL_ACTION = 630000,
            GAME_SOCIAL_ACTION_PROXY_SOCIAL_SIDE_CHANNEL_ACTION = 630001
        }

        enum GameTelemetryAction {
            GAME_TELEMETRY_ACTION_UNKNOWN_GAME_TELEMETRY_ACTION = 0,
            GAME_TELEMETRY_ACTION_COLLECT_CLIENT_TELEMETRY = 610000,
            GAME_TELEMETRY_ACTION_GET_CLIENT_TELEMETRY_SETTINGS = 610001
        }

        enum GameWebTokenAction {
            GAME_WEB_TOKEN_ACTION_UNKNOWN_GAME_WEB_TOKEN_ACTION = 0,
            GAME_WEB_TOKEN_ACTION_GET_WEB_TOKEN_ACTION = 370000
        }

        enum GenericClickTelemetryIds {
            GENERIC_CLICK_TELEMETRY_IDS_UNDEFINED_GENERIC_EVENT = 0,
            GENERIC_CLICK_TELEMETRY_IDS_SPEED_WARNING_SHOW = 1,
            GENERIC_CLICK_TELEMETRY_IDS_SPEED_WARNING_PASSENGER = 2,
            GENERIC_CLICK_TELEMETRY_IDS_CACHE_RESET_CLICKED = 3,
            GENERIC_CLICK_TELEMETRY_IDS_REFUND_PAGE_OPENED = 4
        }

        enum GraphDataType {
            GRAPH_DATA_TYPE_ARDK = 0
        }

        enum GroupType {
            GROUP_TYPE_UNSET = 0,
            GROUP_TYPE_INVITE_ONLY_GROUP = 1,
            GROUP_TYPE_MATCHMAKING_GROUP = 2
        }

        enum GymBadgeType {
            GYM_BADGE_UNSET = 0,
            GYM_BADGE_VANILLA = 1,
            GYM_BADGE_BRONZE = 2,
            GYM_BADGE_SILVER = 3,
            GYM_BADGE_GOLD = 4
        }

        enum HelpshiftAuthenticationFailureReason {
            HELPSHIFT_AUTHENTICATON_FAILURE_REASON_AUTH_TOKEN_NOT_PROVIDED = 0,
            HELPSHIFT_AUTHENTICATON_FAILURE_REASON_INVALID_AUTH_TOKEN = 1,
            HELPSHIFT_AUTHENTICATON_FAILURE_REASON_UNKNOWN = 2
        }

        enum HoloActivityType {
            ACTIVITY_UNKNOWN = 0,
            ACTIVITY_CATCH_POKEMON = 1,
            ACTIVITY_CATCH_LEGEND_POKEMON = 2,
            ACTIVITY_FLEE_POKEMON = 3,
            ACTIVITY_DEFEAT_FORT = 4,
            ACTIVITY_EVOLVE_POKEMON = 5,
            ACTIVITY_HATCH_EGG = 6,
            ACTIVITY_WALK_KM = 7,
            ACTIVITY_POKEDEX_ENTRY_NEW = 8,
            ACTIVITY_CATCH_FIRST_THROW = 9,
            ACTIVITY_CATCH_NICE_THROW = 10,
            ACTIVITY_CATCH_GREAT_THROW = 11,
            ACTIVITY_CATCH_EXCELLENT_THROW = 12,
            ACTIVITY_CATCH_CURVEBALL = 13,
            ACTIVITY_CATCH_FIRST_CATCH_OF_DAY = 14,
            ACTIVITY_CATCH_MILESTONE = 15,
            ACTIVITY_TRAIN_POKEMON = 16,
            ACTIVITY_SEARCH_FORT = 17,
            ACTIVITY_RELEASE_POKEMON = 18,
            ACTIVITY_HATCH_EGG_SMALL_BONUS = 19,
            ACTIVITY_HATCH_EGG_MEDIUM_BONUS = 20,
            ACTIVITY_HATCH_EGG_LARGE_BONUS = 21,
            ACTIVITY_DEFEAT_GYM_DEFENDER = 22,
            ACTIVITY_DEFEAT_GYM_LEADER = 23,
            ACTIVITY_CATCH_FIRST_CATCH_STREAK_BONUS = 24,
            ACTIVITY_SEARCH_FORT_FIRST_OF_THE_DAY = 25,
            ACTIVITY_SEARCH_FORT_STREAK_BONUS = 26,
            ACTIVITY_DEFEAT_RAID_POKEMON = 27,
            ACTIVITY_FEED_BERRY = 28,
            ACTIVITY_SEARCH_GYM = 29,
            ACTIVITY_NEW_POKESTOP = 30,
            ACTIVITY_GYM_BATTLE_LOSS = 31,
            ACTIVITY_CATCH_AR_PLUS_BONUS = 32,
            ACTIVITY_CATCH_QUEST_POKEMON_ENCOUNTER = 33,
            ACTIVITY_FRIENDSHIP_LEVEL_UP_0 = 35,
            ACTIVITY_FRIENDSHIP_LEVEL_UP_1 = 36,
            ACTIVITY_FRIENDSHIP_LEVEL_UP_2 = 37,
            ACTIVITY_FRIENDSHIP_LEVEL_UP_3 = 38,
            ACTIVITY_FRIENDSHIP_LEVEL_UP_4 = 39,
            ACTIVITY_SEND_GIFT = 40,
            ACTIVITY_RAID_LEVEL_1_ADDITIONAL_XP = 42,
            ACTIVITY_RAID_LEVEL_2_ADDITIONAL_XP = 43,
            ACTIVITY_RAID_LEVEL_3_ADDITIONAL_XP = 44,
            ACTIVITY_RAID_LEVEL_4_ADDITIONAL_XP = 45,
            ACTIVITY_RAID_LEVEL_5_ADDITIONAL_XP = 46,
            ACTIVITY_HATCH_EGG_SHADOW = 47,
            ACTIVITY_HATCH_EGG_GIFT = 48,
            ACTIVITY_REMOTE_DEFEAT_RAID_POKEMON = 49,
            ACTIVITY_REMOTE_RAID_LEVEL_1_ADDITIONAL_XP = 50,
            ACTIVITY_REMOTE_RAID_LEVEL_2_ADDITIONAL_XP = 51,
            ACTIVITY_REMOTE_RAID_LEVEL_3_ADDITIONAL_XP = 52,
            ACTIVITY_REMOTE_RAID_LEVEL_4_ADDITIONAL_XP = 53,
            ACTIVITY_REMOTE_RAID_LEVEL_5_ADDITIONAL_XP = 54,
            ACTIVITY_CHANGE_POKEMON_FORM = 55,
            ACTIVITY_EARN_BUDDY_WALKED_CANDY = 56,
            ACTIVITY_RAID_LEVEL_1_SHADOW_ADDITIONAL_XP = 57,
            ACTIVITY_RAID_LEVEL_2_SHADOW_ADDITIONAL_XP = 58,
            ACTIVITY_RAID_LEVEL_3_SHADOW_ADDITIONAL_XP = 59,
            ACTIVITY_RAID_LEVEL_4_SHADOW_ADDITIONAL_XP = 60,
            ACTIVITY_RAID_LEVEL_5_SHADOW_ADDITIONAL_XP = 61,
            ACTIVITY_REMOTE_RAID_LEVEL_1_SHADOW_ADDITIONAL_XP = 62,
            ACTIVITY_REMOTE_RAID_LEVEL_2_SHADOW_ADDITIONAL_XP = 63,
            ACTIVITY_REMOTE_RAID_LEVEL_3_SHADOW_ADDITIONAL_XP = 64,
            ACTIVITY_REMOTE_RAID_LEVEL_4_SHADOW_ADDITIONAL_XP = 65,
            ACTIVITY_REMOTE_RAID_LEVEL_5_SHADOW_ADDITIONAL_XP = 66,
            ACTIVITY_CATCH_MASTER_BALL_THROW = 67,
            ACTIVITY_RAID_LEVEL_MEGA_ADDITIONAL_XP = 68,
            ACTIVITY_RAID_LEVEL_MEGA_5_ADDITIONAL_XP = 69,
            ACTIVITY_RAID_LEVEL_ULTRA_BEAST_ADDITIONAL_XP = 70,
            ACTIVITY_RAID_LEVEL_EXTENDED_EGG_ADDITIONAL_XP = 71,
            ACTIVITY_RAID_LEVEL_PRIMAL_ADDITIONAL_XP = 72,
            ACTIVITY_REMOTE_RAID_LEVEL_MEGA_ADDITIONAL_XP = 73,
            ACTIVITY_REMOTE_RAID_LEVEL_MEGA_5_ADDITIONAL_XP = 74,
            ACTIVITY_REMOTE_RAID_LEVEL_ULTRA_BEAST_ADDITIONAL_XP = 75,
            ACTIVITY_REMOTE_RAID_LEVEL_EXTENDED_EGG_ADDITIONAL_XP = 76,
            ACTIVITY_REMOTE_RAID_LEVEL_PRIMAL_ADDITIONAL_XP = 77,
            ACTIVITY_ROUTE_COMPLETE = 78,
            ACTIVITY_ROUTE_COMPLETE_FIRST_OF_THE_DAY = 79,
            ACTIVITY_ROUTE_COMPLETE_STREAK_BONUS = 80,
            ACTIVITY_FUSE_POKEMON = 81,
            ACTIVITY_UNFUSE_POKEMON = 82,
            ACTIVITY_CATCH_STREAK_BONUS = 86,
            ACTIVITY_TAPPABLE_POKEMON_ENCOUNTER = 94
        }

        enum HoloBadgeType {
            BADGE_UNSET = 0,
            BADGE_TRAVEL_KM = 1,
            BADGE_POKEDEX_ENTRIES = 2,
            BADGE_CAPTURE_TOTAL = 3,
            BADGE_DEFEATED_FORT = 4,
            BADGE_EVOLVED_TOTAL = 5,
            BADGE_HATCHED_TOTAL = 6,
            BADGE_ENCOUNTERED_TOTAL = 7,
            BADGE_POKESTOPS_VISITED = 8,
            BADGE_UNIQUE_POKESTOPS = 9,
            BADGE_POKEBALL_THROWN = 10,
            BADGE_BIG_MAGIKARP = 11,
            BADGE_DEPLOYED_TOTAL = 12,
            BADGE_BATTLE_ATTACK_WON = 13,
            BADGE_BATTLE_TRAINING_WON = 14,
            BADGE_BATTLE_DEFEND_WON = 15,
            BADGE_PRESTIGE_RAISED = 16,
            BADGE_PRESTIGE_DROPPED = 17,
            BADGE_TYPE_NORMAL = 18,
            BADGE_TYPE_FIGHTING = 19,
            BADGE_TYPE_FLYING = 20,
            BADGE_TYPE_POISON = 21,
            BADGE_TYPE_GROUND = 22,
            BADGE_TYPE_ROCK = 23,
            BADGE_TYPE_BUG = 24,
            BADGE_TYPE_GHOST = 25,
            BADGE_TYPE_STEEL = 26,
            BADGE_TYPE_FIRE = 27,
            BADGE_TYPE_WATER = 28,
            BADGE_TYPE_GRASS = 29,
            BADGE_TYPE_ELECTRIC = 30,
            BADGE_TYPE_PSYCHIC = 31,
            BADGE_TYPE_ICE = 32,
            BADGE_TYPE_DRAGON = 33,
            BADGE_TYPE_DARK = 34,
            BADGE_TYPE_FAIRY = 35,
            BADGE_SMALL_RATTATA = 36,
            BADGE_PIKACHU = 37,
            BADGE_UNOWN = 38,
            BADGE_POKEDEX_ENTRIES_GEN2 = 39,
            BADGE_RAID_BATTLE_WON = 40,
            BADGE_LEGENDARY_BATTLE_WON = 41,
            BADGE_BERRIES_FED = 42,
            BADGE_HOURS_DEFENDED = 43,
            BADGE_PLACE_HOLDER = 44,
            BADGE_POKEDEX_ENTRIES_GEN3 = 45,
            BADGE_CHALLENGE_QUESTS = 46,
            BADGE_MEW_ENCOUNTER = 47,
            BADGE_MAX_LEVEL_FRIENDS = 48,
            BADGE_TRADING = 49,
            BADGE_TRADING_DISTANCE = 50,
            BADGE_POKEDEX_ENTRIES_GEN4 = 51,
            BADGE_GREAT_LEAGUE = 52,
            BADGE_ULTRA_LEAGUE = 53,
            BADGE_MASTER_LEAGUE = 54,
            BADGE_PHOTOBOMB = 55,
            BADGE_POKEDEX_ENTRIES_GEN5 = 56,
            BADGE_POKEMON_PURIFIED = 57,
            BADGE_ROCKET_GRUNTS_DEFEATED = 58,
            BADGE_ROCKET_GIOVANNI_DEFEATED = 59,
            BADGE_BUDDY_BEST = 60,
            BADGE_POKEDEX_ENTRIES_GEN6 = 61,
            BADGE_POKEDEX_ENTRIES_GEN7 = 62,
            BADGE_POKEDEX_ENTRIES_GEN8 = 63,
            BADGE_7_DAY_STREAKS = 64,
            BADGE_UNIQUE_RAID_BOSSES_DEFEATED = 65,
            BADGE_RAIDS_WITH_FRIENDS = 66,
            BADGE_POKEMON_CAUGHT_AT_YOUR_LURES = 67,
            BADGE_WAYFARER = 68,
            BADGE_TOTAL_MEGA_EVOS = 69,
            BADGE_UNIQUE_MEGA_EVOS = 70,
            DEPRECATED_0 = 71,
            BADGE_ROUTE_ACCEPTED = 72,
            BADGE_TRAINERS_REFERRED = 73,
            BADGE_POKESTOPS_SCANNED = 74,
            BADGE_RAID_BATTLE_STAT = 76,
            BADGE_TOTAL_ROUTE_PLAY = 77,
            BADGE_UNIQUE_ROUTE_PLAY = 78,
            BADGE_POKEDEX_ENTRIES_GEN8A = 79,
            BADGE_CAPTURE_SMALL_POKEMON = 80,
            BADGE_CAPTURE_LARGE_POKEMON = 81,
            BADGE_POKEDEX_ENTRIES_GEN9 = 82,
            BADGE_PARTY_CHALLENGES_COMPLETED = 83,
            BADGE_PARTY_BOOSTS_CONTRIBUTED = 84,
            BADGE_CHECK_INS = 85,
            BADGE_BREAD_BATTLES_ENTERED = 86,
            BADGE_BREAD_BATTLES_WON = 87,
            BADGE_BREAD_BATTLES_DOUGH_WON = 88,
            BADGE_BREAD_UNIQUE = 89,
            BADGE_BREAD_DOUGH_UNIQUE = 90,
            BADGE_DYNAMIC_MIN = 1000,
            BADGE_MINI_COLLECTION = 1002,
            BADGE_BUTTERFLY_COLLECTOR = 1003,
            BADGE_MAX_SIZE_FIRST_PLACE_WIN = 1004,
            BADGE_STAMP_RALLY = 1005,
            BADGE_EVENT_MIN = 2000,
            BADGE_CHICAGO_FEST_JULY_2017 = 2001,
            BADGE_PIKACHU_OUTBREAK_YOKOHAMA_2017 = 2002,
            BADGE_SAFARI_ZONE_EUROPE_2017 = 2003,
            BADGE_SAFARI_ZONE_EUROPE_2017_10_07 = 2004,
            BADGE_SAFARI_ZONE_EUROPE_2017_10_14 = 2005,
            BADGE_CHICAGO_FEST_JULY_2018_SAT_NORTH = 2006,
            BADGE_CHICAGO_FEST_JULY_2018_SAT_SOUTH = 2007,
            BADGE_CHICAGO_FEST_JULY_2018_SUN_NORTH = 2008,
            BADGE_CHICAGO_FEST_JULY_2018_SUN_SOUTH = 2009,
            BADGE_APAC_PARTNER_JULY_2018_0 = 2010,
            BADGE_APAC_PARTNER_JULY_2018_1 = 2011,
            BADGE_APAC_PARTNER_JULY_2018_2 = 2012,
            BADGE_APAC_PARTNER_JULY_2018_3 = 2013,
            BADGE_APAC_PARTNER_JULY_2018_4 = 2014,
            BADGE_APAC_PARTNER_JULY_2018_5 = 2015,
            BADGE_APAC_PARTNER_JULY_2018_6 = 2016,
            BADGE_APAC_PARTNER_JULY_2018_7 = 2017,
            BADGE_APAC_PARTNER_JULY_2018_8 = 2018,
            BADGE_APAC_PARTNER_JULY_2018_9 = 2019,
            BADGE_YOKOSUKA_29_AUG_2018_MIKASA = 2020,
            BADGE_YOKOSUKA_29_AUG_2018_VERNY = 2021,
            BADGE_YOKOSUKA_29_AUG_2018_KURIHAMA = 2022,
            BADGE_YOKOSUKA_30_AUG_2018_MIKASA = 2023,
            BADGE_YOKOSUKA_30_AUG_2018_VERNY = 2024,
            BADGE_YOKOSUKA_30_AUG_2018_KURIHAMA = 2025,
            BADGE_YOKOSUKA_31_AUG_2018_MIKASA = 2026,
            BADGE_YOKOSUKA_31_AUG_2018_VERNY = 2027,
            BADGE_YOKOSUKA_31_AUG_2018_KURIHAMA = 2028,
            BADGE_YOKOSUKA_1_SEP_2018_MIKASA = 2029,
            BADGE_YOKOSUKA_1_SEP_2018_VERNY = 2030,
            BADGE_YOKOSUKA_1_SEP_2018_KURIHAMA = 2031,
            BADGE_YOKOSUKA_2_SEP_2018_MIKASA = 2032,
            BADGE_YOKOSUKA_2_SEP_2018_VERNY = 2033,
            BADGE_YOKOSUKA_2_SEP_2018_KURIHAMA = 2034,
            BADGE_TOP_BANANA_1 = 2035,
            BADGE_TOP_BANANA_2 = 2036,
            BADGE_TOP_BANANA_3 = 2037,
            BADGE_PARTNER_EVENT_2019_0 = 2038,
            BADGE_PARTNER_EVENT_2019_1 = 2039,
            BADGE_PARTNER_EVENT_2019_2 = 2040,
            BADGE_PARTNER_EVENT_2019_3 = 2041,
            BADGE_PARTNER_EVENT_2019_4 = 2042,
            BADGE_PARTNER_EVENT_2019_5 = 2043,
            BADGE_PARTNER_EVENT_2019_6 = 2044,
            BADGE_PARTNER_EVENT_2019_7 = 2045,
            BADGE_PARTNER_EVENT_2019_8 = 2046,
            BADGE_PARTNER_EVENT_2019_9 = 2047,
            BADGE_SENTOSA_18_APR_2019 = 2048,
            BADGE_SENTOSA_19_APR_2019 = 2049,
            BADGE_SENTOSA_20_APR_2019 = 2050,
            BADGE_SENTOSA_21_APR_2019 = 2051,
            BADGE_SENTOSA_22_APR_2019 = 2052,
            BADGE_CITY_EXPLORER_PASS_00 = 2053,
            BADGE_CITY_EXPLORER_PASS_01 = 2054,
            BADGE_CITY_EXPLORER_PASS_02 = 2055,
            BADGE_CITY_EXPLORER_PASS_03 = 2056,
            BADGE_CITY_EXPLORER_PASS_04 = 2057,
            BADGE_CITY_EXPLORER_PASS_05 = 2058,
            BADGE_CITY_EXPLORER_PASS_06 = 2059,
            BADGE_CITY_EXPLORER_PASS_07 = 2060,
            BADGE_CITY_EXPLORER_PASS_08 = 2061,
            BADGE_CITY_EXPLORER_PASS_09 = 2062,
            BADGE_CITY_EXPLORER_PASS_10 = 2063,
            BADGE_CITY_EXPLORER_PASS_11 = 2064,
            BADGE_CITY_EXPLORER_PASS_12 = 2065,
            BADGE_CITY_EXPLORER_PASS_13 = 2066,
            BADGE_CITY_EXPLORER_PASS_14 = 2067,
            BADGE_CITY_EXPLORER_PASS_15 = 2068,
            BADGE_CITY_EXPLORER_PASS_16 = 2069,
            BADGE_CITY_EXPLORER_PASS_17 = 2070,
            BADGE_CITY_EXPLORER_PASS_18 = 2071,
            BADGE_CITY_EXPLORER_PASS_19 = 2072,
            BADGE_CITY_EXPLORER_PASS_20 = 2073,
            BADGE_CITY_EXPLORER_PASS_21 = 2074,
            BADGE_CITY_EXPLORER_PASS_22 = 2075,
            BADGE_CITY_EXPLORER_PASS_23 = 2076,
            BADGE_CITY_EXPLORER_PASS_24 = 2077,
            BADGE_CITY_EXPLORER_PASS_25 = 2078,
            BADGE_CITY_EXPLORER_PASS_26 = 2079,
            BADGE_CITY_EXPLORER_PASS_27 = 2080,
            BADGE_CITY_EXPLORER_PASS_28 = 2081,
            BADGE_CITY_EXPLORER_PASS_29 = 2082,
            BADGE_CITY_EXPLORER_PASS_30 = 2083,
            BADGE_CITY_EXPLORER_PASS_31 = 2084,
            BADGE_CITY_EXPLORER_PASS_32 = 2085,
            BADGE_CITY_EXPLORER_PASS_33 = 2086,
            BADGE_CITY_EXPLORER_PASS_34 = 2087,
            BADGE_CITY_EXPLORER_PASS_35 = 2088,
            BADGE_CITY_EXPLORER_PASS_36 = 2089,
            BADGE_CITY_EXPLORER_PASS_37 = 2090,
            BADGE_CITY_EXPLORER_PASS_38 = 2091,
            BADGE_CITY_EXPLORER_PASS_39 = 2092,
            BADGE_CITY_EXPLORER_PASS_40 = 2093,
            BADGE_AIR_ADVENTURES_OKINAWA_00 = 2094,
            BADGE_AIR_ADVENTURES_OKINAWA_RELEASE = 2095,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_00_EARLYACCESS = 2096,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_00_GENERAL = 2097,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_01_EARLYACCESS = 2098,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_01_GENERAL = 2099,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_02_EARLYACCESS = 2100,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_02_GENERAL = 2101,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_03_EARLYACCESS = 2102,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_03_GENERAL = 2103,
            BADGE_DYNAMIC_EVENT_MIN = 5000,
            BADGE_GOFEST_2019_AMERICAS_DAY_00_NORTH_GENERAL = 5001,
            BADGE_GOFEST_2019_AMERICAS_DAY_00_NORTH_EARLYACCESS = 5002,
            BADGE_GOFEST_2019_AMERICAS_DAY_00_SOUTH_GENERAL = 5003,
            BADGE_GOFEST_2019_AMERICAS_DAY_00_SOUTH_EARLYACCESS = 5004,
            BADGE_GOFEST_2019_AMERICAS_DAY_01_NORTH_GENERAL = 5005,
            BADGE_GOFEST_2019_AMERICAS_DAY_01_NORTH_EARLYACCESS = 5006,
            BADGE_GOFEST_2019_AMERICAS_DAY_01_SOUTH_GENERAL = 5007,
            BADGE_GOFEST_2019_AMERICAS_DAY_01_SOUTH_EARLYACCESS = 5008,
            BADGE_GOFEST_2019_AMERICAS_DAY_02_NORTH_GENERAL = 5009,
            BADGE_GOFEST_2019_AMERICAS_DAY_02_NORTH_EARLYACCESS = 5010,
            BADGE_GOFEST_2019_AMERICAS_DAY_02_SOUTH_GENERAL = 5011,
            BADGE_GOFEST_2019_AMERICAS_DAY_02_SOUTH_EARLYACCESS = 5012,
            BADGE_GOFEST_2019_AMERICAS_DAY_03_NORTH_GENERAL = 5013,
            BADGE_GOFEST_2019_AMERICAS_DAY_03_NORTH_EARLYACCESS = 5014,
            BADGE_GOFEST_2019_AMERICAS_DAY_03_SOUTH_GENERAL = 5015,
            BADGE_GOFEST_2019_AMERICAS_DAY_03_SOUTH_EARLYACCESS = 5016,
            BADGE_GOFEST_2019_AMERICAS_DAY_04_NORTH_GENERAL = 5017,
            BADGE_GOFEST_2019_AMERICAS_DAY_04_NORTH_EARLYACCESS = 5018,
            BADGE_GOFEST_2019_AMERICAS_DAY_04_SOUTH_GENERAL = 5019,
            BADGE_GOFEST_2019_AMERICAS_DAY_04_SOUTH_EARLYACCESS = 5020,
            BADGE_GOFEST_2019_EMEA_DAY_00_GENERAL = 5021,
            BADGE_GOFEST_2019_EMEA_DAY_00_EARLYACCESS = 5022,
            BADGE_GOFEST_2019_EMEA_DAY_01_GENERAL = 5023,
            BADGE_GOFEST_2019_EMEA_DAY_01_EARLYACCESS = 5024,
            BADGE_GOFEST_2019_EMEA_DAY_02_GENERAL = 5025,
            BADGE_GOFEST_2019_EMEA_DAY_02_EARLYACCESS = 5026,
            BADGE_GOFEST_2019_EMEA_DAY_03_GENERAL = 5027,
            BADGE_GOFEST_2019_EMEA_DAY_03_EARLYACCESS = 5028,
            BADGE_GOFEST_2019_EMEA_DAY_04_GENERAL = 5029,
            BADGE_GOFEST_2019_EMEA_DAY_04_EARLYACCESS = 5030,
            BADGE_GOFEST_2019_APAC_DAY_00_GENERAL = 5031,
            BADGE_GOFEST_2019_APAC_DAY_01_GENERAL = 5032,
            BADGE_GOFEST_2019_APAC_DAY_02_GENERAL = 5033,
            BADGE_GOFEST_2019_APAC_DAY_03_GENERAL = 5034,
            BADGE_GOFEST_2019_APAC_DAY_04_GENERAL = 5035,
            BADGE_GOFEST_2019_APAC_DAY_05_GENERAL = 5036,
            BADGE_GOFEST_2019_APAC_DAY_06_GENERAL = 5037,
            BADGE_GOFEST_2019_APAC_DAY_07_GENERAL = 5038,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_00_GENERAL = 5039,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_00_EARLYACCESS = 5040,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_01_GENERAL = 5041,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_01_EARLYACCESS = 5042,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_02_GENERAL = 5043,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_02_EARLYACCESS = 5044,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_03_GENERAL = 5045,
            BADGE_SAFARIZONE_2019_MONTREAL_DAY_03_EARLYACCESS = 5046,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_00_GENERAL = 5047,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_00_EARLYACCESS = 5048,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_01_GENERAL = 5049,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_01_EARLYACCESS = 5050,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_02_GENERAL = 5051,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_02_EARLYACCESS = 5052,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_03_GENERAL = 5053,
            BADGE_SAFARIZONE_2020_STLOUIS_DAY_03_EARLYACCESS = 5054,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_00_GENERAL = 5055,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_00_EARLYACCESS = 5056,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_01_GENERAL = 5057,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_01_EARLYACCESS = 5058,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_02_GENERAL = 5059,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_02_EARLYACCESS = 5060,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_03_GENERAL = 5061,
            BADGE_SAFARIZONE_2020_LIVERPOOL_DAY_03_EARLYACCESS = 5062,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_00_GENERAL = 5063,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_00_EARLYACCESS = 5064,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_01_GENERAL = 5065,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_01_EARLYACCESS = 5066,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_02_GENERAL = 5067,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_02_EARLYACCESS = 5068,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_03_GENERAL = 5069,
            BADGE_SAFARIZONE_2020_PHILADELPHIA_DAY_03_EARLYACCESS = 5070,
            BADGE_GOFEST_2020_TEST = 5071,
            BADGE_GOFEST_2020_GLOBAL = 5072,
            BADGE_GOTOUR_2021_GREEN_TEST = 5073,
            BADGE_GOTOUR_2021_RED_TEST = 5074,
            BADGE_GOTOUR_2021_GREEN_GLOBAL = 5075,
            BADGE_GOTOUR_2021_RED_GLOBAL = 5076,
            BADGE_GLOBAL_TICKETED_EVENT = 5100,
            BADGE_EVENT_0001 = 5201,
            BADGE_EVENT_0002 = 5202,
            BADGE_EVENT_0003 = 5203,
            BADGE_EVENT_0004 = 5204,
            BADGE_EVENT_0005 = 5205,
            BADGE_EVENT_0006 = 5206,
            BADGE_EVENT_0007 = 5207,
            BADGE_EVENT_0008 = 5208,
            BADGE_EVENT_0009 = 5209,
            BADGE_EVENT_0010 = 5210,
            BADGE_EVENT_0011 = 5211,
            BADGE_EVENT_0012 = 5212,
            BADGE_EVENT_0013 = 5213,
            BADGE_EVENT_0014 = 5214,
            BADGE_EVENT_0015 = 5215,
            BADGE_EVENT_0016 = 5216,
            BADGE_EVENT_0017 = 5217,
            BADGE_EVENT_0018 = 5218,
            BADGE_EVENT_0019 = 5219,
            BADGE_EVENT_0020 = 5220,
            BADGE_EVENT_0021 = 5221,
            BADGE_EVENT_0022 = 5222,
            BADGE_EVENT_0023 = 5223,
            BADGE_EVENT_0024 = 5224,
            BADGE_EVENT_0025 = 5225,
            BADGE_EVENT_0026 = 5226,
            BADGE_EVENT_0027 = 5227,
            BADGE_EVENT_0028 = 5228,
            BADGE_EVENT_0029 = 5229,
            BADGE_EVENT_0030 = 5230,
            BADGE_LEVEL_40 = 5231,
            BADGE_GOFEST_2021_TEST = 5232,
            BADGE_GOFEST_2021_GLOBAL = 5233,
            BADGE_TRADING_CARD_0001 = 5234,
            BADGE_TRADING_CARD_0002 = 5235,
            BADGE_TRADING_CARD_0003 = 5236,
            BADGE_TRADING_CARD_0004 = 5237,
            BADGE_TRADING_CARD_0005 = 5238,
            BADGE_TRADING_CARD_0006 = 5239,
            BADGE_TRADING_CARD_0007 = 5240,
            BADGE_TRADING_CARD_0008 = 5241,
            BADGE_TRADING_CARD_0009 = 5242,
            BADGE_TRADING_CARD_0010 = 5243,
            BADGE_GOFEST_2022_TEST = 5244,
            BADGE_GOFEST_2022_GLOBAL = 5245,
            BADGE_GOTOUR_2022_GOLD_TEST = 5246,
            BADGE_GOTOUR_2022_SILVER_TEST = 5247,
            BADGE_GOTOUR_2022_GOLD_GLOBAL = 5248,
            BADGE_GOTOUR_2022_SILVER_GLOBAL = 5249,
            BADGE_GOTOUR_2022_LIVE_A_TEST = 5250,
            BADGE_GOTOUR_2022_LIVE_A_GLOBAL = 5251,
            BADGE_GOTOUR_2022_LIVE_B_TEST = 5252,
            BADGE_GOTOUR_2022_LIVE_B_GLOBAL = 5253,
            BADGE_EVENT_0031 = 5254,
            BADGE_EVENT_0032 = 5255,
            BADGE_EVENT_0033 = 5256,
            BADGE_EVENT_0034 = 5257,
            BADGE_EVENT_0035 = 5258,
            BADGE_EVENT_0036 = 5259,
            BADGE_EVENT_0037 = 5260,
            BADGE_EVENT_0038 = 5261,
            BADGE_EVENT_0039 = 5262,
            BADGE_EVENT_0040 = 5263,
            BADGE_EVENT_0041 = 5264,
            BADGE_EVENT_0042 = 5265,
            BADGE_EVENT_0043 = 5266,
            BADGE_EVENT_0044 = 5267,
            BADGE_EVENT_0045 = 5268,
            BADGE_EVENT_0046 = 5269,
            BADGE_EVENT_0047 = 5270,
            BADGE_EVENT_0048 = 5271,
            BADGE_EVENT_0049 = 5272,
            BADGE_EVENT_0050 = 5273,
            BADGE_EVENT_0051 = 5274,
            BADGE_EVENT_0052 = 5275,
            BADGE_EVENT_0053 = 5276,
            BADGE_EVENT_0054 = 5277,
            BADGE_EVENT_0055 = 5278,
            BADGE_EVENT_0056 = 5279,
            BADGE_EVENT_0057 = 5280,
            BADGE_EVENT_0058 = 5281,
            BADGE_EVENT_0059 = 5282,
            BADGE_EVENT_0060 = 5283,
            BADGE_EVENT_0061 = 5284,
            BADGE_EVENT_0062 = 5285,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_00_GENERAL = 5286,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_00_EARLYACCESS = 5287,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_01_GENERAL = 5288,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_01_EARLYACCESS = 5289,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_02_GENERAL = 5290,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_02_EARLYACCESS = 5291,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_03_GENERAL = 5292,
            BADGE_SAFARIZONE_2022_SEVILLE_DAY_03_EARLYACCESS = 5293,
            BADGE_AA_2023_JEJU_DAY_00 = 5294,
            BADGE_AA_2023_JEJU_DAY_01 = 5295,
            BADGE_AA_2023_JEJU_DAY_02 = 5296,
            BADGE_AA_2023_JEJU_DAY_03 = 5297,
            DEPRECATED_1 = 5300,
            DEPRECATED_2 = 5301,
            BADGE_GOFEST_2022_BERLIN_TEST_GENERAL = 5302,
            BADGE_GOFEST_2022_BERLIN_TEST_EARLYACCESS = 5303,
            BADGE_GOFEST_2022_BERLIN_DAY_01_GENERAL = 5304,
            BADGE_GOFEST_2022_BERLIN_DAY_01_EARLYACCESS = 5305,
            BADGE_GOFEST_2022_BERLIN_DAY_02_GENERAL = 5306,
            BADGE_GOFEST_2022_BERLIN_DAY_02_EARLYACCESS = 5307,
            BADGE_GOFEST_2022_BERLIN_DAY_03_GENERAL = 5308,
            BADGE_GOFEST_2022_BERLIN_DAY_03_EARLYACCESS = 5309,
            BADGE_GOFEST_2022_SEATTLE_TEST_PARK_MORNING = 5310,
            BADGE_GOFEST_2022_SEATTLE_TEST_PARK_AFTERNOON = 5311,
            BADGE_GOFEST_2022_SEATTLE_TEST_CITY_MORNING = 5312,
            BADGE_GOFEST_2022_SEATTLE_TEST_CITY_AFTERNOON = 5313,
            BADGE_GOFEST_2022_SEATTLE_DAY_01_PARK_MORNING = 5314,
            BADGE_GOFEST_2022_SEATTLE_DAY_01_PARK_AFTERNOON = 5315,
            BADGE_GOFEST_2022_SEATTLE_DAY_01_CITY_MORNING = 5316,
            BADGE_GOFEST_2022_SEATTLE_DAY_01_CITY_AFTERNOON = 5317,
            BADGE_GOFEST_2022_SEATTLE_DAY_02_PARK_MORNING = 5318,
            BADGE_GOFEST_2022_SEATTLE_DAY_02_PARK_AFTERNOON = 5319,
            BADGE_GOFEST_2022_SEATTLE_DAY_02_CITY_MORNING = 5320,
            BADGE_GOFEST_2022_SEATTLE_DAY_02_CITY_AFTERNOON = 5321,
            BADGE_GOFEST_2022_SEATTLE_DAY_03_PARK_MORNING = 5322,
            BADGE_GOFEST_2022_SEATTLE_DAY_03_PARK_AFTERNOON = 5323,
            BADGE_GOFEST_2022_SEATTLE_DAY_03_CITY_MORNING = 5324,
            BADGE_GOFEST_2022_SEATTLE_DAY_03_CITY_AFTERNOON = 5325,
            BADGE_GOFEST_2022_SAPPORO_TEST_PARK_MORNING = 5326,
            BADGE_GOFEST_2022_SAPPORO_TEST_PARK_AFTERNOON = 5327,
            BADGE_GOFEST_2022_SAPPORO_TEST_CITY_MORNING = 5328,
            BADGE_GOFEST_2022_SAPPORO_TEST_CITY_AFTERNOON = 5329,
            BADGE_GOFEST_2022_SAPPORO_DAY_01_PARK_MORNING = 5330,
            BADGE_GOFEST_2022_SAPPORO_DAY_01_PARK_AFTERNOON = 5331,
            BADGE_GOFEST_2022_SAPPORO_DAY_01_CITY_MORNING = 5332,
            BADGE_GOFEST_2022_SAPPORO_DAY_01_CITY_AFTERNOON = 5333,
            BADGE_GOFEST_2022_SAPPORO_DAY_02_PARK_MORNING = 5334,
            BADGE_GOFEST_2022_SAPPORO_DAY_02_PARK_AFTERNOON = 5335,
            BADGE_GOFEST_2022_SAPPORO_DAY_02_CITY_MORNING = 5336,
            BADGE_GOFEST_2022_SAPPORO_DAY_02_CITY_AFTERNOON = 5337,
            BADGE_GOFEST_2022_SAPPORO_DAY_03_PARK_MORNING = 5338,
            BADGE_GOFEST_2022_SAPPORO_DAY_03_PARK_AFTERNOON = 5339,
            BADGE_GOFEST_2022_SAPPORO_DAY_03_CITY_MORNING = 5340,
            BADGE_GOFEST_2022_SAPPORO_DAY_03_CITY_AFTERNOON = 5341,
            BADGE_GOFEST_2022_BERLIN_ADDON_HATCH_TEST = 5342,
            BADGE_GOFEST_2022_BERLIN_ADDON_HATCH = 5343,
            BADGE_GOFEST_2022_BERLIN_ADDON_RAID_TEST = 5344,
            BADGE_GOFEST_2022_BERLIN_ADDON_RAID = 5345,
            BADGE_GOFEST_2022_SEATTLE_ADDON_HATCH_TEST = 5346,
            BADGE_GOFEST_2022_SEATTLE_ADDON_HATCH = 5347,
            BADGE_GOFEST_2022_SEATTLE_ADDON_RAID_TEST = 5348,
            BADGE_GOFEST_2022_SEATTLE_ADDON_RAID = 5349,
            BADGE_GOFEST_2022_SAPPORO_ADDON_HATCH_TEST = 5350,
            BADGE_GOFEST_2022_SAPPORO_ADDON_HATCH = 5351,
            BADGE_GOFEST_2022_SAPPORO_ADDON_RAID_TEST = 5352,
            BADGE_GOFEST_2022_SAPPORO_ADDON_RAID = 5353,
            BADGE_EVENT_0063 = 5354,
            BADGE_EVENT_0064 = 5355,
            BADGE_EVENT_0065 = 5356,
            BADGE_EVENT_0066 = 5357,
            BADGE_EVENT_0067 = 5358,
            BADGE_EVENT_0068 = 5359,
            BADGE_EVENT_0069 = 5360,
            BADGE_EVENT_0070 = 5361,
            BADGE_EVENT_0071 = 5362,
            BADGE_EVENT_0072 = 5363,
            BADGE_EVENT_0073 = 5364,
            BADGE_EVENT_0074 = 5365,
            BADGE_EVENT_0075 = 5366,
            BADGE_EVENT_0076 = 5367,
            BADGE_EVENT_0077 = 5368,
            BADGE_EVENT_0078 = 5369,
            BADGE_EVENT_0079 = 5370,
            BADGE_EVENT_0080 = 5371,
            BADGE_EVENT_0081 = 5372,
            BADGE_EVENT_0082 = 5373,
            BADGE_EVENT_0083 = 5374,
            BADGE_EVENT_0084 = 5375,
            BADGE_EVENT_0085 = 5376,
            BADGE_EVENT_0086 = 5377,
            BADGE_EVENT_0087 = 5378,
            BADGE_EVENT_0088 = 5379,
            BADGE_EVENT_0089 = 5380,
            BADGE_EVENT_0090 = 5381,
            BADGE_EVENT_0091 = 5382,
            BADGE_EVENT_0092 = 5383,
            BADGE_EVENT_0093 = 5384,
            BADGE_EVENT_0094 = 5385,
            BADGE_EVENT_0095 = 5386,
            BADGE_EVENT_0096 = 5387,
            BADGE_EVENT_0097 = 5388,
            BADGE_EVENT_0098 = 5389,
            BADGE_EVENT_0099 = 5390,
            BADGE_EVENT_0100 = 5391,
            BADGE_EVENT_0101 = 5392,
            BADGE_EVENT_0102 = 5393,
            BADGE_EVENT_0103 = 5394,
            BADGE_EVENT_0104 = 5395,
            BADGE_EVENT_0105 = 5396,
            BADGE_EVENT_0106 = 5397,
            BADGE_EVENT_0107 = 5398,
            BADGE_EVENT_0108 = 5399,
            BADGE_EVENT_0109 = 5400,
            BADGE_EVENT_0110 = 5401,
            BADGE_EVENT_0111 = 5402,
            BADGE_EVENT_0112 = 5403,
            BADGE_EVENT_0113 = 5404,
            BADGE_EVENT_0114 = 5405,
            BADGE_EVENT_0115 = 5406,
            BADGE_EVENT_0116 = 5407,
            BADGE_EVENT_0117 = 5408,
            BADGE_EVENT_0118 = 5409,
            BADGE_EVENT_0119 = 5410,
            BADGE_EVENT_0120 = 5411,
            BADGE_EVENT_0121 = 5412,
            BADGE_EVENT_0122 = 5413,
            BADGE_EVENT_0123 = 5414,
            BADGE_EVENT_0124 = 5415,
            BADGE_EVENT_0125 = 5416,
            BADGE_EVENT_0126 = 5417,
            BADGE_EVENT_0127 = 5418,
            BADGE_EVENT_0128 = 5419,
            BADGE_EVENT_0129 = 5420,
            BADGE_EVENT_0130 = 5421,
            BADGE_EVENT_0131 = 5422,
            BADGE_EVENT_0132 = 5423,
            BADGE_EVENT_0133 = 5424,
            BADGE_EVENT_0134 = 5425,
            BADGE_EVENT_0135 = 5426,
            BADGE_EVENT_0136 = 5427,
            BADGE_EVENT_0137 = 5428,
            BADGE_EVENT_0138 = 5429,
            BADGE_EVENT_0139 = 5430,
            BADGE_EVENT_0140 = 5431,
            BADGE_EVENT_0141 = 5432,
            BADGE_EVENT_0142 = 5433,
            BADGE_EVENT_0143 = 5434,
            BADGE_EVENT_0144 = 5435,
            BADGE_EVENT_0145 = 5436,
            BADGE_EVENT_0146 = 5437,
            BADGE_EVENT_0147 = 5438,
            BADGE_EVENT_0148 = 5439,
            BADGE_EVENT_0149 = 5440,
            BADGE_EVENT_0150 = 5441,
            BADGE_EVENT_0151 = 5442,
            BADGE_EVENT_0152 = 5443,
            BADGE_EVENT_0153 = 5444,
            BADGE_EVENT_0154 = 5445,
            BADGE_EVENT_0155 = 5446,
            BADGE_EVENT_0156 = 5447,
            BADGE_EVENT_0157 = 5448,
            BADGE_EVENT_0158 = 5449,
            BADGE_EVENT_0159 = 5450,
            BADGE_EVENT_0160 = 5451,
            BADGE_EVENT_0161 = 5452,
            BADGE_EVENT_0162 = 5453,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_00_EARLYACCESS = 5454,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_00_GENERAL = 5455,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_01_EARLYACCESS = 5456,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_01_GENERAL = 5457,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_02_EARLYACCESS = 5458,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_02_GENERAL = 5459,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_03_EARLYACCESS = 5460,
            BADGE_SAFARIZONE_2022_TAIPEI_DAY_03_GENERAL = 5461,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_00_EARLYACCESS_TEST = 5462,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_00_GENERAL_TEST = 5463,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_01_EARLYACCESS_TEST = 5464,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_01_GENERAL_TEST = 5465,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_02_EARLYACCESS_TEST = 5466,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_02_GENERAL_TEST = 5467,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_03_EARLYACCESS_TEST = 5468,
            BADGE_SAFARIZONE_2022_SINGAPORE_DAY_03_GENERAL_TEST = 5469,
            BADGE_GOTOUR_2023_RUBY_TEST = 5470,
            BADGE_GOTOUR_2023_SAPPHIRE_TEST = 5471,
            BADGE_GOTOUR_2023_RUBY_GLOBAL = 5472,
            BADGE_GOTOUR_2023_SAPPHIRE_GLOBAL = 5473,
            BADGE_GOTOUR_LIVE_2023_DAY_00 = 5474,
            BADGE_GOTOUR_LIVE_2023_DAY_01 = 5475,
            BADGE_GOTOUR_LIVE_2023_DAY_02 = 5476,
            BADGE_GOTOUR_2023_HATCH_ADDON_TEST = 5477,
            BADGE_GOTOUR_2023_RAID_ADDON_TEST = 5478,
            BADGE_GOTOUR_2023_HATCH_ADDON = 5479,
            BADGE_GOTOUR_2023_RAID_ADDON = 5480,
            BADGE_GOFEST_2023_OSAKA_DAY1_CITY = 5481,
            BADGE_GOFEST_2023_OSAKA_DAY2_CITY = 5482,
            BADGE_GOFEST_2023_OSAKA_DAY3_CITY = 5483,
            BADGE_GOFEST_2023_OSAKA_DAY1_EXTENDED = 5484,
            BADGE_GOFEST_2023_OSAKA_DAY2_EXTENDED = 5485,
            BADGE_GOFEST_2023_OSAKA_DAY3_EXTENDED = 5486,
            BADGE_GOFEST_2023_OSAKA_DAY1_PARK_MORNING = 5487,
            BADGE_GOFEST_2023_OSAKA_DAY2_PARK_MORNING = 5488,
            BADGE_GOFEST_2023_OSAKA_DAY3_PARK_MORNING = 5489,
            BADGE_GOFEST_2023_OSAKA_DAY1_PARK_AFTERNOON = 5490,
            BADGE_GOFEST_2023_OSAKA_DAY2_PARK_AFTERNOON = 5491,
            BADGE_GOFEST_2023_OSAKA_DAY3_PARK_AFTERNOON = 5492,
            BADGE_GOFEST_2023_OSAKA_ADDON_HATCH = 5493,
            BADGE_GOFEST_2023_OSAKA_ADDON_RAID = 5494,
            BADGE_GOFEST_2023_OSAKA_VIP = 5495,
            BADGE_GOFEST_2023_OSAKA_ADDON_HATCH_TEST = 5496,
            BADGE_GOFEST_2023_OSAKA_ADDON_RAID_TEST = 5497,
            BADGE_GOFEST_2023_OSAKA_PARK_TEST = 5498,
            BADGE_GOFEST_2023_OSAKA_PARK_2_TEST = 5499,
            BADGE_GOFEST_2023_OSAKA_CITY_TEST = 5500,
            BADGE_GOFEST_2023_OSAKA_CITY_2_TEST = 5501,
            BADGE_GOFEST_2023_LONDON_DAY1_CITY = 5502,
            BADGE_GOFEST_2023_LONDON_DAY2_CITY = 5503,
            BADGE_GOFEST_2023_LONDON_DAY3_CITY = 5504,
            BADGE_GOFEST_2023_LONDON_DAY1_EXTENDED = 5505,
            BADGE_GOFEST_2023_LONDON_DAY2_EXTENDED = 5506,
            BADGE_GOFEST_2023_LONDON_DAY3_EXTENDED = 5507,
            BADGE_GOFEST_2023_LONDON_DAY1_PARK_MORNING = 5508,
            BADGE_GOFEST_2023_LONDON_DAY2_PARK_MORNING = 5509,
            BADGE_GOFEST_2023_LONDON_DAY3_PARK_MORNING = 5510,
            BADGE_GOFEST_2023_LONDON_DAY1_PARK_AFTERNOON = 5511,
            BADGE_GOFEST_2023_LONDON_DAY2_PARK_AFTERNOON = 5512,
            BADGE_GOFEST_2023_LONDON_DAY3_PARK_AFTERNOON = 5513,
            BADGE_GOFEST_2023_LONDON_ADDON_HATCH = 5514,
            BADGE_GOFEST_2023_LONDON_ADDON_RAID = 5515,
            BADGE_GOFEST_2023_LONDON_VIP = 5516,
            BADGE_GOFEST_2023_LONDON_ADDON_HATCH_TEST = 5517,
            BADGE_GOFEST_2023_LONDON_ADDON_RAID_TEST = 5518,
            BADGE_GOFEST_2023_LONDON_PARK_TEST = 5519,
            BADGE_GOFEST_2023_LONDON_PARK_2_TEST = 5520,
            BADGE_GOFEST_2023_LONDON_CITY_TEST = 5521,
            BADGE_GOFEST_2023_LONDON_CITY_2_TEST = 5522,
            BADGE_GOFEST_2023_NEWYORK_DAY1_CITY = 5523,
            BADGE_GOFEST_2023_NEWYORK_DAY2_CITY = 5524,
            BADGE_GOFEST_2023_NEWYORK_DAY3_CITY = 5525,
            BADGE_GOFEST_2023_NEWYORK_DAY1_EXTENDED = 5526,
            BADGE_GOFEST_2023_NEWYORK_DAY2_EXTENDED = 5527,
            BADGE_GOFEST_2023_NEWYORK_DAY3_EXTENDED = 5528,
            BADGE_GOFEST_2023_NEWYORK_DAY1_PARK_MORNING = 5529,
            BADGE_GOFEST_2023_NEWYORK_DAY2_PARK_MORNING = 5530,
            BADGE_GOFEST_2023_NEWYORK_DAY3_PARK_MORNING = 5531,
            BADGE_GOFEST_2023_NEWYORK_DAY1_PARK_AFTERNOON = 5532,
            BADGE_GOFEST_2023_NEWYORK_DAY2_PARK_AFTERNOON = 5533,
            BADGE_GOFEST_2023_NEWYORK_DAY3_PARK_AFTERNOON = 5534,
            BADGE_GOFEST_2023_NEWYORK_ADDON_HATCH = 5535,
            BADGE_GOFEST_2023_NEWYORK_ADDON_RAID = 5536,
            BADGE_GOFEST_2023_NEWYORK_VIP = 5537,
            BADGE_GOFEST_2023_NEWYORK_ADDON_HATCH_TEST = 5538,
            BADGE_GOFEST_2023_NEWYORK_ADDON_RAID_TEST = 5539,
            BADGE_GOFEST_2023_NEWYORK_PARK_TEST = 5540,
            BADGE_GOFEST_2023_NEWYORK_PARK_2_TEST = 5541,
            BADGE_GOFEST_2023_NEWYORK_CITY_TEST = 5542,
            BADGE_GOFEST_2023_NEWYORK_CITY_2_TEST = 5543,
            BADGE_GOFEST_2023_GLOBAL = 5544,
            BADGE_GOFEST_2023_TEST = 5545,
            BADGE_SAFARI_2023_SEOUL_DAY_00 = 5546,
            BADGE_SAFARI_2023_SEOUL_DAY_01 = 5547,
            BADGE_SAFARI_2023_SEOUL_DAY_02 = 5548,
            BADGE_SAFARI_2023_SEOUL_ADD_ON_HATCH = 5549,
            BADGE_SAFARI_2023_SEOUL_ADD_ON_RAID = 5550,
            BADGE_SAFARI_2023_BARCELONA_DAY_00 = 5551,
            BADGE_SAFARI_2023_BARCELONA_DAY_01 = 5552,
            BADGE_SAFARI_2023_BARCELONA_DAY_02 = 5553,
            BADGE_SAFARI_2023_BARCELONA_ADD_ON_HATCH = 5554,
            BADGE_SAFARI_2023_BARCELONA_ADD_ON_RAID = 5555,
            BADGE_SAFARI_2023_MEXCITY_DAY_00 = 5556,
            BADGE_SAFARI_2023_MEXCITY_DAY_01 = 5557,
            BADGE_SAFARI_2023_MEXCITY_DAY_02 = 5558,
            BADGE_SAFARI_2023_MEXCITY_ADD_ON_HATCH = 5559,
            BADGE_SAFARI_2023_MEXCITY_ADD_ON_RAID = 5560,
            BADGE_GOTOUR_2024_DIAMOND_TEST = 5561,
            BADGE_GOTOUR_2024_PEARL_TEST = 5562,
            BADGE_GOTOUR_2024_DIAMOND = 5563,
            BADGE_GOTOUR_2024_PEARL = 5564,
            BADGE_GOTOUR_2024_SECRET_00 = 5565,
            BADGE_GOTOUR_2024_SECRET_01 = 5566,
            BADGE_GOTOUR_2024_SECRET_02 = 5567,
            BADGE_GOTOUR_2024_SECRET_03 = 5568,
            BADGE_GOTOUR_LIVE_2024_TEST_PARK = 5569,
            BADGE_GOTOUR_LIVE_2024_TEST_CITY = 5570,
            BADGE_GOTOUR_LIVE_2024_DAY_PREVIEW = 5571,
            BADGE_GOTOUR_LIVE_2024_DAY_01_PARK = 5572,
            BADGE_GOTOUR_LIVE_2024_DAY_01_CITY = 5573,
            BADGE_GOTOUR_LIVE_2024_DAY_02_PARK = 5574,
            BADGE_GOTOUR_LIVE_2024_DAY_02_CITY = 5575,
            BADGE_GOTOUR_LIVE_2024_TEST_ADDON_HATCH = 5576,
            BADGE_GOTOUR_LIVE_2024_TEST_ADDON_RAID = 5577,
            BADGE_GOTOUR_LIVE_2024_ADDON_HATCH = 5578,
            BADGE_GOTOUR_LIVE_2024_ADDON_RAID = 5579,
            BADGE_GOTOUR_LIVE_2024_VIP = 5580,
            BADGE_SAFARI_2024_TAINAN_DAY_00 = 5581,
            BADGE_SAFARI_2024_TAINAN_DAY_01 = 5582,
            BADGE_SAFARI_2024_TAINAN_DAY_02 = 5583,
            BADGE_SAFARI_2024_TAINAN_ADD_ON_HATCH_TEST = 5584,
            BADGE_SAFARI_2024_TAINAN_ADD_ON_RAID_TEST = 5585,
            BADGE_SAFARI_2024_TAINAN_ADD_ON_HATCH = 5586,
            BADGE_SAFARI_2024_TAINAN_ADD_ON_RAID = 5587,
            BADGE_AA_2024_BALI_DAY_00 = 5588,
            BADGE_AA_2024_BALI_DAY_01 = 5589,
            BADGE_AA_2024_BALI_DAY_02 = 5590,
            BADGE_AA_2024_BALI_DAY_03 = 5591,
            BADGE_GOFEST_2024_GLOBAL = 5592,
            BADGE_GOFEST_2024_GLOBAL_TEST = 5593,
            BADGE_GOFEST_2024_SENDAI_PREVIEW = 5594,
            BADGE_GOFEST_2024_SENDAI_DAY0_CITY = 5595,
            BADGE_GOFEST_2024_SENDAI_DAY0_EXTENDED = 5596,
            BADGE_GOFEST_2024_SENDAI_DAY0_PARK_MORNING = 5597,
            BADGE_GOFEST_2024_SENDAI_DAY0_PARK_AFTERNOON = 5598,
            BADGE_GOFEST_2024_SENDAI_DAY1_CITY = 5599,
            BADGE_GOFEST_2024_SENDAI_DAY2_CITY = 5600,
            BADGE_GOFEST_2024_SENDAI_DAY3_CITY = 5601,
            BADGE_GOFEST_2024_SENDAI_DAY4_CITY = 5602,
            BADGE_GOFEST_2024_SENDAI_DAY1_EXTENDED = 5603,
            BADGE_GOFEST_2024_SENDAI_DAY2_EXTENDED = 5604,
            BADGE_GOFEST_2024_SENDAI_DAY3_EXTENDED = 5605,
            BADGE_GOFEST_2024_SENDAI_DAY1_PARK_MORNING = 5606,
            BADGE_GOFEST_2024_SENDAI_DAY2_PARK_MORNING = 5607,
            BADGE_GOFEST_2024_SENDAI_DAY3_PARK_MORNING = 5608,
            BADGE_GOFEST_2024_SENDAI_DAY4_PARK_MORNING = 5609,
            BADGE_GOFEST_2024_SENDAI_DAY1_PARK_AFTERNOON = 5610,
            BADGE_GOFEST_2024_SENDAI_DAY2_PARK_AFTERNOON = 5611,
            BADGE_GOFEST_2024_SENDAI_DAY3_PARK_AFTERNOON = 5612,
            BADGE_GOFEST_2024_SENDAI_DAY4_PARK_AFTERNOON = 5613,
            BADGE_GOFEST_2024_SENDAI_DAY4_PARK_EXTENDED = 5614,
            BADGE_GOFEST_2024_SENDAI_ADDON_HATCH = 5615,
            BADGE_GOFEST_2024_SENDAI_ADDON_RAID = 5616,
            BADGE_GOFEST_2024_SENDAI_VIP = 5617,
            BADGE_GOFEST_2024_SENDAI_ADDON_HATCH_TEST = 5618,
            BADGE_GOFEST_2024_SENDAI_ADDON_RAID_TEST = 5619,
            BADGE_GOFEST_2024_SENDAI_PARK_TEST = 5620,
            BADGE_GOFEST_2024_SENDAI_PARK_2_TEST = 5621,
            BADGE_GOFEST_2024_SENDAI_CITY_TEST = 5622,
            BADGE_GOFEST_2024_SENDAI_CITY_2_TEST = 5623,
            BADGE_GOFEST_2024_MADRID_PREVIEW = 5624,
            BADGE_GOFEST_2024_MADRID_DAY1_CITY = 5625,
            BADGE_GOFEST_2024_MADRID_DAY2_CITY = 5626,
            BADGE_GOFEST_2024_MADRID_DAY3_CITY = 5627,
            BADGE_GOFEST_2024_MADRID_DAY1_EXTENDED = 5628,
            BADGE_GOFEST_2024_MADRID_DAY2_EXTENDED = 5629,
            BADGE_GOFEST_2024_MADRID_DAY3_EXTENDED = 5630,
            BADGE_GOFEST_2024_MADRID_DAY1_PARK_MORNING = 5631,
            BADGE_GOFEST_2024_MADRID_DAY2_PARK_MORNING = 5632,
            BADGE_GOFEST_2024_MADRID_DAY3_PARK_MORNING = 5633,
            BADGE_GOFEST_2024_MADRID_DAY1_PARK_AFTERNOON = 5634,
            BADGE_GOFEST_2024_MADRID_DAY2_PARK_AFTERNOON = 5635,
            BADGE_GOFEST_2024_MADRID_DAY3_PARK_AFTERNOON = 5636,
            BADGE_GOFEST_2024_MADRID_ADDON_HATCH = 5637,
            BADGE_GOFEST_2024_MADRID_ADDON_RAID = 5638,
            BADGE_GOFEST_2024_MADRID_VIP = 5639,
            BADGE_GOFEST_2024_MADRID_ADDON_HATCH_TEST = 5640,
            BADGE_GOFEST_2024_MADRID_ADDON_RAID_TEST = 5641,
            BADGE_GOFEST_2024_MADRID_PARK_TEST = 5642,
            BADGE_GOFEST_2024_MADRID_PARK_2_TEST = 5643,
            BADGE_GOFEST_2024_MADRID_CITY_TEST = 5644,
            BADGE_GOFEST_2024_MADRID_CITY_2_TEST = 5645,
            BADGE_GOFEST_2024_NEWYORK_PREVIEW = 5646,
            BADGE_GOFEST_2024_NEWYORK_DAY1_CITY = 5647,
            BADGE_GOFEST_2024_NEWYORK_DAY2_CITY = 5648,
            BADGE_GOFEST_2024_NEWYORK_DAY3_CITY = 5649,
            BADGE_GOFEST_2024_NEWYORK_DAY1_EXTENDED = 5650,
            BADGE_GOFEST_2024_NEWYORK_DAY2_EXTENDED = 5651,
            BADGE_GOFEST_2024_NEWYORK_DAY3_EXTENDED = 5652,
            BADGE_GOFEST_2024_NEWYORK_DAY1_PARK_MORNING = 5653,
            BADGE_GOFEST_2024_NEWYORK_DAY2_PARK_MORNING = 5654,
            BADGE_GOFEST_2024_NEWYORK_DAY3_PARK_MORNING = 5655,
            BADGE_GOFEST_2024_NEWYORK_DAY1_PARK_AFTERNOON = 5656,
            BADGE_GOFEST_2024_NEWYORK_DAY2_PARK_AFTERNOON = 5657,
            BADGE_GOFEST_2024_NEWYORK_DAY3_PARK_AFTERNOON = 5658,
            BADGE_GOFEST_2024_NEWYORK_ADDON_HATCH = 5659,
            BADGE_GOFEST_2024_NEWYORK_ADDON_RAID = 5660,
            BADGE_GOFEST_2024_NEWYORK_VIP = 5661,
            BADGE_GOFEST_2024_NEWYORK_ADDON_HATCH_TEST = 5662,
            BADGE_GOFEST_2024_NEWYORK_ADDON_RAID_TEST = 5663,
            BADGE_GOFEST_2024_NEWYORK_PARK_TEST = 5664,
            BADGE_GOFEST_2024_NEWYORK_PARK_2_TEST = 5665,
            BADGE_GOFEST_2024_NEWYORK_CITY_TEST = 5666,
            BADGE_GOFEST_2024_NEWYORK_CITY_2_TEST = 5667,
            BADGE_GOFEST_2024_PJCS_CITY = 5668,
            BADGE_GOFEST_2024_PJCS_CITY_2 = 5669,
            BADGE_GOFEST_2024_PJCS_EXTENDED = 5670,
            BADGE_GOFEST_2024_PJCS_EXTENDED_2 = 5671,
            BADGE_GOFEST_2024_PJCS_TEST = 5672,
            BADGE_AA_2024_SURABAYA_DAY_00 = 5673,
            BADGE_AA_2024_SURABAYA_DAY_01 = 5674,
            BADGE_AA_2024_SURABAYA_DAY_02 = 5675,
            BADGE_AA_2024_YOGYAKARTA_DAY_00 = 5676,
            BADGE_AA_2024_YOGYAKARTA_DAY_01 = 5677,
            BADGE_AA_2024_YOGYAKARTA_DAY_02 = 5678,
            BADGE_SAFARI_2024_JAKARTA_DAY_00 = 5679,
            BADGE_SAFARI_2024_JAKARTA_DAY_01 = 5680,
            BADGE_SAFARI_2024_JAKARTA_DAY_02 = 5681,
            BADGE_SAFARI_2024_JAKARTA_ADD_ON_HATCH = 5682,
            BADGE_SAFARI_2024_JAKARTA_ADD_ON_HATCH_TEST = 5683,
            BADGE_SAFARI_2024_JAKARTA_ADD_ON_RAID = 5684,
            BADGE_SAFARI_2024_JAKARTA_ADD_ON_RAID_TEST = 5685,
            BADGE_SAFARI_2024_INCHEON_DAY_00 = 5686,
            BADGE_SAFARI_2024_INCHEON_DAY_01 = 5687,
            BADGE_SAFARI_2024_INCHEON_DAY_02 = 5688,
            BADGE_SAFARI_2024_INCHEON_DAY_03 = 5689,
            BADGE_SAFARI_2024_INCHEON_DAY_00_CITYWIDE = 5690,
            BADGE_SAFARI_2024_INCHEON_DAY_01_CITYWIDE = 5691,
            BADGE_SAFARI_2024_INCHEON_DAY_02_CITYWIDE = 5692,
            BADGE_SAFARI_2024_INCHEON_DAY_03_CITYWIDE = 5693,
            BADGE_GOWA_2024_IRL_SATURDAY_PARK_MORNING = 5694,
            BADGE_GOWA_2024_IRL_SATURDAY_PARK_AFTERNOON = 5695,
            BADGE_GOWA_2024_IRL_SATURDAY_CITY = 5696,
            BADGE_GOWA_2024_IRL_SATURDAY_ESSENTIAL = 5697,
            BADGE_GOWA_2024_IRL_SUNDAY_PARK_MORNING = 5698,
            BADGE_GOWA_2024_IRL_SUNDAY_PARK_AFTERNOON = 5699,
            BADGE_GOWA_2024_IRL_SUNDAY_CITY = 5700,
            BADGE_GOWA_2024_IRL_SUNDAY_ESSENTIAL = 5701,
            BADGE_GOWA_2024_IRL_ADDON_HATCH = 5702,
            BADGE_GOWA_2024_IRL_ADDON_RAID = 5703,
            BADGE_GOWA_2024_IRL_TEST_PARK_MORNING = 5704,
            BADGE_GOWA_2024_IRL_TEST_PARK_AFTERNOON = 5705,
            BADGE_GOWA_2024_IRL_TEST_CITY = 5706,
            BADGE_GOWA_2024_IRL_TEST_ESSENTIAL = 5707,
            BADGE_GOWA_2024_IRL_ADDON_HATCH_TEST = 5708,
            BADGE_GOWA_2024_IRL_ADDON_RAID_TEST = 5709,
            BADGE_GOWA_2024_IRL_FULLTEST = 5710,
            BADGE_GOWA_2024_GLOBAL = 5711,
            BADGE_GOWA_2024_TEST = 5712,
            BADGE_GOWA_2024_SPECIAL_RESEARCH_A = 5713,
            BADGE_GOWA_2024_SPECIAL_RESEARCH_B = 5714,
            BADGE_SAFARI_2024_SAO_PAULO_TEST = 5715,
            BADGE_SAFARI_2024_SAO_PAULO_DAY_01 = 5716,
            BADGE_SAFARI_2024_SAO_PAULO_DAY_02 = 5717,
            BADGE_SAFARI_2024_SAO_PAULO_ADD_ON_HATCH_TEST = 5718,
            BADGE_SAFARI_2024_SAO_PAULO_ADD_ON_HATCH = 5719,
            BADGE_SAFARI_2024_SAO_PAULO_ADD_ON_RAID_TEST = 5720,
            BADGE_SAFARI_2024_SAO_PAULO_ADD_ON_RAID = 5721,
            BADGE_SAFARI_2024_HONG_KONG_TEST = 5722,
            BADGE_SAFARI_2024_HONG_KONG_DAY_01 = 5723,
            BADGE_SAFARI_2024_HONG_KONG_DAY_02 = 5724,
            BADGE_SAFARI_2024_HONG_KONG_ADD_ON_HATCH_TEST = 5725,
            BADGE_SAFARI_2024_HONG_KONG_ADD_ON_HATCH = 5726,
            BADGE_SAFARI_2024_HONG_KONG_ADD_ON_RAID_TEST = 5727,
            BADGE_SAFARI_2024_HONG_KONG_ADD_ON_RAID = 5728,
            BADGE_GO_TOUR_2025_LOS_ANGELES_TEST_PARK = 5729,
            BADGE_GO_TOUR_2025_LOS_ANGELES_TEST_CITY = 5730,
            BADGE_GO_TOUR_2025_LOS_ANGELES_TEST_ALL_DAY_BONUSES = 5731,
            BADGE_GO_TOUR_2025_LOS_ANGELES_FRIDAY_PARK = 5732,
            BADGE_GO_TOUR_2025_LOS_ANGELES_FRIDAY_CITY = 5733,
            BADGE_GO_TOUR_2025_LOS_ANGELES_FRIDAY_ALL_DAY_BONUSES = 5734,
            BADGE_GO_TOUR_2025_LOS_ANGELES_SATURDAY_PARK = 5735,
            BADGE_GO_TOUR_2025_LOS_ANGELES_SATURDAY_CITY = 5736,
            BADGE_GO_TOUR_2025_LOS_ANGELES_SATURDAY_ALL_DAY_BONUSES = 5737,
            BADGE_GO_TOUR_2025_LOS_ANGELES_SUNDAY_PARK = 5738,
            BADGE_GO_TOUR_2025_LOS_ANGELES_SUNDAY_CITY = 5739,
            BADGE_GO_TOUR_2025_LOS_ANGELES_SUNDAY_ALL_DAY_BONUSES = 5740,
            BADGE_GO_TOUR_2025_LOS_ANGELES_ADD_ON_RAID_TEST = 5741,
            BADGE_GO_TOUR_2025_LOS_ANGELES_ADD_ON_RAID = 5742,
            BADGE_GO_TOUR_2025_LOS_ANGELES_ADD_ON_HATCH_TEST = 5743,
            BADGE_GO_TOUR_2025_LOS_ANGELES_ADD_ON_HATCH = 5744,
            BADGE_GO_TOUR_2025_LOS_ANGELES_VIP = 5745,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_TEST_PARK = 5746,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_TEST_CITY = 5747,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_TEST_ALL_DAY_BONUSES = 5748,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_FRIDAY_PARK = 5749,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_FRIDAY_CITY = 5750,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_FRIDAY_ALL_DAY_BONUSES = 5751,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_SATURDAY_PARK = 5752,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_SATURDAY_CITY = 5753,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_SATURDAY_ALL_DAY_BONUSES = 5754,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_SUNDAY_PARK = 5755,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_SUNDAY_CITY = 5756,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_SUNDAY_ALL_DAY_BONUSES = 5757,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_ADD_ON_RAID_TEST = 5758,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_ADD_ON_RAID = 5759,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_ADD_ON_HATCH_TEST = 5760,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_ADD_ON_HATCH = 5761,
            BADGE_GO_TOUR_2025_NEW_TAIPEI_CITY_VIP = 5762,
            BADGE_GO_TOUR_2025_GLOBAL_BLACK_VERSION = 5763,
            BADGE_GO_TOUR_2025_GLOBAL_WHITE_VERSION = 5764,
            BADGE_SAFARI_2025_MILAN_TEST = 5768,
            BADGE_SAFARI_2025_MILAN_DAY_01 = 5769,
            BADGE_SAFARI_2025_MILAN_DAY_02 = 5770,
            BADGE_SAFARI_2025_MILAN_ADD_ON_HATCH_TEST = 5771,
            BADGE_SAFARI_2025_MILAN_ADD_ON_HATCH = 5772,
            BADGE_SAFARI_2025_MILAN_ADD_ON_RAID_TEST = 5773,
            BADGE_SAFARI_2025_MILAN_ADD_ON_RAID = 5774,
            BADGE_SAFARI_2025_MUMBAI_TEST = 5775,
            BADGE_SAFARI_2025_MUMBAI_DAY_01 = 5776,
            BADGE_SAFARI_2025_MUMBAI_DAY_02 = 5777,
            BADGE_SAFARI_2025_MUMBAI_ADD_ON_HATCH_TEST = 5778,
            BADGE_SAFARI_2025_MUMBAI_ADD_ON_HATCH = 5779,
            BADGE_SAFARI_2025_MUMBAI_ADD_ON_RAID_TEST = 5780,
            BADGE_SAFARI_2025_MUMBAI_ADD_ON_RAID = 5781,
            BADGE_SAFARI_2025_SANTIAGO_TEST = 5782,
            BADGE_SAFARI_2025_SANTIAGO_DAY_01 = 5783,
            BADGE_SAFARI_2025_SANTIAGO_DAY_02 = 5784,
            BADGE_SAFARI_2025_SANTIAGO_ADD_ON_HATCH_TEST = 5785,
            BADGE_SAFARI_2025_SANTIAGO_ADD_ON_HATCH = 5786,
            BADGE_SAFARI_2025_SANTIAGO_ADD_ON_RAID_TEST = 5787,
            BADGE_SAFARI_2025_SANTIAGO_ADD_ON_RAID = 5788,
            BADGE_SAFARI_2025_SINGAPORE_TEST = 5789,
            BADGE_SAFARI_2025_SINGAPORE_DAY_01 = 5790,
            BADGE_SAFARI_2025_SINGAPORE_DAY_02 = 5791,
            BADGE_SAFARI_2025_SINGAPORE_ADD_ON_HATCH_TEST = 5792,
            BADGE_SAFARI_2025_SINGAPORE_ADD_ON_HATCH = 5793,
            BADGE_SAFARI_2025_SINGAPORE_ADD_ON_RAID_TEST = 5794,
            BADGE_SAFARI_2025_SINGAPORE_ADD_ON_RAID = 5795,
            BADGE_EVENT_0163 = 5874,
            BADGE_EVENT_0164 = 5875,
            BADGE_EVENT_0165 = 5876,
            BADGE_EVENT_0166 = 5877,
            BADGE_EVENT_0167 = 5878,
            BADGE_EVENT_0168 = 5879,
            BADGE_EVENT_0169 = 5880,
            BADGE_EVENT_0170 = 5881,
            BADGE_EVENT_0171 = 5882,
            BADGE_EVENT_0172 = 5883,
            BADGE_EVENT_0173 = 5884,
            BADGE_EVENT_0174 = 5885,
            BADGE_EVENT_0175 = 5886,
            BADGE_EVENT_0176 = 5887,
            BADGE_EVENT_0177 = 5888,
            BADGE_EVENT_0178 = 5889,
            BADGE_EVENT_0179 = 5890,
            BADGE_EVENT_0180 = 5891,
            BADGE_EVENT_0181 = 5892,
            BADGE_EVENT_0182 = 5893,
            BADGE_EVENT_0183 = 5894,
            BADGE_EVENT_0184 = 5895,
            BADGE_EVENT_0185 = 5896,
            BADGE_EVENT_0186 = 5897,
            BADGE_EVENT_0187 = 5898,
            BADGE_EVENT_0188 = 5899,
            BADGE_EVENT_0189 = 5900,
            BADGE_EVENT_0190 = 5901,
            BADGE_EVENT_0191 = 5902,
            BADGE_EVENT_0192 = 5903,
            BADGE_EVENT_0193 = 5904,
            BADGE_EVENT_0194 = 5905,
            BADGE_EVENT_0195 = 5906,
            BADGE_EVENT_0196 = 5907,
            BADGE_EVENT_0197 = 5908,
            BADGE_EVENT_0198 = 5909,
            BADGE_EVENT_0199 = 5910,
            BADGE_EVENT_0200 = 5911,
            BADGE_EVENT_0201 = 5912,
            BADGE_EVENT_0202 = 5913,
            BADGE_EVENT_0203 = 5914,
            BADGE_EVENT_0204 = 5915,
            BADGE_EVENT_0205 = 5916,
            BADGE_EVENT_0206 = 5917,
            BADGE_EVENT_0207 = 5918,
            BADGE_EVENT_0208 = 5919,
            BADGE_EVENT_0209 = 5920,
            BADGE_EVENT_0210 = 5921,
            BADGE_EVENT_0211 = 5922,
            BADGE_EVENT_0212 = 5923,
            BADGE_EVENT_0213 = 5924,
            BADGE_EVENT_0214 = 5925,
            BADGE_EVENT_0215 = 5926,
            BADGE_EVENT_0216 = 5927,
            BADGE_EVENT_0217 = 5928,
            BADGE_EVENT_0218 = 5929,
            BADGE_EVENT_0219 = 5930,
            BADGE_EVENT_0220 = 5931,
            BADGE_EVENT_0221 = 5932,
            BADGE_EVENT_0222 = 5933,
            BADGE_EVENT_0223 = 5934,
            BADGE_EVENT_0224 = 5935,
            BADGE_EVENT_0225 = 5936,
            BADGE_EVENT_0226 = 5937,
            BADGE_EVENT_0227 = 5938,
            BADGE_EVENT_0228 = 5939,
            BADGE_EVENT_0229 = 5940,
            BADGE_EVENT_0230 = 5941,
            BADGE_EVENT_0231 = 5942,
            BADGE_EVENT_0232 = 5943,
            BADGE_EVENT_0233 = 5944,
            BADGE_EVENT_0234 = 5945,
            BADGE_EVENT_0235 = 5946,
            BADGE_EVENT_0236 = 5947,
            BADGE_EVENT_0237 = 5948,
            BADGE_EVENT_0238 = 5949,
            BADGE_EVENT_0239 = 5950,
            BADGE_EVENT_0240 = 5951,
            BADGE_EVENT_0241 = 5952,
            BADGE_EVENT_0242 = 5953,
            BADGE_EVENT_0243 = 5954,
            BADGE_EVENT_0244 = 5955,
            BADGE_EVENT_0245 = 5956,
            BADGE_EVENT_0246 = 5957,
            BADGE_EVENT_0247 = 5958,
            BADGE_EVENT_0248 = 5959,
            BADGE_EVENT_0249 = 5960,
            BADGE_EVENT_0250 = 5961,
            BADGE_EVENT_0251 = 5962,
            BADGE_EVENT_0252 = 5963,
            BADGE_EVENT_0253 = 5964,
            BADGE_EVENT_0254 = 5965,
            BADGE_EVENT_0255 = 5966,
            BADGE_EVENT_0256 = 5967,
            BADGE_EVENT_0257 = 5968,
            BADGE_EVENT_0258 = 5969,
            BADGE_EVENT_0259 = 5970,
            BADGE_EVENT_0260 = 5971,
            BADGE_EVENT_0261 = 5972,
            BADGE_EVENT_0262 = 5973,
            BADGE_EVENT_0263 = 5974,
            BADGE_EVENT_0264 = 5975,
            BADGE_EVENT_0265 = 5976,
            BADGE_EVENT_0266 = 5977,
            BADGE_EVENT_0267 = 5978,
            BADGE_EVENT_0268 = 5979,
            BADGE_EVENT_0269 = 5980,
            BADGE_EVENT_0270 = 5981,
            BADGE_EVENT_0271 = 5982,
            BADGE_EVENT_0272 = 5983,
            BADGE_EVENT_0273 = 5984,
            BADGE_EVENT_0274 = 5985,
            BADGE_EVENT_0275 = 5986,
            BADGE_EVENT_0276 = 5987,
            BADGE_EVENT_0277 = 5988,
            BADGE_EVENT_0278 = 5989,
            BADGE_EVENT_0279 = 5990,
            BADGE_EVENT_0280 = 5991
        }

        enum HoloIapItemCategory {
            IAP_CATEGORY_NONE = 0,
            IAP_CATEGORY_BUNDLE = 1,
            IAP_CATEGORY_ITEMS = 2,
            IAP_CATEGORY_UPGRADES = 3,
            IAP_CATEGORY_POKECOINS = 4,
            IAP_CATEGORY_AVATAR = 5,
            IAP_CATEGORY_AVATAR_STORE_LINK = 6,
            IAP_CATEGORY_TEAM_CHANGE = 7,
            IAP_CATEGORY_GLOBAL_EVENT_TICKET = 10,
            IAP_CATEGORY_VS_SEEKER = 11,
            IAP_CATEGORY_STICKER = 12,
            IAP_CATEGORY_FREE = 13,
            IAP_CATEGORY_SUBSCRIPTION = 14,
            IAP_CATEGORY_TRANSPORTER_ENERGY = 15,
            IAP_CATEGORY_POSTCARD = 16,
            IAP_CATEGORY_FLAIR_BUNDLE = 17,
            IAP_CATEGORY_GIFTABLE = 18,
            IAP_CATEGORY_REWARDED_SPEND = 19,
            IAP_CATEGORY_EVENT_PASS = 20
        }

        enum HoloItemCategory {
            ITEM_CATEGORY_NONE = 0,
            ITEM_CATEGORY_POKEBALL = 1,
            ITEM_CATEGORY_FOOD = 2,
            ITEM_CATEGORY_MEDICINE = 3,
            ITEM_CATEGORY_BOOST = 4,
            ITEM_CATEGORY_UTILITES = 5,
            ITEM_CATEGORY_CAMERA = 6,
            ITEM_CATEGORY_DISK = 7,
            ITEM_CATEGORY_INCUBATOR = 8,
            ITEM_CATEGORY_INCENSE = 9,
            ITEM_CATEGORY_XP_BOOST = 10,
            ITEM_CATEGORY_INVENTORY_UPGRADE = 11,
            ITEM_CATEGORY_EVOLUTION_REQUIREMENT = 12,
            ITEM_CATEGORY_MOVE_REROLL = 13,
            ITEM_CATEGORY_CANDY = 14,
            ITEM_CATEGORY_RAID_TICKET = 15,
            ITEM_CATEGORY_STARDUST_BOOST = 16,
            ITEM_CATEGORY_FRIEND_GIFT_BOX = 17,
            ITEM_CATEGORY_TEAM_CHANGE = 18,
            ITEM_CATEGORY_ROUTE = 19,
            ITEM_CATEGORY_VS_SEEKER = 20,
            ITEM_CATEGORY_INCIDENT_TICKET = 21,
            ITEM_CATEGORY_GLOBAL_EVENT_TICKET = 22,
            ITEM_CATEGORY_BUDDY_EXCLUSIVE_FOOD = 23,
            ITEM_CATEGORY_STICKER = 24,
            ITEM_CATEGORY_POSTCARD_INVENTORY = 25,
            ITEM_CATEGORY_EVENT_TICKET_GIFT = 26,
            ITEM_CATEGORY_MP = 27,
            ITEM_CATEGORY_BREAD = 28,
            ITEM_CATEGORY_EVENT_PASS_POINT = 29,
            ITEM_CATEGORY_STAT_INCREASE = 30,
            ITEM_CATEGORY_EXPIRING = 31
        }

        enum HoloItemEffect {
            ITEM_EFFECT_NONE = 0,
            ITEM_EFFECT_CAP_NO_FLEE = 1000,
            ITEM_EFFECT_CAP_NO_MOVEMENT = 1002,
            ITEM_EFFECT_CAP_NO_THREAT = 1003,
            ITEM_EFFECT_CAP_TARGET_MAX = 1004,
            ITEM_EFFECT_CAP_TARGET_SLOW = 1005,
            ITEM_EFFECT_CAP_CHANCE_NIGHT = 1006,
            ITEM_EFFECT_CAP_CHANCE_TRAINER = 1007,
            ITEM_EFFECT_CAP_CHANCE_FIRST_THROW = 1008,
            ITEM_EFFECT_CAP_CHANCE_LEGEND = 1009,
            ITEM_EFFECT_CAP_CHANCE_HEAVY = 1010,
            ITEM_EFFECT_CAP_CHANCE_REPEAT = 1011,
            ITEM_EFFECT_CAP_CHANCE_MULTI_THROW = 1012,
            ITEM_EFFECT_CAP_CHANCE_ALWAYS = 1013,
            ITEM_EFFECT_CAP_CHANCE_SINGLE_THROW = 1014,
            ITEM_EFFECT_CANDY_AWARD = 1015,
            ITEM_EFFECT_FULL_MOTIVATION = 1016
        }

        enum HoloItemType {
            ITEM_TYPE_NONE = 0,
            ITEM_TYPE_POKEBALL = 1,
            ITEM_TYPE_POTION = 2,
            ITEM_TYPE_REVIVE = 3,
            ITEM_TYPE_MAP = 4,
            ITEM_TYPE_BATTLE = 5,
            ITEM_TYPE_FOOD = 6,
            ITEM_TYPE_CAMERA = 7,
            ITEM_TYPE_DISK = 8,
            ITEM_TYPE_INCUBATOR = 9,
            ITEM_TYPE_INCENSE = 10,
            ITEM_TYPE_XP_BOOST = 11,
            ITEM_TYPE_INVENTORY_UPGRADE = 12,
            ITEM_TYPE_EVOLUTION_REQUIREMENT = 13,
            ITEM_TYPE_MOVE_REROLL = 14,
            ITEM_TYPE_CANDY = 15,
            ITEM_TYPE_RAID_TICKET = 16,
            ITEM_TYPE_STARDUST_BOOST = 17,
            ITEM_TYPE_FRIEND_GIFT_BOX = 18,
            ITEM_TYPE_TEAM_CHANGE = 19,
            ITEM_TYPE_ROUTE = 20,
            ITEM_TYPE_VS_SEEKER_BATTLE_NOW = 21,
            ITEM_TYPE_INCIDENT_TICKET = 22,
            ITEM_TYPE_GLOBAL_EVENT_TICKET = 23,
            ITEM_TYPE_STICKER_INVENTORY = 24,
            ITEM_TYPE_POSTCARD_INVENTORY = 25,
            ITEM_TYPE_EVENT_TICKET_GIFT = 26,
            ITEM_TYPE_BREAKFAST = 27,
            ITEM_TYPE_MP = 28,
            ITEM_TYPE_MP_REPLENISH = 29,
            ITEM_TYPE_EVENT_PASS_POINT = 30,
            ITEM_TYPE_FRIEND_BOOST = 31,
            ITEM_TYPE_STAT_INCREASE = 32
        }

        enum HoloPokemonClass {
            POKEMON_CLASS_NORMAL = 0,
            POKEMON_CLASS_LEGENDARY = 1,
            POKEMON_CLASS_MYTHIC = 2,
            POKEMON_CLASS_ULTRA_BEAST = 3
        }

        enum HoloPokemonEggType {
            EGG_TYPE_UNSET = 0,
            EGG_TYPE_SHADOW = 1
        }

        enum HoloPokemonFamilyId {
            FAMILY_UNSET = 0,
            FAMILY_BULBASAUR = 1,
            FAMILY_CHARMANDER = 4,
            FAMILY_SQUIRTLE = 7,
            FAMILY_CATERPIE = 10,
            FAMILY_WEEDLE = 13,
            FAMILY_PIDGEY = 16,
            FAMILY_RATTATA = 19,
            FAMILY_SPEAROW = 21,
            FAMILY_EKANS = 23,
            FAMILY_PIKACHU = 25,
            FAMILY_SANDSHREW = 27,
            FAMILY_NIDORAN_FEMALE = 29,
            FAMILY_NIDORAN_MALE = 32,
            FAMILY_CLEFAIRY = 35,
            FAMILY_VULPIX = 37,
            FAMILY_JIGGLYPUFF = 39,
            FAMILY_ZUBAT = 41,
            FAMILY_ODDISH = 43,
            FAMILY_PARAS = 46,
            FAMILY_VENONAT = 48,
            FAMILY_DIGLETT = 50,
            FAMILY_MEOWTH = 52,
            FAMILY_PSYDUCK = 54,
            FAMILY_MANKEY = 56,
            FAMILY_GROWLITHE = 58,
            FAMILY_POLIWAG = 60,
            FAMILY_ABRA = 63,
            FAMILY_MACHOP = 66,
            FAMILY_BELLSPROUT = 69,
            FAMILY_TENTACOOL = 72,
            FAMILY_GEODUDE = 74,
            FAMILY_PONYTA = 77,
            FAMILY_SLOWPOKE = 79,
            FAMILY_MAGNEMITE = 81,
            FAMILY_FARFETCHD = 83,
            FAMILY_DODUO = 84,
            FAMILY_SEEL = 86,
            FAMILY_GRIMER = 88,
            FAMILY_SHELLDER = 90,
            FAMILY_GASTLY = 92,
            FAMILY_ONIX = 95,
            FAMILY_DROWZEE = 96,
            FAMILY_KRABBY = 98,
            FAMILY_VOLTORB = 100,
            FAMILY_EXEGGCUTE = 102,
            FAMILY_CUBONE = 104,
            FAMILY_HITMONLEE = 106,
            FAMILY_HITMONCHAN = 107,
            FAMILY_LICKITUNG = 108,
            FAMILY_KOFFING = 109,
            FAMILY_RHYHORN = 111,
            FAMILY_CHANSEY = 113,
            FAMILY_TANGELA = 114,
            FAMILY_KANGASKHAN = 115,
            FAMILY_HORSEA = 116,
            FAMILY_GOLDEEN = 118,
            FAMILY_STARYU = 120,
            FAMILY_MR_MIME = 122,
            FAMILY_SCYTHER = 123,
            FAMILY_JYNX = 124,
            FAMILY_ELECTABUZZ = 125,
            FAMILY_MAGMAR = 126,
            FAMILY_PINSIR = 127,
            FAMILY_TAUROS = 128,
            FAMILY_MAGIKARP = 129,
            FAMILY_LAPRAS = 131,
            FAMILY_DITTO = 132,
            FAMILY_EEVEE = 133,
            FAMILY_PORYGON = 137,
            FAMILY_OMANYTE = 138,
            FAMILY_KABUTO = 140,
            FAMILY_AERODACTYL = 142,
            FAMILY_SNORLAX = 143,
            FAMILY_ARTICUNO = 144,
            FAMILY_ZAPDOS = 145,
            FAMILY_MOLTRES = 146,
            FAMILY_DRATINI = 147,
            FAMILY_MEWTWO = 150,
            FAMILY_MEW = 151,
            FAMILY_CHIKORITA = 152,
            FAMILY_CYNDAQUIL = 155,
            FAMILY_TOTODILE = 158,
            FAMILY_SENTRET = 161,
            FAMILY_HOOTHOOT = 163,
            FAMILY_LEDYBA = 165,
            FAMILY_SPINARAK = 167,
            FAMILY_CHINCHOU = 170,
            FAMILY_TOGEPI = 175,
            FAMILY_NATU = 177,
            FAMILY_MAREEP = 179,
            FAMILY_MARILL = 183,
            FAMILY_SUDOWOODO = 185,
            FAMILY_HOPPIP = 187,
            FAMILY_AIPOM = 190,
            FAMILY_SUNKERN = 191,
            FAMILY_YANMA = 193,
            FAMILY_WOOPER = 194,
            FAMILY_MURKROW = 198,
            FAMILY_MISDREAVUS = 200,
            FAMILY_UNOWN = 201,
            FAMILY_WOBBUFFET = 202,
            FAMILY_GIRAFARIG = 203,
            FAMILY_PINECO = 204,
            FAMILY_DUNSPARCE = 206,
            FAMILY_GLIGAR = 207,
            FAMILY_SNUBBULL = 209,
            FAMILY_QWILFISH = 211,
            FAMILY_SHUCKLE = 213,
            FAMILY_HERACROSS = 214,
            FAMILY_SNEASEL = 215,
            FAMILY_TEDDIURSA = 216,
            FAMILY_SLUGMA = 218,
            FAMILY_SWINUB = 220,
            FAMILY_CORSOLA = 222,
            FAMILY_REMORAID = 223,
            FAMILY_DELIBIRD = 225,
            FAMILY_MANTINE = 226,
            FAMILY_SKARMORY = 227,
            FAMILY_HOUNDOUR = 228,
            FAMILY_PHANPY = 231,
            FAMILY_STANTLER = 234,
            FAMILY_SMEARGLE = 235,
            FAMILY_TYROGUE = 236,
            FAMILY_MILTANK = 241,
            FAMILY_RAIKOU = 243,
            FAMILY_ENTEI = 244,
            FAMILY_SUICUNE = 245,
            FAMILY_LARVITAR = 246,
            FAMILY_LUGIA = 249,
            FAMILY_HO_OH = 250,
            FAMILY_CELEBI = 251,
            FAMILY_TREECKO = 252,
            FAMILY_TORCHIC = 255,
            FAMILY_MUDKIP = 258,
            FAMILY_POOCHYENA = 261,
            FAMILY_ZIGZAGOON = 263,
            FAMILY_WURMPLE = 265,
            FAMILY_LOTAD = 270,
            FAMILY_SEEDOT = 273,
            FAMILY_TAILLOW = 276,
            FAMILY_WINGULL = 278,
            FAMILY_RALTS = 280,
            FAMILY_SURSKIT = 283,
            FAMILY_SHROOMISH = 285,
            FAMILY_SLAKOTH = 287,
            FAMILY_NINCADA = 290,
            FAMILY_WHISMUR = 293,
            FAMILY_MAKUHITA = 296,
            FAMILY_NOSEPASS = 299,
            FAMILY_SKITTY = 300,
            FAMILY_SABLEYE = 302,
            FAMILY_MAWILE = 303,
            FAMILY_ARON = 304,
            FAMILY_MEDITITE = 307,
            FAMILY_ELECTRIKE = 309,
            FAMILY_PLUSLE = 311,
            FAMILY_MINUN = 312,
            FAMILY_VOLBEAT = 313,
            FAMILY_ILLUMISE = 314,
            FAMILY_ROSELIA = 315,
            FAMILY_GULPIN = 316,
            FAMILY_CARVANHA = 318,
            FAMILY_WAILMER = 320,
            FAMILY_NUMEL = 322,
            FAMILY_TORKOAL = 324,
            FAMILY_SPOINK = 325,
            FAMILY_SPINDA = 327,
            FAMILY_TRAPINCH = 328,
            FAMILY_CACNEA = 331,
            FAMILY_SWABLU = 333,
            FAMILY_ZANGOOSE = 335,
            FAMILY_SEVIPER = 336,
            FAMILY_LUNATONE = 337,
            FAMILY_SOLROCK = 338,
            FAMILY_BARBOACH = 339,
            FAMILY_CORPHISH = 341,
            FAMILY_BALTOY = 343,
            FAMILY_LILEEP = 345,
            FAMILY_ANORITH = 347,
            FAMILY_FEEBAS = 349,
            FAMILY_CASTFORM = 351,
            FAMILY_KECLEON = 352,
            FAMILY_SHUPPET = 353,
            FAMILY_DUSKULL = 355,
            FAMILY_TROPIUS = 357,
            FAMILY_CHIMECHO = 358,
            FAMILY_ABSOL = 359,
            FAMILY_SNORUNT = 361,
            FAMILY_SPHEAL = 363,
            FAMILY_CLAMPERL = 366,
            FAMILY_RELICANTH = 369,
            FAMILY_LUVDISC = 370,
            FAMILY_BAGON = 371,
            FAMILY_BELDUM = 374,
            FAMILY_REGIROCK = 377,
            FAMILY_REGICE = 378,
            FAMILY_REGISTEEL = 379,
            FAMILY_LATIAS = 380,
            FAMILY_LATIOS = 381,
            FAMILY_KYOGRE = 382,
            FAMILY_GROUDON = 383,
            FAMILY_RAYQUAZA = 384,
            FAMILY_JIRACHI = 385,
            FAMILY_DEOXYS = 386,
            FAMILY_TURTWIG = 387,
            FAMILY_CHIMCHAR = 390,
            FAMILY_PIPLUP = 393,
            FAMILY_STARLY = 396,
            FAMILY_BIDOOF = 399,
            FAMILY_KRICKETOT = 401,
            FAMILY_SHINX = 403,
            FAMILY_CRANIDOS = 408,
            FAMILY_SHIELDON = 410,
            FAMILY_BURMY = 412,
            FAMILY_COMBEE = 415,
            FAMILY_PACHIRISU = 417,
            FAMILY_BUIZEL = 418,
            FAMILY_CHERUBI = 420,
            FAMILY_SHELLOS = 422,
            FAMILY_DRIFLOON = 425,
            FAMILY_BUNEARY = 427,
            FAMILY_GLAMEOW = 431,
            FAMILY_STUNKY = 434,
            FAMILY_BRONZOR = 436,
            FAMILY_CHATOT = 441,
            FAMILY_SPIRITOMB = 442,
            FAMILY_GIBLE = 443,
            FAMILY_LUCARIO = 448,
            FAMILY_HIPPOPOTAS = 449,
            FAMILY_SKORUPI = 451,
            FAMILY_CROAGUNK = 453,
            FAMILY_CARNIVINE = 455,
            FAMILY_FINNEON = 456,
            FAMILY_SNOVER = 459,
            FAMILY_ROTOM = 479,
            FAMILY_UXIE = 480,
            FAMILY_MESPRIT = 481,
            FAMILY_AZELF = 482,
            FAMILY_DIALGA = 483,
            FAMILY_PALKIA = 484,
            FAMILY_HEATRAN = 485,
            FAMILY_REGIGIGAS = 486,
            FAMILY_GIRATINA = 487,
            FAMILY_CRESSELIA = 488,
            FAMILY_PHIONE = 489,
            FAMILY_MANAPHY = 490,
            FAMILY_DARKRAI = 491,
            FAMILY_SHAYMIN = 492,
            FAMILY_ARCEUS = 493,
            FAMILY_VICTINI = 494,
            FAMILY_SNIVY = 495,
            FAMILY_TEPIG = 498,
            FAMILY_OSHAWOTT = 501,
            FAMILY_PATRAT = 504,
            FAMILY_LILLIPUP = 506,
            FAMILY_PURRLOIN = 509,
            FAMILY_PANSAGE = 511,
            FAMILY_PANSEAR = 513,
            FAMILY_PANPOUR = 515,
            FAMILY_MUNNA = 517,
            FAMILY_PIDOVE = 519,
            FAMILY_BLITZLE = 522,
            FAMILY_ROGGENROLA = 524,
            FAMILY_WOOBAT = 527,
            FAMILY_DRILBUR = 529,
            FAMILY_AUDINO = 531,
            FAMILY_TIMBURR = 532,
            FAMILY_TYMPOLE = 535,
            FAMILY_THROH = 538,
            FAMILY_SAWK = 539,
            FAMILY_SEWADDLE = 540,
            FAMILY_VENIPEDE = 543,
            FAMILY_COTTONEE = 546,
            FAMILY_PETILIL = 548,
            FAMILY_BASCULIN = 550,
            FAMILY_SANDILE = 551,
            FAMILY_DARUMAKA = 554,
            FAMILY_MARACTUS = 556,
            FAMILY_DWEBBLE = 557,
            FAMILY_SCRAGGY = 559,
            FAMILY_SIGILYPH = 561,
            FAMILY_YAMASK = 562,
            FAMILY_TIRTOUGA = 564,
            FAMILY_ARCHEN = 566,
            FAMILY_TRUBBISH = 568,
            FAMILY_ZORUA = 570,
            FAMILY_MINCCINO = 572,
            FAMILY_GOTHITA = 574,
            FAMILY_SOLOSIS = 577,
            FAMILY_DUCKLETT = 580,
            FAMILY_VANILLITE = 582,
            FAMILY_DEERLING = 585,
            FAMILY_EMOLGA = 587,
            FAMILY_KARRABLAST = 588,
            FAMILY_FOONGUS = 590,
            FAMILY_FRILLISH = 592,
            FAMILY_ALOMOMOLA = 594,
            FAMILY_JOLTIK = 595,
            FAMILY_FERROSEED = 597,
            FAMILY_KLINK = 599,
            FAMILY_TYNAMO = 602,
            FAMILY_ELGYEM = 605,
            FAMILY_LITWICK = 607,
            FAMILY_AXEW = 610,
            FAMILY_CUBCHOO = 613,
            FAMILY_CRYOGONAL = 615,
            FAMILY_SHELMET = 616,
            FAMILY_STUNFISK = 618,
            FAMILY_MIENFOO = 619,
            FAMILY_DRUDDIGON = 621,
            FAMILY_GOLETT = 622,
            FAMILY_PAWNIARD = 624,
            FAMILY_BOUFFALANT = 626,
            FAMILY_RUFFLET = 627,
            FAMILY_VULLABY = 629,
            FAMILY_HEATMOR = 631,
            FAMILY_DURANT = 632,
            FAMILY_DEINO = 633,
            FAMILY_LARVESTA = 636,
            FAMILY_COBALION = 638,
            FAMILY_TERRAKION = 639,
            FAMILY_VIRIZION = 640,
            FAMILY_TORNADUS = 641,
            FAMILY_THUNDURUS = 642,
            FAMILY_RESHIRAM = 643,
            FAMILY_ZEKROM = 644,
            FAMILY_LANDORUS = 645,
            FAMILY_KYUREM = 646,
            FAMILY_KELDEO = 647,
            FAMILY_MELOETTA = 648,
            FAMILY_GENESECT = 649,
            FAMILY_CHESPIN = 650,
            FAMILY_FENNEKIN = 653,
            FAMILY_FROAKIE = 656,
            FAMILY_BUNNELBY = 659,
            FAMILY_FLETCHLING = 661,
            FAMILY_SCATTERBUG = 664,
            FAMILY_LITLEO = 667,
            FAMILY_FLABEBE = 669,
            FAMILY_SKIDDO = 672,
            FAMILY_PANCHAM = 674,
            FAMILY_FURFROU = 676,
            FAMILY_ESPURR = 677,
            FAMILY_HONEDGE = 679,
            FAMILY_SPRITZEE = 682,
            FAMILY_SWIRLIX = 684,
            FAMILY_INKAY = 686,
            FAMILY_BINACLE = 688,
            FAMILY_SKRELP = 690,
            FAMILY_CLAUNCHER = 692,
            FAMILY_HELIOPTILE = 694,
            FAMILY_TYRUNT = 696,
            FAMILY_AMAURA = 698,
            FAMILY_HAWLUCHA = 701,
            FAMILY_DEDENNE = 702,
            FAMILY_CARBINK = 703,
            FAMILY_GOOMY = 704,
            FAMILY_KLEFKI = 707,
            FAMILY_PHANTUMP = 708,
            FAMILY_PUMPKABOO = 710,
            FAMILY_BERGMITE = 712,
            FAMILY_NOIBAT = 714,
            FAMILY_XERNEAS = 716,
            FAMILY_YVELTAL = 717,
            FAMILY_ZYGARDE = 718,
            FAMILY_DIANCIE = 719,
            FAMILY_HOOPA = 720,
            FAMILY_VOLCANION = 721,
            FAMILY_ROWLET = 722,
            FAMILY_LITTEN = 725,
            FAMILY_POPPLIO = 728,
            FAMILY_PIKIPEK = 731,
            FAMILY_YUNGOOS = 734,
            FAMILY_GRUBBIN = 736,
            FAMILY_CRABRAWLER = 739,
            FAMILY_ORICORIO = 741,
            FAMILY_CUTIEFLY = 742,
            FAMILY_ROCKRUFF = 744,
            FAMILY_WISHIWASHI = 746,
            FAMILY_MAREANIE = 747,
            FAMILY_MUDBRAY = 749,
            FAMILY_DEWPIDER = 751,
            FAMILY_FOMANTIS = 753,
            FAMILY_MORELULL = 755,
            FAMILY_SALANDIT = 757,
            FAMILY_STUFFUL = 759,
            FAMILY_BOUNSWEET = 761,
            FAMILY_COMFEY = 764,
            FAMILY_ORANGURU = 765,
            FAMILY_PASSIMIAN = 766,
            FAMILY_WIMPOD = 767,
            FAMILY_SANDYGAST = 769,
            FAMILY_PYUKUMUKU = 771,
            FAMILY_TYPE_NULL = 772,
            FAMILY_MINIOR = 774,
            FAMILY_KOMALA = 775,
            FAMILY_TURTONATOR = 776,
            FAMILY_TOGEDEMARU = 777,
            FAMILY_MIMIKYU = 778,
            FAMILY_BRUXISH = 779,
            FAMILY_DRAMPA = 780,
            FAMILY_DHELMISE = 781,
            FAMILY_JANGMO_O = 782,
            FAMILY_TAPU_KOKO = 785,
            FAMILY_TAPU_LELE = 786,
            FAMILY_TAPU_BULU = 787,
            FAMILY_TAPU_FINI = 788,
            FAMILY_COSMOG = 789,
            FAMILY_NIHILEGO = 793,
            FAMILY_BUZZWOLE = 794,
            FAMILY_PHEROMOSA = 795,
            FAMILY_XURKITREE = 796,
            FAMILY_CELESTEELA = 797,
            FAMILY_KARTANA = 798,
            FAMILY_GUZZLORD = 799,
            FAMILY_NECROZMA = 800,
            FAMILY_MAGEARNA = 801,
            FAMILY_MARSHADOW = 802,
            FAMILY_POIPOLE = 803,
            FAMILY_STAKATAKA = 805,
            FAMILY_BLACEPHALON = 806,
            FAMILY_ZERAORA = 807,
            FAMILY_MELTAN = 808,
            FAMILY_GROOKEY = 810,
            FAMILY_SCORBUNNY = 813,
            FAMILY_SOBBLE = 816,
            FAMILY_SKWOVET = 819,
            FAMILY_ROOKIDEE = 821,
            FAMILY_BLIPBUG = 824,
            FAMILY_NICKIT = 827,
            FAMILY_GOSSIFLEUR = 829,
            FAMILY_WOOLOO = 831,
            FAMILY_CHEWTLE = 833,
            FAMILY_YAMPER = 835,
            FAMILY_ROLYCOLY = 837,
            FAMILY_APPLIN = 840,
            FAMILY_SILICOBRA = 843,
            FAMILY_CRAMORANT = 845,
            FAMILY_ARROKUDA = 846,
            FAMILY_TOXEL = 848,
            FAMILY_SIZZLIPEDE = 850,
            FAMILY_CLOBBOPUS = 852,
            FAMILY_SINISTEA = 854,
            FAMILY_HATENNA = 856,
            FAMILY_IMPIDIMP = 859,
            FAMILY_MILCERY = 868,
            FAMILY_FALINKS = 870,
            FAMILY_PINCURCHIN = 871,
            FAMILY_SNOM = 872,
            FAMILY_STONJOURNER = 874,
            FAMILY_EISCUE = 875,
            FAMILY_INDEEDEE = 876,
            FAMILY_MORPEKO = 877,
            FAMILY_CUFANT = 878,
            FAMILY_DRACOZOLT = 880,
            FAMILY_ARCTOZOLT = 881,
            FAMILY_DRACOVISH = 882,
            FAMILY_ARCTOVISH = 883,
            FAMILY_DURALUDON = 884,
            FAMILY_DREEPY = 885,
            FAMILY_ZACIAN = 888,
            FAMILY_ZAMAZENTA = 889,
            FAMILY_ETERNATUS = 890,
            FAMILY_KUBFU = 891,
            FAMILY_ZARUDE = 893,
            FAMILY_REGIELEKI = 894,
            FAMILY_REGIDRAGO = 895,
            FAMILY_GLASTRIER = 896,
            FAMILY_SPECTRIER = 897,
            FAMILY_CALYREX = 898,
            FAMILY_ENAMORUS = 905,
            FAMILY_SPRIGATITO = 906,
            FAMILY_FUECOCO = 909,
            FAMILY_QUAXLY = 912,
            FAMILY_LECHONK = 915,
            FAMILY_TAROUNTULA = 917,
            FAMILY_NYMBLE = 919,
            FAMILY_PAWMI = 921,
            FAMILY_TANDEMAUS = 924,
            FAMILY_FIDOUGH = 926,
            FAMILY_SMOLIV = 928,
            FAMILY_SQUAWKABILLY = 931,
            FAMILY_NACLI = 932,
            FAMILY_CHARCADET = 935,
            FAMILY_TADBULB = 938,
            FAMILY_WATTREL = 940,
            FAMILY_MASCHIFF = 942,
            FAMILY_SHROODLE = 944,
            FAMILY_BRAMBLIN = 946,
            FAMILY_TOEDSCOOL = 948,
            FAMILY_KLAWF = 950,
            FAMILY_CAPSAKID = 951,
            FAMILY_RELLOR = 953,
            FAMILY_FLITTLE = 955,
            FAMILY_TINKATINK = 957,
            FAMILY_WIGLETT = 960,
            FAMILY_BOMBIRDIER = 962,
            FAMILY_FINIZEN = 963,
            FAMILY_VAROOM = 965,
            FAMILY_CYCLIZAR = 967,
            FAMILY_ORTHWORM = 968,
            FAMILY_GLIMMET = 969,
            FAMILY_GREAVARD = 971,
            FAMILY_FLAMIGO = 973,
            FAMILY_CETODDLE = 974,
            FAMILY_VELUZA = 976,
            FAMILY_DONDOZO = 977,
            FAMILY_TATSUGIRI = 978,
            FAMILY_ANNIHILAPE = 979,
            FAMILY_CLODSIRE = 980,
            FAMILY_FARIGIRAF = 981,
            FAMILY_DUDUNSPARCE = 982,
            FAMILY_KINGAMBIT = 983,
            FAMILY_GREATTUSK = 984,
            FAMILY_SCREAMTAIL = 985,
            FAMILY_BRUTEBONNET = 986,
            FAMILY_FLUTTERMANE = 987,
            FAMILY_SLITHERWING = 988,
            FAMILY_SANDYSHOCKS = 989,
            FAMILY_IRONTREADS = 990,
            FAMILY_IRONBUNDLE = 991,
            FAMILY_IRONHANDS = 992,
            FAMILY_IRONJUGULIS = 993,
            FAMILY_IRONMOTH = 994,
            FAMILY_IRONTHORNS = 995,
            FAMILY_FRIGIBAX = 996,
            FAMILY_GIMMIGHOUL = 999,
            FAMILY_WOCHIEN = 1001,
            FAMILY_CHIENPAO = 1002,
            FAMILY_TINGLU = 1003,
            FAMILY_CHIYU = 1004,
            FAMILY_ROARINGMOON = 1005,
            FAMILY_IRONVALIANT = 1006,
            FAMILY_KORAIDON = 1007,
            FAMILY_MIRAIDON = 1008
        }

        enum HoloPokemonId {
            MISSINGNO = 0,
            BULBASAUR = 1,
            IVYSAUR = 2,
            VENUSAUR = 3,
            CHARMANDER = 4,
            CHARMELEON = 5,
            CHARIZARD = 6,
            SQUIRTLE = 7,
            WARTORTLE = 8,
            BLASTOISE = 9,
            CATERPIE = 10,
            METAPOD = 11,
            BUTTERFREE = 12,
            WEEDLE = 13,
            KAKUNA = 14,
            BEEDRILL = 15,
            PIDGEY = 16,
            PIDGEOTTO = 17,
            PIDGEOT = 18,
            RATTATA = 19,
            RATICATE = 20,
            SPEAROW = 21,
            FEAROW = 22,
            EKANS = 23,
            ARBOK = 24,
            PIKACHU = 25,
            RAICHU = 26,
            SANDSHREW = 27,
            SANDSLASH = 28,
            NIDORAN_FEMALE = 29,
            NIDORINA = 30,
            NIDOQUEEN = 31,
            NIDORAN_MALE = 32,
            NIDORINO = 33,
            NIDOKING = 34,
            CLEFAIRY = 35,
            CLEFABLE = 36,
            VULPIX = 37,
            NINETALES = 38,
            JIGGLYPUFF = 39,
            WIGGLYTUFF = 40,
            ZUBAT = 41,
            GOLBAT = 42,
            ODDISH = 43,
            GLOOM = 44,
            VILEPLUME = 45,
            PARAS = 46,
            PARASECT = 47,
            VENONAT = 48,
            VENOMOTH = 49,
            DIGLETT = 50,
            DUGTRIO = 51,
            MEOWTH = 52,
            PERSIAN = 53,
            PSYDUCK = 54,
            GOLDUCK = 55,
            MANKEY = 56,
            PRIMEAPE = 57,
            GROWLITHE = 58,
            ARCANINE = 59,
            POLIWAG = 60,
            POLIWHIRL = 61,
            POLIWRATH = 62,
            ABRA = 63,
            KADABRA = 64,
            ALAKAZAM = 65,
            MACHOP = 66,
            MACHOKE = 67,
            MACHAMP = 68,
            BELLSPROUT = 69,
            WEEPINBELL = 70,
            VICTREEBEL = 71,
            TENTACOOL = 72,
            TENTACRUEL = 73,
            GEODUDE = 74,
            GRAVELER = 75,
            GOLEM = 76,
            PONYTA = 77,
            RAPIDASH = 78,
            SLOWPOKE = 79,
            SLOWBRO = 80,
            MAGNEMITE = 81,
            MAGNETON = 82,
            FARFETCHD = 83,
            DODUO = 84,
            DODRIO = 85,
            SEEL = 86,
            DEWGONG = 87,
            GRIMER = 88,
            MUK = 89,
            SHELLDER = 90,
            CLOYSTER = 91,
            GASTLY = 92,
            HAUNTER = 93,
            GENGAR = 94,
            ONIX = 95,
            DROWZEE = 96,
            HYPNO = 97,
            KRABBY = 98,
            KINGLER = 99,
            VOLTORB = 100,
            ELECTRODE = 101,
            EXEGGCUTE = 102,
            EXEGGUTOR = 103,
            CUBONE = 104,
            MAROWAK = 105,
            HITMONLEE = 106,
            HITMONCHAN = 107,
            LICKITUNG = 108,
            KOFFING = 109,
            WEEZING = 110,
            RHYHORN = 111,
            RHYDON = 112,
            CHANSEY = 113,
            TANGELA = 114,
            KANGASKHAN = 115,
            HORSEA = 116,
            SEADRA = 117,
            GOLDEEN = 118,
            SEAKING = 119,
            STARYU = 120,
            STARMIE = 121,
            MR_MIME = 122,
            SCYTHER = 123,
            JYNX = 124,
            ELECTABUZZ = 125,
            MAGMAR = 126,
            PINSIR = 127,
            TAUROS = 128,
            MAGIKARP = 129,
            GYARADOS = 130,
            LAPRAS = 131,
            DITTO = 132,
            EEVEE = 133,
            VAPOREON = 134,
            JOLTEON = 135,
            FLAREON = 136,
            PORYGON = 137,
            OMANYTE = 138,
            OMASTAR = 139,
            KABUTO = 140,
            KABUTOPS = 141,
            AERODACTYL = 142,
            SNORLAX = 143,
            ARTICUNO = 144,
            ZAPDOS = 145,
            MOLTRES = 146,
            DRATINI = 147,
            DRAGONAIR = 148,
            DRAGONITE = 149,
            MEWTWO = 150,
            MEW = 151,
            CHIKORITA = 152,
            BAYLEEF = 153,
            MEGANIUM = 154,
            CYNDAQUIL = 155,
            QUILAVA = 156,
            TYPHLOSION = 157,
            TOTODILE = 158,
            CROCONAW = 159,
            FERALIGATR = 160,
            SENTRET = 161,
            FURRET = 162,
            HOOTHOOT = 163,
            NOCTOWL = 164,
            LEDYBA = 165,
            LEDIAN = 166,
            SPINARAK = 167,
            ARIADOS = 168,
            CROBAT = 169,
            CHINCHOU = 170,
            LANTURN = 171,
            PICHU = 172,
            CLEFFA = 173,
            IGGLYBUFF = 174,
            TOGEPI = 175,
            TOGETIC = 176,
            NATU = 177,
            XATU = 178,
            MAREEP = 179,
            FLAAFFY = 180,
            AMPHAROS = 181,
            BELLOSSOM = 182,
            MARILL = 183,
            AZUMARILL = 184,
            SUDOWOODO = 185,
            POLITOED = 186,
            HOPPIP = 187,
            SKIPLOOM = 188,
            JUMPLUFF = 189,
            AIPOM = 190,
            SUNKERN = 191,
            SUNFLORA = 192,
            YANMA = 193,
            WOOPER = 194,
            QUAGSIRE = 195,
            ESPEON = 196,
            UMBREON = 197,
            MURKROW = 198,
            SLOWKING = 199,
            MISDREAVUS = 200,
            UNOWN = 201,
            WOBBUFFET = 202,
            GIRAFARIG = 203,
            PINECO = 204,
            FORRETRESS = 205,
            DUNSPARCE = 206,
            GLIGAR = 207,
            STEELIX = 208,
            SNUBBULL = 209,
            GRANBULL = 210,
            QWILFISH = 211,
            SCIZOR = 212,
            SHUCKLE = 213,
            HERACROSS = 214,
            SNEASEL = 215,
            TEDDIURSA = 216,
            URSARING = 217,
            SLUGMA = 218,
            MAGCARGO = 219,
            SWINUB = 220,
            PILOSWINE = 221,
            CORSOLA = 222,
            REMORAID = 223,
            OCTILLERY = 224,
            DELIBIRD = 225,
            MANTINE = 226,
            SKARMORY = 227,
            HOUNDOUR = 228,
            HOUNDOOM = 229,
            KINGDRA = 230,
            PHANPY = 231,
            DONPHAN = 232,
            PORYGON2 = 233,
            STANTLER = 234,
            SMEARGLE = 235,
            TYROGUE = 236,
            HITMONTOP = 237,
            SMOOCHUM = 238,
            ELEKID = 239,
            MAGBY = 240,
            MILTANK = 241,
            BLISSEY = 242,
            RAIKOU = 243,
            ENTEI = 244,
            SUICUNE = 245,
            LARVITAR = 246,
            PUPITAR = 247,
            TYRANITAR = 248,
            LUGIA = 249,
            HO_OH = 250,
            CELEBI = 251,
            TREECKO = 252,
            GROVYLE = 253,
            SCEPTILE = 254,
            TORCHIC = 255,
            COMBUSKEN = 256,
            BLAZIKEN = 257,
            MUDKIP = 258,
            MARSHTOMP = 259,
            SWAMPERT = 260,
            POOCHYENA = 261,
            MIGHTYENA = 262,
            ZIGZAGOON = 263,
            LINOONE = 264,
            WURMPLE = 265,
            SILCOON = 266,
            BEAUTIFLY = 267,
            CASCOON = 268,
            DUSTOX = 269,
            LOTAD = 270,
            LOMBRE = 271,
            LUDICOLO = 272,
            SEEDOT = 273,
            NUZLEAF = 274,
            SHIFTRY = 275,
            TAILLOW = 276,
            SWELLOW = 277,
            WINGULL = 278,
            PELIPPER = 279,
            RALTS = 280,
            KIRLIA = 281,
            GARDEVOIR = 282,
            SURSKIT = 283,
            MASQUERAIN = 284,
            SHROOMISH = 285,
            BRELOOM = 286,
            SLAKOTH = 287,
            VIGOROTH = 288,
            SLAKING = 289,
            NINCADA = 290,
            NINJASK = 291,
            SHEDINJA = 292,
            WHISMUR = 293,
            LOUDRED = 294,
            EXPLOUD = 295,
            MAKUHITA = 296,
            HARIYAMA = 297,
            AZURILL = 298,
            NOSEPASS = 299,
            SKITTY = 300,
            DELCATTY = 301,
            SABLEYE = 302,
            MAWILE = 303,
            ARON = 304,
            LAIRON = 305,
            AGGRON = 306,
            MEDITITE = 307,
            MEDICHAM = 308,
            ELECTRIKE = 309,
            MANECTRIC = 310,
            PLUSLE = 311,
            MINUN = 312,
            VOLBEAT = 313,
            ILLUMISE = 314,
            ROSELIA = 315,
            GULPIN = 316,
            SWALOT = 317,
            CARVANHA = 318,
            SHARPEDO = 319,
            WAILMER = 320,
            WAILORD = 321,
            NUMEL = 322,
            CAMERUPT = 323,
            TORKOAL = 324,
            SPOINK = 325,
            GRUMPIG = 326,
            SPINDA = 327,
            TRAPINCH = 328,
            VIBRAVA = 329,
            FLYGON = 330,
            CACNEA = 331,
            CACTURNE = 332,
            SWABLU = 333,
            ALTARIA = 334,
            ZANGOOSE = 335,
            SEVIPER = 336,
            LUNATONE = 337,
            SOLROCK = 338,
            BARBOACH = 339,
            WHISCASH = 340,
            CORPHISH = 341,
            CRAWDAUNT = 342,
            BALTOY = 343,
            CLAYDOL = 344,
            LILEEP = 345,
            CRADILY = 346,
            ANORITH = 347,
            ARMALDO = 348,
            FEEBAS = 349,
            MILOTIC = 350,
            CASTFORM = 351,
            KECLEON = 352,
            SHUPPET = 353,
            BANETTE = 354,
            DUSKULL = 355,
            DUSCLOPS = 356,
            TROPIUS = 357,
            CHIMECHO = 358,
            ABSOL = 359,
            WYNAUT = 360,
            SNORUNT = 361,
            GLALIE = 362,
            SPHEAL = 363,
            SEALEO = 364,
            WALREIN = 365,
            CLAMPERL = 366,
            HUNTAIL = 367,
            GOREBYSS = 368,
            RELICANTH = 369,
            LUVDISC = 370,
            BAGON = 371,
            SHELGON = 372,
            SALAMENCE = 373,
            BELDUM = 374,
            METANG = 375,
            METAGROSS = 376,
            REGIROCK = 377,
            REGICE = 378,
            REGISTEEL = 379,
            LATIAS = 380,
            LATIOS = 381,
            KYOGRE = 382,
            GROUDON = 383,
            RAYQUAZA = 384,
            JIRACHI = 385,
            DEOXYS = 386,
            TURTWIG = 387,
            GROTLE = 388,
            TORTERRA = 389,
            CHIMCHAR = 390,
            MONFERNO = 391,
            INFERNAPE = 392,
            PIPLUP = 393,
            PRINPLUP = 394,
            EMPOLEON = 395,
            STARLY = 396,
            STARAVIA = 397,
            STARAPTOR = 398,
            BIDOOF = 399,
            BIBAREL = 400,
            KRICKETOT = 401,
            KRICKETUNE = 402,
            SHINX = 403,
            LUXIO = 404,
            LUXRAY = 405,
            BUDEW = 406,
            ROSERADE = 407,
            CRANIDOS = 408,
            RAMPARDOS = 409,
            SHIELDON = 410,
            BASTIODON = 411,
            BURMY = 412,
            WORMADAM = 413,
            MOTHIM = 414,
            COMBEE = 415,
            VESPIQUEN = 416,
            PACHIRISU = 417,
            BUIZEL = 418,
            FLOATZEL = 419,
            CHERUBI = 420,
            CHERRIM = 421,
            SHELLOS = 422,
            GASTRODON = 423,
            AMBIPOM = 424,
            DRIFLOON = 425,
            DRIFBLIM = 426,
            BUNEARY = 427,
            LOPUNNY = 428,
            MISMAGIUS = 429,
            HONCHKROW = 430,
            GLAMEOW = 431,
            PURUGLY = 432,
            CHINGLING = 433,
            STUNKY = 434,
            SKUNTANK = 435,
            BRONZOR = 436,
            BRONZONG = 437,
            BONSLY = 438,
            MIME_JR = 439,
            HAPPINY = 440,
            CHATOT = 441,
            SPIRITOMB = 442,
            GIBLE = 443,
            GABITE = 444,
            GARCHOMP = 445,
            MUNCHLAX = 446,
            RIOLU = 447,
            LUCARIO = 448,
            HIPPOPOTAS = 449,
            HIPPOWDON = 450,
            SKORUPI = 451,
            DRAPION = 452,
            CROAGUNK = 453,
            TOXICROAK = 454,
            CARNIVINE = 455,
            FINNEON = 456,
            LUMINEON = 457,
            MANTYKE = 458,
            SNOVER = 459,
            ABOMASNOW = 460,
            WEAVILE = 461,
            MAGNEZONE = 462,
            LICKILICKY = 463,
            RHYPERIOR = 464,
            TANGROWTH = 465,
            ELECTIVIRE = 466,
            MAGMORTAR = 467,
            TOGEKISS = 468,
            YANMEGA = 469,
            LEAFEON = 470,
            GLACEON = 471,
            GLISCOR = 472,
            MAMOSWINE = 473,
            PORYGON_Z = 474,
            GALLADE = 475,
            PROBOPASS = 476,
            DUSKNOIR = 477,
            FROSLASS = 478,
            ROTOM = 479,
            UXIE = 480,
            MESPRIT = 481,
            AZELF = 482,
            DIALGA = 483,
            PALKIA = 484,
            HEATRAN = 485,
            REGIGIGAS = 486,
            GIRATINA = 487,
            CRESSELIA = 488,
            PHIONE = 489,
            MANAPHY = 490,
            DARKRAI = 491,
            SHAYMIN = 492,
            ARCEUS = 493,
            VICTINI = 494,
            SNIVY = 495,
            SERVINE = 496,
            SERPERIOR = 497,
            TEPIG = 498,
            PIGNITE = 499,
            EMBOAR = 500,
            OSHAWOTT = 501,
            DEWOTT = 502,
            SAMUROTT = 503,
            PATRAT = 504,
            WATCHOG = 505,
            LILLIPUP = 506,
            HERDIER = 507,
            STOUTLAND = 508,
            PURRLOIN = 509,
            LIEPARD = 510,
            PANSAGE = 511,
            SIMISAGE = 512,
            PANSEAR = 513,
            SIMISEAR = 514,
            PANPOUR = 515,
            SIMIPOUR = 516,
            MUNNA = 517,
            MUSHARNA = 518,
            PIDOVE = 519,
            TRANQUILL = 520,
            UNFEZANT = 521,
            BLITZLE = 522,
            ZEBSTRIKA = 523,
            ROGGENROLA = 524,
            BOLDORE = 525,
            GIGALITH = 526,
            WOOBAT = 527,
            SWOOBAT = 528,
            DRILBUR = 529,
            EXCADRILL = 530,
            AUDINO = 531,
            TIMBURR = 532,
            GURDURR = 533,
            CONKELDURR = 534,
            TYMPOLE = 535,
            PALPITOAD = 536,
            SEISMITOAD = 537,
            THROH = 538,
            SAWK = 539,
            SEWADDLE = 540,
            SWADLOON = 541,
            LEAVANNY = 542,
            VENIPEDE = 543,
            WHIRLIPEDE = 544,
            SCOLIPEDE = 545,
            COTTONEE = 546,
            WHIMSICOTT = 547,
            PETILIL = 548,
            LILLIGANT = 549,
            BASCULIN = 550,
            SANDILE = 551,
            KROKOROK = 552,
            KROOKODILE = 553,
            DARUMAKA = 554,
            DARMANITAN = 555,
            MARACTUS = 556,
            DWEBBLE = 557,
            CRUSTLE = 558,
            SCRAGGY = 559,
            SCRAFTY = 560,
            SIGILYPH = 561,
            YAMASK = 562,
            COFAGRIGUS = 563,
            TIRTOUGA = 564,
            CARRACOSTA = 565,
            ARCHEN = 566,
            ARCHEOPS = 567,
            TRUBBISH = 568,
            GARBODOR = 569,
            ZORUA = 570,
            ZOROARK = 571,
            MINCCINO = 572,
            CINCCINO = 573,
            GOTHITA = 574,
            GOTHORITA = 575,
            GOTHITELLE = 576,
            SOLOSIS = 577,
            DUOSION = 578,
            REUNICLUS = 579,
            DUCKLETT = 580,
            SWANNA = 581,
            VANILLITE = 582,
            VANILLISH = 583,
            VANILLUXE = 584,
            DEERLING = 585,
            SAWSBUCK = 586,
            EMOLGA = 587,
            KARRABLAST = 588,
            ESCAVALIER = 589,
            FOONGUS = 590,
            AMOONGUSS = 591,
            FRILLISH = 592,
            JELLICENT = 593,
            ALOMOMOLA = 594,
            JOLTIK = 595,
            GALVANTULA = 596,
            FERROSEED = 597,
            FERROTHORN = 598,
            KLINK = 599,
            KLANG = 600,
            KLINKLANG = 601,
            TYNAMO = 602,
            EELEKTRIK = 603,
            EELEKTROSS = 604,
            ELGYEM = 605,
            BEHEEYEM = 606,
            LITWICK = 607,
            LAMPENT = 608,
            CHANDELURE = 609,
            AXEW = 610,
            FRAXURE = 611,
            HAXORUS = 612,
            CUBCHOO = 613,
            BEARTIC = 614,
            CRYOGONAL = 615,
            SHELMET = 616,
            ACCELGOR = 617,
            STUNFISK = 618,
            MIENFOO = 619,
            MIENSHAO = 620,
            DRUDDIGON = 621,
            GOLETT = 622,
            GOLURK = 623,
            PAWNIARD = 624,
            BISHARP = 625,
            BOUFFALANT = 626,
            RUFFLET = 627,
            BRAVIARY = 628,
            VULLABY = 629,
            MANDIBUZZ = 630,
            HEATMOR = 631,
            DURANT = 632,
            DEINO = 633,
            ZWEILOUS = 634,
            HYDREIGON = 635,
            LARVESTA = 636,
            VOLCARONA = 637,
            COBALION = 638,
            TERRAKION = 639,
            VIRIZION = 640,
            TORNADUS = 641,
            THUNDURUS = 642,
            RESHIRAM = 643,
            ZEKROM = 644,
            LANDORUS = 645,
            KYUREM = 646,
            KELDEO = 647,
            MELOETTA = 648,
            GENESECT = 649,
            CHESPIN = 650,
            QUILLADIN = 651,
            CHESNAUGHT = 652,
            FENNEKIN = 653,
            BRAIXEN = 654,
            DELPHOX = 655,
            FROAKIE = 656,
            FROGADIER = 657,
            GRENINJA = 658,
            BUNNELBY = 659,
            DIGGERSBY = 660,
            FLETCHLING = 661,
            FLETCHINDER = 662,
            TALONFLAME = 663,
            SCATTERBUG = 664,
            SPEWPA = 665,
            VIVILLON = 666,
            LITLEO = 667,
            PYROAR = 668,
            FLABEBE = 669,
            FLOETTE = 670,
            FLORGES = 671,
            SKIDDO = 672,
            GOGOAT = 673,
            PANCHAM = 674,
            PANGORO = 675,
            FURFROU = 676,
            ESPURR = 677,
            MEOWSTIC = 678,
            HONEDGE = 679,
            DOUBLADE = 680,
            AEGISLASH = 681,
            SPRITZEE = 682,
            AROMATISSE = 683,
            SWIRLIX = 684,
            SLURPUFF = 685,
            INKAY = 686,
            MALAMAR = 687,
            BINACLE = 688,
            BARBARACLE = 689,
            SKRELP = 690,
            DRAGALGE = 691,
            CLAUNCHER = 692,
            CLAWITZER = 693,
            HELIOPTILE = 694,
            HELIOLISK = 695,
            TYRUNT = 696,
            TYRANTRUM = 697,
            AMAURA = 698,
            AURORUS = 699,
            SYLVEON = 700,
            HAWLUCHA = 701,
            DEDENNE = 702,
            CARBINK = 703,
            GOOMY = 704,
            SLIGGOO = 705,
            GOODRA = 706,
            KLEFKI = 707,
            PHANTUMP = 708,
            TREVENANT = 709,
            PUMPKABOO = 710,
            GOURGEIST = 711,
            BERGMITE = 712,
            AVALUGG = 713,
            NOIBAT = 714,
            NOIVERN = 715,
            XERNEAS = 716,
            YVELTAL = 717,
            ZYGARDE = 718,
            DIANCIE = 719,
            HOOPA = 720,
            VOLCANION = 721,
            ROWLET = 722,
            DARTRIX = 723,
            DECIDUEYE = 724,
            LITTEN = 725,
            TORRACAT = 726,
            INCINEROAR = 727,
            POPPLIO = 728,
            BRIONNE = 729,
            PRIMARINA = 730,
            PIKIPEK = 731,
            TRUMBEAK = 732,
            TOUCANNON = 733,
            YUNGOOS = 734,
            GUMSHOOS = 735,
            GRUBBIN = 736,
            CHARJABUG = 737,
            VIKAVOLT = 738,
            CRABRAWLER = 739,
            CRABOMINABLE = 740,
            ORICORIO = 741,
            CUTIEFLY = 742,
            RIBOMBEE = 743,
            ROCKRUFF = 744,
            LYCANROC = 745,
            WISHIWASHI = 746,
            MAREANIE = 747,
            TOXAPEX = 748,
            MUDBRAY = 749,
            MUDSDALE = 750,
            DEWPIDER = 751,
            ARAQUANID = 752,
            FOMANTIS = 753,
            LURANTIS = 754,
            MORELULL = 755,
            SHIINOTIC = 756,
            SALANDIT = 757,
            SALAZZLE = 758,
            STUFFUL = 759,
            BEWEAR = 760,
            BOUNSWEET = 761,
            STEENEE = 762,
            TSAREENA = 763,
            COMFEY = 764,
            ORANGURU = 765,
            PASSIMIAN = 766,
            WIMPOD = 767,
            GOLISOPOD = 768,
            SANDYGAST = 769,
            PALOSSAND = 770,
            PYUKUMUKU = 771,
            TYPE_NULL = 772,
            SILVALLY = 773,
            MINIOR = 774,
            KOMALA = 775,
            TURTONATOR = 776,
            TOGEDEMARU = 777,
            MIMIKYU = 778,
            BRUXISH = 779,
            DRAMPA = 780,
            DHELMISE = 781,
            JANGMO_O = 782,
            HAKAMO_O = 783,
            KOMMO_O = 784,
            TAPU_KOKO = 785,
            TAPU_LELE = 786,
            TAPU_BULU = 787,
            TAPU_FINI = 788,
            COSMOG = 789,
            COSMOEM = 790,
            SOLGALEO = 791,
            LUNALA = 792,
            NIHILEGO = 793,
            BUZZWOLE = 794,
            PHEROMOSA = 795,
            XURKITREE = 796,
            CELESTEELA = 797,
            KARTANA = 798,
            GUZZLORD = 799,
            NECROZMA = 800,
            MAGEARNA = 801,
            MARSHADOW = 802,
            POIPOLE = 803,
            NAGANADEL = 804,
            STAKATAKA = 805,
            BLACEPHALON = 806,
            ZERAORA = 807,
            MELTAN = 808,
            MELMETAL = 809,
            GROOKEY = 810,
            THWACKEY = 811,
            RILLABOOM = 812,
            SCORBUNNY = 813,
            RABOOT = 814,
            CINDERACE = 815,
            SOBBLE = 816,
            DRIZZILE = 817,
            INTELEON = 818,
            SKWOVET = 819,
            GREEDENT = 820,
            ROOKIDEE = 821,
            CORVISQUIRE = 822,
            CORVIKNIGHT = 823,
            BLIPBUG = 824,
            DOTTLER = 825,
            ORBEETLE = 826,
            NICKIT = 827,
            THIEVUL = 828,
            GOSSIFLEUR = 829,
            ELDEGOSS = 830,
            WOOLOO = 831,
            DUBWOOL = 832,
            CHEWTLE = 833,
            DREDNAW = 834,
            YAMPER = 835,
            BOLTUND = 836,
            ROLYCOLY = 837,
            CARKOL = 838,
            COALOSSAL = 839,
            APPLIN = 840,
            FLAPPLE = 841,
            APPLETUN = 842,
            SILICOBRA = 843,
            SANDACONDA = 844,
            CRAMORANT = 845,
            ARROKUDA = 846,
            BARRASKEWDA = 847,
            TOXEL = 848,
            TOXTRICITY = 849,
            SIZZLIPEDE = 850,
            CENTISKORCH = 851,
            CLOBBOPUS = 852,
            GRAPPLOCT = 853,
            SINISTEA = 854,
            POLTEAGEIST = 855,
            HATENNA = 856,
            HATTREM = 857,
            HATTERENE = 858,
            IMPIDIMP = 859,
            MORGREM = 860,
            GRIMMSNARL = 861,
            OBSTAGOON = 862,
            PERRSERKER = 863,
            CURSOLA = 864,
            SIRFETCHD = 865,
            MR_RIME = 866,
            RUNERIGUS = 867,
            MILCERY = 868,
            ALCREMIE = 869,
            FALINKS = 870,
            PINCURCHIN = 871,
            SNOM = 872,
            FROSMOTH = 873,
            STONJOURNER = 874,
            EISCUE = 875,
            INDEEDEE = 876,
            MORPEKO = 877,
            CUFANT = 878,
            COPPERAJAH = 879,
            DRACOZOLT = 880,
            ARCTOZOLT = 881,
            DRACOVISH = 882,
            ARCTOVISH = 883,
            DURALUDON = 884,
            DREEPY = 885,
            DRAKLOAK = 886,
            DRAGAPULT = 887,
            ZACIAN = 888,
            ZAMAZENTA = 889,
            ETERNATUS = 890,
            KUBFU = 891,
            URSHIFU = 892,
            ZARUDE = 893,
            REGIELEKI = 894,
            REGIDRAGO = 895,
            GLASTRIER = 896,
            SPECTRIER = 897,
            CALYREX = 898,
            WYRDEER = 899,
            KLEAVOR = 900,
            URSALUNA = 901,
            BASCULEGION = 902,
            SNEASLER = 903,
            OVERQWIL = 904,
            ENAMORUS = 905,
            SPRIGATITO = 906,
            FLORAGATO = 907,
            MEOWSCARADA = 908,
            FUECOCO = 909,
            CROCALOR = 910,
            SKELEDIRGE = 911,
            QUAXLY = 912,
            QUAXWELL = 913,
            QUAQUAVAL = 914,
            LECHONK = 915,
            OINKOLOGNE = 916,
            TAROUNTULA = 917,
            SPIDOPS = 918,
            NYMBLE = 919,
            LOKIX = 920,
            PAWMI = 921,
            PAWMO = 922,
            PAWMOT = 923,
            TANDEMAUS = 924,
            MAUSHOLD = 925,
            FIDOUGH = 926,
            DACHSBUN = 927,
            SMOLIV = 928,
            DOLLIV = 929,
            ARBOLIVA = 930,
            SQUAWKABILLY = 931,
            NACLI = 932,
            NACLSTACK = 933,
            GARGANACL = 934,
            CHARCADET = 935,
            ARMAROUGE = 936,
            CERULEDGE = 937,
            TADBULB = 938,
            BELLIBOLT = 939,
            WATTREL = 940,
            KILOWATTREL = 941,
            MASCHIFF = 942,
            MABOSSTIFF = 943,
            SHROODLE = 944,
            GRAFAIAI = 945,
            BRAMBLIN = 946,
            BRAMBLEGHAST = 947,
            TOEDSCOOL = 948,
            TOEDSCRUEL = 949,
            KLAWF = 950,
            CAPSAKID = 951,
            SCOVILLAIN = 952,
            RELLOR = 953,
            RABSCA = 954,
            FLITTLE = 955,
            ESPATHRA = 956,
            TINKATINK = 957,
            TINKATUFF = 958,
            TINKATON = 959,
            WIGLETT = 960,
            WUGTRIO = 961,
            BOMBIRDIER = 962,
            FINIZEN = 963,
            PALAFIN = 964,
            VAROOM = 965,
            REVAVROOM = 966,
            CYCLIZAR = 967,
            ORTHWORM = 968,
            GLIMMET = 969,
            GLIMMORA = 970,
            GREAVARD = 971,
            HOUNDSTONE = 972,
            FLAMIGO = 973,
            CETODDLE = 974,
            CETITAN = 975,
            VELUZA = 976,
            DONDOZO = 977,
            TATSUGIRI = 978,
            ANNIHILAPE = 979,
            CLODSIRE = 980,
            FARIGIRAF = 981,
            DUDUNSPARCE = 982,
            KINGAMBIT = 983,
            GREATTUSK = 984,
            SCREAMTAIL = 985,
            BRUTEBONNET = 986,
            FLUTTERMANE = 987,
            SLITHERWING = 988,
            SANDYSHOCKS = 989,
            IRONTREADS = 990,
            IRONBUNDLE = 991,
            IRONHANDS = 992,
            IRONJUGULIS = 993,
            IRONMOTH = 994,
            IRONTHORNS = 995,
            FRIGIBAX = 996,
            ARCTIBAX = 997,
            BAXCALIBUR = 998,
            GIMMIGHOUL = 999,
            GHOLDENGO = 1000,
            WOCHIEN = 1001,
            CHIENPAO = 1002,
            TINGLU = 1003,
            CHIYU = 1004,
            ROARINGMOON = 1005,
            IRONVALIANT = 1006,
            KORAIDON = 1007,
            MIRAIDON = 1008
        }

        enum HoloPokemonMove {
            MOVE_UNSET = 0,
            THUNDER_SHOCK = 1,
            QUICK_ATTACK = 2,
            SCRATCH = 3,
            EMBER = 4,
            VINE_WHIP = 5,
            TACKLE = 6,
            RAZOR_LEAF = 7,
            TAKE_DOWN = 8,
            WATER_GUN = 9,
            BITE = 10,
            POUND = 11,
            DOUBLE_SLAP = 12,
            WRAP = 13,
            HYPER_BEAM = 14,
            LICK = 15,
            DARK_PULSE = 16,
            SMOG = 17,
            SLUDGE = 18,
            METAL_CLAW = 19,
            VICE_GRIP = 20,
            FLAME_WHEEL = 21,
            MEGAHORN = 22,
            WING_ATTACK = 23,
            FLAMETHROWER = 24,
            SUCKER_PUNCH = 25,
            DIG = 26,
            LOW_KICK = 27,
            CROSS_CHOP = 28,
            PSYCHO_CUT = 29,
            PSYBEAM = 30,
            EARTHQUAKE = 31,
            STONE_EDGE = 32,
            ICE_PUNCH = 33,
            HEART_STAMP = 34,
            DISCHARGE = 35,
            FLASH_CANNON = 36,
            PECK = 37,
            DRILL_PECK = 38,
            ICE_BEAM = 39,
            BLIZZARD = 40,
            AIR_SLASH = 41,
            HEAT_WAVE = 42,
            TWINEEDLE = 43,
            POISON_JAB = 44,
            AERIAL_ACE = 45,
            DRILL_RUN = 46,
            PETAL_BLIZZARD = 47,
            MEGA_DRAIN = 48,
            BUG_BUZZ = 49,
            POISON_FANG = 50,
            NIGHT_SLASH = 51,
            SLASH = 52,
            BUBBLE_BEAM = 53,
            SUBMISSION = 54,
            KARATE_CHOP = 55,
            LOW_SWEEP = 56,
            AQUA_JET = 57,
            AQUA_TAIL = 58,
            SEED_BOMB = 59,
            PSYSHOCK = 60,
            ROCK_THROW = 61,
            ANCIENT_POWER = 62,
            ROCK_TOMB = 63,
            ROCK_SLIDE = 64,
            POWER_GEM = 65,
            SHADOW_SNEAK = 66,
            SHADOW_PUNCH = 67,
            SHADOW_CLAW = 68,
            OMINOUS_WIND = 69,
            SHADOW_BALL = 70,
            BULLET_PUNCH = 71,
            MAGNET_BOMB = 72,
            STEEL_WING = 73,
            IRON_HEAD = 74,
            PARABOLIC_CHARGE = 75,
            SPARK = 76,
            THUNDER_PUNCH = 77,
            THUNDER = 78,
            THUNDERBOLT = 79,
            TWISTER = 80,
            DRAGON_BREATH = 81,
            DRAGON_PULSE = 82,
            DRAGON_CLAW = 83,
            DISARMING_VOICE = 84,
            DRAINING_KISS = 85,
            DAZZLING_GLEAM = 86,
            MOONBLAST = 87,
            PLAY_ROUGH = 88,
            CROSS_POISON = 89,
            SLUDGE_BOMB = 90,
            SLUDGE_WAVE = 91,
            GUNK_SHOT = 92,
            MUD_SHOT = 93,
            BONE_CLUB = 94,
            BULLDOZE = 95,
            MUD_BOMB = 96,
            FURY_CUTTER = 97,
            BUG_BITE = 98,
            SIGNAL_BEAM = 99,
            X_SCISSOR = 100,
            FLAME_CHARGE = 101,
            FLAME_BURST = 102,
            FIRE_BLAST = 103,
            BRINE = 104,
            WATER_PULSE = 105,
            SCALD = 106,
            HYDRO_PUMP = 107,
            PSYCHIC = 108,
            PSYSTRIKE = 109,
            ICE_SHARD = 110,
            ICY_WIND = 111,
            FROST_BREATH = 112,
            ABSORB = 113,
            GIGA_DRAIN = 114,
            FIRE_PUNCH = 115,
            SOLAR_BEAM = 116,
            LEAF_BLADE = 117,
            POWER_WHIP = 118,
            SPLASH = 119,
            ACID = 120,
            AIR_CUTTER = 121,
            HURRICANE = 122,
            BRICK_BREAK = 123,
            CUT = 124,
            SWIFT = 125,
            HORN_ATTACK = 126,
            STOMP = 127,
            HEADBUTT = 128,
            HYPER_FANG = 129,
            SLAM = 130,
            BODY_SLAM = 131,
            REST = 132,
            STRUGGLE = 133,
            SCALD_BLASTOISE = 134,
            HYDRO_PUMP_BLASTOISE = 135,
            WRAP_GREEN = 136,
            WRAP_PINK = 137,
            FURY_CUTTER_FAST = 200,
            BUG_BITE_FAST = 201,
            BITE_FAST = 202,
            SUCKER_PUNCH_FAST = 203,
            DRAGON_BREATH_FAST = 204,
            THUNDER_SHOCK_FAST = 205,
            SPARK_FAST = 206,
            LOW_KICK_FAST = 207,
            KARATE_CHOP_FAST = 208,
            EMBER_FAST = 209,
            WING_ATTACK_FAST = 210,
            PECK_FAST = 211,
            LICK_FAST = 212,
            SHADOW_CLAW_FAST = 213,
            VINE_WHIP_FAST = 214,
            RAZOR_LEAF_FAST = 215,
            MUD_SHOT_FAST = 216,
            ICE_SHARD_FAST = 217,
            FROST_BREATH_FAST = 218,
            QUICK_ATTACK_FAST = 219,
            SCRATCH_FAST = 220,
            TACKLE_FAST = 221,
            POUND_FAST = 222,
            CUT_FAST = 223,
            POISON_JAB_FAST = 224,
            ACID_FAST = 225,
            PSYCHO_CUT_FAST = 226,
            ROCK_THROW_FAST = 227,
            METAL_CLAW_FAST = 228,
            BULLET_PUNCH_FAST = 229,
            WATER_GUN_FAST = 230,
            SPLASH_FAST = 231,
            WATER_GUN_FAST_BLASTOISE = 232,
            MUD_SLAP_FAST = 233,
            ZEN_HEADBUTT_FAST = 234,
            CONFUSION_FAST = 235,
            POISON_STING_FAST = 236,
            BUBBLE_FAST = 237,
            FEINT_ATTACK_FAST = 238,
            STEEL_WING_FAST = 239,
            FIRE_FANG_FAST = 240,
            ROCK_SMASH_FAST = 241,
            TRANSFORM_FAST = 242,
            COUNTER_FAST = 243,
            POWDER_SNOW_FAST = 244,
            CLOSE_COMBAT = 245,
            DYNAMIC_PUNCH = 246,
            FOCUS_BLAST = 247,
            AURORA_BEAM = 248,
            CHARGE_BEAM_FAST = 249,
            VOLT_SWITCH_FAST = 250,
            WILD_CHARGE = 251,
            ZAP_CANNON = 252,
            DRAGON_TAIL_FAST = 253,
            AVALANCHE = 254,
            AIR_SLASH_FAST = 255,
            BRAVE_BIRD = 256,
            SKY_ATTACK = 257,
            SAND_TOMB = 258,
            ROCK_BLAST = 259,
            INFESTATION_FAST = 260,
            STRUGGLE_BUG_FAST = 261,
            SILVER_WIND = 262,
            ASTONISH_FAST = 263,
            HEX_FAST = 264,
            NIGHT_SHADE = 265,
            IRON_TAIL_FAST = 266,
            GYRO_BALL = 267,
            HEAVY_SLAM = 268,
            FIRE_SPIN_FAST = 269,
            OVERHEAT = 270,
            BULLET_SEED_FAST = 271,
            GRASS_KNOT = 272,
            ENERGY_BALL = 273,
            EXTRASENSORY_FAST = 274,
            FUTURESIGHT = 275,
            MIRROR_COAT = 276,
            OUTRAGE = 277,
            SNARL_FAST = 278,
            CRUNCH = 279,
            FOUL_PLAY = 280,
            HIDDEN_POWER_FAST = 281,
            TAKE_DOWN_FAST = 282,
            WATERFALL_FAST = 283,
            SURF = 284,
            DRACO_METEOR = 285,
            DOOM_DESIRE = 286,
            YAWN_FAST = 287,
            PSYCHO_BOOST = 288,
            ORIGIN_PULSE = 289,
            PRECIPICE_BLADES = 290,
            PRESENT_FAST = 291,
            WEATHER_BALL_FIRE = 292,
            WEATHER_BALL_ICE = 293,
            WEATHER_BALL_ROCK = 294,
            WEATHER_BALL_WATER = 295,
            FRENZY_PLANT = 296,
            SMACK_DOWN_FAST = 297,
            BLAST_BURN = 298,
            HYDRO_CANNON = 299,
            LAST_RESORT = 300,
            METEOR_MASH = 301,
            SKULL_BASH = 302,
            ACID_SPRAY = 303,
            EARTH_POWER = 304,
            CRABHAMMER = 305,
            LUNGE = 306,
            CRUSH_CLAW = 307,
            OCTAZOOKA = 308,
            MIRROR_SHOT = 309,
            SUPER_POWER = 310,
            FELL_STINGER = 311,
            LEAF_TORNADO = 312,
            LEECH_LIFE = 313,
            DRAIN_PUNCH = 314,
            SHADOW_BONE = 315,
            MUDDY_WATER = 316,
            BLAZE_KICK = 317,
            RAZOR_SHELL = 318,
            POWER_UP_PUNCH = 319,
            CHARM_FAST = 320,
            GIGA_IMPACT = 321,
            FRUSTRATION = 322,
            RETURN = 323,
            SYNCHRONOISE = 324,
            LOCK_ON_FAST = 325,
            THUNDER_FANG_FAST = 326,
            ICE_FANG_FAST = 327,
            HORN_DRILL = 328,
            FISSURE = 329,
            SACRED_SWORD = 330,
            FLYING_PRESS = 331,
            AURA_SPHERE = 332,
            PAYBACK = 333,
            ROCK_WRECKER = 334,
            AEROBLAST = 335,
            TECHNO_BLAST_NORMAL = 336,
            TECHNO_BLAST_BURN = 337,
            TECHNO_BLAST_CHILL = 338,
            TECHNO_BLAST_WATER = 339,
            TECHNO_BLAST_SHOCK = 340,
            FLY = 341,
            V_CREATE = 342,
            LEAF_STORM = 343,
            TRI_ATTACK = 344,
            GUST_FAST = 345,
            INCINERATE_FAST = 346,
            DARK_VOID = 347,
            FEATHER_DANCE = 348,
            FIERY_DANCE = 349,
            FAIRY_WIND_FAST = 350,
            RELIC_SONG = 351,
            WEATHER_BALL_NORMAL = 352,
            PSYCHIC_FANGS = 353,
            HYPERSPACE_FURY = 354,
            HYPERSPACE_HOLE = 355,
            DOUBLE_KICK_FAST = 356,
            MAGICAL_LEAF_FAST = 357,
            SACRED_FIRE = 358,
            ICICLE_SPEAR = 359,
            AEROBLAST_PLUS = 360,
            AEROBLAST_PLUS_PLUS = 361,
            SACRED_FIRE_PLUS = 362,
            SACRED_FIRE_PLUS_PLUS = 363,
            ACROBATICS = 364,
            LUSTER_PURGE = 365,
            MIST_BALL = 366,
            BRUTAL_SWING = 367,
            ROLLOUT_FAST = 368,
            SEED_FLARE = 369,
            OBSTRUCT = 370,
            SHADOW_FORCE = 371,
            METEOR_BEAM = 372,
            WATER_SHURIKEN_FAST = 373,
            FUSION_BOLT = 374,
            FUSION_FLARE = 375,
            POLTERGEIST = 376,
            HIGH_HORSEPOWER = 377,
            GLACIATE = 378,
            BREAKING_SWIPE = 379,
            BOOMBURST = 380,
            DOUBLE_IRON_BASH = 381,
            MYSTICAL_FIRE = 382,
            LIQUIDATION = 383,
            DRAGON_ASCENT = 384,
            LEAFAGE_FAST = 385,
            MAGMA_STORM = 386,
            GEOMANCY_FAST = 387,
            SPACIAL_REND = 388,
            OBLIVION_WING = 389,
            NATURES_MADNESS = 390,
            TRIPLE_AXEL = 391,
            TRAILBLAZE = 392,
            SCORCHING_SANDS = 393,
            ROAR_OF_TIME = 394,
            BLEAKWIND_STORM = 395,
            SANDSEAR_STORM = 396,
            WILDBOLT_STORM = 397,
            SPIRIT_SHACKLE = 398,
            VOLT_TACKLE = 399,
            DARKEST_LARIAT = 400,
            PSYWAVE_FAST = 401,
            METAL_SOUND_FAST = 402,
            SAND_ATTACK_FAST = 403,
            SUNSTEEL_STRIKE = 404,
            MOONGEIST_BEAM = 405,
            AURA_WHEEL_ELECTRIC = 406,
            AURA_WHEEL_DARK = 407,
            HIGH_JUMP_KICK = 408,
            VN_BM_001 = 409,
            VN_BM_002 = 410,
            VN_BM_003 = 411,
            VN_BM_004 = 412,
            VN_BM_005 = 413,
            VN_BM_006 = 414,
            VN_BM_007 = 415,
            VN_BM_008 = 416,
            VN_BM_009 = 417,
            VN_BM_010 = 418,
            VN_BM_011 = 419,
            VN_BM_012 = 420,
            VN_BM_013 = 421,
            VN_BM_014 = 422,
            VN_BM_015 = 423,
            VN_BM_016 = 424,
            VN_BM_017 = 425,
            VN_BM_018 = 426,
            VN_BM_019 = 427,
            VN_BM_020 = 428,
            VN_BM_021 = 429,
            VN_BM_022 = 430,
            VN_BM_023 = 431,
            VN_BM_024 = 432,
            VN_BM_025 = 433,
            VN_BM_026 = 434,
            VN_BM_027 = 435,
            VN_BM_028 = 436,
            VN_BM_029 = 437,
            VN_BM_030 = 438,
            VN_BM_031 = 439,
            VN_BM_032 = 440,
            VN_BM_033 = 441,
            VN_BM_034 = 442,
            VN_BM_035 = 443,
            VN_BM_036 = 444,
            VN_BM_037 = 445,
            VN_BM_038 = 446,
            VN_BM_039 = 447,
            VN_BM_040 = 448,
            VN_BM_041 = 449,
            VN_BM_042 = 450,
            VN_BM_043 = 451,
            VN_BM_044 = 452,
            VN_BM_045 = 453,
            VN_BM_046 = 454,
            VN_BM_047 = 455,
            VN_BM_048 = 456,
            VN_BM_049 = 457,
            VN_BM_050 = 458,
            VN_BM_051 = 459,
            VN_BM_052 = 460,
            VN_BM_053 = 461,
            FORCE_PALM_FAST = 462,
            SPARKLING_ARIA = 463,
            RAGE_FIST = 464,
            FLOWER_TRICK = 465,
            FREEZE_SHOCK = 466,
            ICE_BURN = 467,
            TORCH_SONG = 468,
            BEHEMOTH_BLADE = 469,
            BEHEMOTH_BASH = 470,
            UPPER_HAND = 471,
            THUNDER_CAGE = 472,
            VN_BM_054 = 473,
            VN_BM_055 = 474,
            VN_BM_056 = 475,
            VN_BM_057 = 476,
            VN_BM_058 = 477,
            VN_BM_059 = 478,
            VN_BM_060 = 479,
            VN_BM_061 = 480
        }

        enum HoloPokemonMovementType {
            MOVEMENT_STATIC = 0,
            MOVEMENT_JUMP = 1,
            MOVEMENT_VERTICAL = 2,
            MOVEMENT_PSYCHIC = 3,
            MOVEMENT_ELECTRIC = 4,
            MOVEMENT_FLYING = 5,
            MOVEMENT_HOVERING = 6
        }

        enum HoloPokemonNature {
            NATURE_UNKNOWN = 0,
            POKEMON_NATURE_STOIC = 1,
            POKEMON_NATURE_ASSASSIN = 2,
            POKEMON_NATURE_GUARDIAN = 3,
            POKEMON_NATURE_RAIDER = 4,
            POKEMON_NATURE_PROTECTOR = 5,
            POKEMON_NATURE_SENTRY = 6,
            POKEMON_NATURE_CHAMPION = 7
        }

        enum HoloPokemonSize {
            POKEMON_SIZE_UNSET = 0,
            XXS = 1,
            XS = 2,
            M = 3,
            XL = 4,
            XXL = 5
        }

        enum HoloPokemonType {
            POKEMON_TYPE_NONE = 0,
            POKEMON_TYPE_NORMAL = 1,
            POKEMON_TYPE_FIGHTING = 2,
            POKEMON_TYPE_FLYING = 3,
            POKEMON_TYPE_POISON = 4,
            POKEMON_TYPE_GROUND = 5,
            POKEMON_TYPE_ROCK = 6,
            POKEMON_TYPE_BUG = 7,
            POKEMON_TYPE_GHOST = 8,
            POKEMON_TYPE_STEEL = 9,
            POKEMON_TYPE_FIRE = 10,
            POKEMON_TYPE_WATER = 11,
            POKEMON_TYPE_GRASS = 12,
            POKEMON_TYPE_ELECTRIC = 13,
            POKEMON_TYPE_PSYCHIC = 14,
            POKEMON_TYPE_ICE = 15,
            POKEMON_TYPE_DRAGON = 16,
            POKEMON_TYPE_DARK = 17,
            POKEMON_TYPE_FAIRY = 18
        }

        enum HoloTemporaryEvolutionId {
            TEMP_EVOLUTION_UNSET = 0,
            TEMP_EVOLUTION_MEGA = 1,
            TEMP_EVOLUTION_MEGA_X = 2,
            TEMP_EVOLUTION_MEGA_Y = 3,
            TEMP_EVOLUTION_PRIMAL = 4
        }

        enum IapLibraryVersion {
            IAP_LIBRARY_VERSION_DEFAULT = 0,
            IAP_LIBRARY_VERSION_IODINE_1_8 = 1,
            IAP_LIBRARY_VERSION_NIA_IAP_4 = 2
        }

        enum IbfcVfxKey {
            DEFAULT_NO_CHANGE = 0,
            DEFAULT_TO_ALTERNATE = 1,
            ALTERNATE_TO_DEFAULT = 2
        }

        enum IncidentDisplayType {
            INCIDENT_DISPLAY_TYPE_NONE = 0,
            INCIDENT_DISPLAY_TYPE_INVASION_GRUNT = 1,
            INCIDENT_DISPLAY_TYPE_INVASION_LEADER = 2,
            INCIDENT_DISPLAY_TYPE_INVASION_GIOVANNI = 3,
            INCIDENT_DISPLAY_TYPE_INVASION_GRUNTB = 4,
            INCIDENT_DISPLAY_TYPE_INVASION_EVENT_NPC = 5,
            INCIDENT_DISPLAY_TYPE_INVASION_ROUTES_NPC = 6,
            INCIDENT_DISPLAY_TYPE_INVASION_GENERIC = 7,
            INCIDENT_DISPLAY_TYPE_INCIDENT_POKESTOP_ENCOUNTER = 8,
            INCIDENT_DISPLAY_TYPE_INCIDENT_CONTEST = 9
        }

        enum InternalClientOperatingSystem {
            OS_UNKNOWN = 0,
            OS_ANDROID = 1,
            OS_IOS = 2,
            OS_DESKTOP = 3
        }

        enum InternalCrmClientActionMethod {
            INTERNAL_CRM_CLIENT_ACTION_UNKNOWN = 0,
            INTERNAL_CRM_CLIENT_ACTION_DELETE_ACCOUNT = 1,
            INTERNAL_CRM_CLIENT_ACTION_DATA_ACCESS = 2,
            INTERNAL_CRM_CLIENT_ACTION_DELETE_ACCOUNT_EMAIL_ON_FILE = 3
        }

        enum InternalGameAccountRegistryActions {
            UNKNOWN_GAME_ACCOUNT_REGISTRY_ACTION = 0,
            ADD_LOGIN_ACTION = 600000,
            REMOVE_LOGIN_ACTION = 600001,
            LIST_LOGIN_ACTION = 600002,
            REPLACE_LOGIN_ACTION = 600003,
            SET_BIRTHDAY_ACTION = 600004,
            GAR_PROXY_ACTION = 600005,
            LINK_TO_ACCOUNT_LOGIN_ACTION = 600006
        }

        enum InternalGameAdventureSyncAction {
            UNKNOWN_GAME_LOCATION_AWARENESS_ACTION = 0,
            REQUEST_GEOFENCE_UPDATES = 360000,
            UPDATE_PLAYER_LOCATION = 360001,
            BULK_UPDATE_PLAYER_LOCATION = 360002,
            UPDATE_BREADCRUMB_HISTORY = 361000,
            REFRESH_PROXIMITY_TOKENS = 362000,
            REPORT_PROXIMITY_CONTACTS = 362001
        }

        enum InternalGameAnticheatAction {
            UNKNOWN_GAME_ANTICHEAT_ACTION = 0,
            GET_OUTSTANDING_WARNINGS = 200000,
            ACKNOWLEDGE_WARNINGS = 200001
        }

        enum InternalGameAuthenticationActionMethod {
            UNKNOWN_GAME_AUTHENTICATION_ACTION = 0,
            ROTATE_GUEST_LOGIN_SECRET_TOKEN = 250011
        }

        enum InternalGameBackgroundModeAction {
            UNKNOWN_GAME_BACKGROUND_MODE_ACTION = 0,
            REGISTER_BACKGROUND_SERVICE = 230000,
            GET_CLIENT_BGMODE_SETTINGS = 230001,
            GET_ADVENTURE_SYNC_PROGRESS = 230002
        }

        enum InternalGameChatActions {
            UNKNOWN_GAME_CHAT_ACTION = 0,
            PROXY_CHAT_ACTION = 660000
        }

        enum InternalGameCrmActions {
            UNKNOWN_CRM_ACTION = 0,
            CRM_PROXY_ACTION = 680000
        }

        enum InternalGameFitnessAction {
            UNKNOWN_GAME_FITNESS_ACTION = 0,
            UPDATE_FITNESS_METRICS = 640000,
            GET_FITNESS_REPORT = 640001,
            GET_ADVENTURE_SYNC_SETTINGS = 640002,
            UPDATE_ADVENTURE_SYNC_SETTINGS = 640003,
            UPDATE_ADVENTURE_SYNC_FITNESS = 640004,
            GET_ADVENTURE_SYNC_FITNESS_REPORT = 640005
        }

        enum InternalGameGmTemplatesAction {
            UNKNOWN_GAME_GM_TEMPLATES_ACTION = 0,
            DOWNLOAD_GAME_MASTER_TEMPLATES = 340000
        }

        enum InternalGameIapAction {
            UNKNOWN_GAME_IAP_ACTION = 0,
            PURCHASE_SKU = 310000,
            GET_AVAILABLE_SKUS_AND_BALANCES = 310001,
            SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 310002,
            PURCHASE_WEB_SKU = 310003,
            REDEEM_GOOGLE_RECEIPT = 310100,
            REDEEM_APPLE_RECEIPT = 310101,
            REDEEM_DESKTOP_RECEIPT = 310102,
            REDEEM_SAMSUNG_RECEIPT = 310103,
            GET_AVAILABLE_SUBSCRIPTIONS = 310200,
            GET_ACTIVE_SUBSCRIPTIONS = 310201,
            REDEEM_XSOLLA_RECEIPT = 311100,
            GET_WEBSTORE_USER = 311101,
            REFUND_IAP_RECEIPT = 311102,
            GET_AVAILABLE_SKUS_ANONYMOUS = 311103,
            REDEEM_WEBSTORE_RECEIPT = 311104
        }

        enum InternalGameNotificationAction {
            UNKNOWN_GAME_NOTIFICATION_ACTION = 0,
            UPDATE_NOTIFICATION_STATUS = 350000
        }

        enum InternalGamePasscodeAction {
            UNKNOWN_GAME_PASSCODE_ACTION = 0,
            REDEEM_PASSCODE = 330000
        }

        enum InternalGamePingAction {
            UNKNOWN_GAME_PING_ACTION = 0,
            PING = 220000,
            PING_ASYNC = 220001,
            PING_DOWNSTREAM = 220002,
            PING_OPEN = 221000
        }

        enum InternalGamePlayerAction {
            UNKNOWN_GAME_PLAYER_ACTION = 0,
            GET_INVENTORY = 380000
        }

        enum InternalGamePoiAction {
            UNKNOWN_GAME_POI_ACTION = 0,
            ADD_NEW_POI = 620000,
            GET_AVAILABLE_SUBMISSIONS = 620001,
            GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 620002,
            GET_PLAYER_SUBMISSION_VALIDATION_SETTINGS = 620003,
            SUBMIT_POI_IMAGE = 620100,
            SUBMIT_POI_TEXT_METADATA_UPDATE = 620101,
            SUBMIT_POI_LOCATION_UPDATE = 620102,
            SUBMIT_POI_TAKEDOWN_REQUEST = 620103,
            SUBMIT_SPONSOR_POI_REPORT = 620104,
            SUBMIT_SPONSOR_POI_LOCATION_UPDATE = 620105,
            ADD_NEW_ROUTE = 620200,
            GENERATE_GMAP_SIGNED_URL = 620300,
            GET_GMAP_SETTINGS = 620301,
            SUBMIT_POI_AR_VIDEO_METADATA = 620400,
            GET_GRAPESHOT_FILE_UPLOAD_URL = 620401,
            ASYNC_FILE_UPLOAD_COMPLETE = 620402
        }

        enum InternalGamePushNotificationAction {
            UNKNOWN_GAME_PUSH_NOTIFICATION_ACTION = 0,
            REGISTER_PUSH_NOTIFICATION = 320000,
            UNREGISTER_PUSH_NOTIFICATION = 320001,
            OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 320002,
            REGISTER_PUSH_NOTIFICATION_TOKEN = 320003,
            UNREGISTER_PUSH_NOTIFICATION_TOKEN = 320004,
            OPT_OUT_PUSH_NOTIFICATION_TOKEN_CATEGORY = 320005
        }

        enum InternalGameSocialAction {
            UNKNOWN_GAME_SOCIAL_ACTION = 0,
            PROXY_SOCIAL_ACTION = 630000,
            PROXY_SOCIAL_SIDE_CHANNEL_ACTION = 630001
        }

        enum InternalGameTelemetryAction {
            UNKNOWN_GAME_TELEMETRY_ACTION = 0,
            COLLECT_CLIENT_TELEMETRY = 610000,
            GET_CLIENT_TELEMETRY_SETTINGS = 610001
        }

        enum InternalGameWebTokenAction {
            UNKNOWN_GAME_WEB_TOKEN_ACTION = 0,
            GET_WEB_TOKEN_ACTION = 370000
        }

        enum InternalGarClientActionMethod {
            INTERNAL_GAR_CLIENT_ACTION_UNKNOWN_GAR_CLIENT_ACTION = 0,
            INTERNAL_GAR_CLIENT_ACTION_GET_MY_ACCOUNT = 1,
            INTERNAL_GAR_CLIENT_ACTION_SEND_SMS_VERIFICATION_CODE = 2,
            INTERNAL_GAR_CLIENT_ACTION_UPDATE_PHONE_NUMBER = 3,
            INTERNAL_GAR_CLIENT_ACTION_CREATE_SHARED_LOGIN_TOKEN = 4,
            INTERNAL_GAR_CLIENT_ACTION_GET_CLIENT_SETTINGS = 5,
            INTERNAL_GAR_CLIENT_ACTION_SET_ACCOUNT_CONTACT_SETTINGS = 6,
            INTERNAL_GAR_CLIENT_ACTION_DELETE_PHONE_NUMBER = 7,
            INTERNAL_GAR_CLIENT_ACTION_ACKNOWLEDGE_INFORMATION = 8,
            INTERNAL_GAR_CLIENT_ACTION_CHECK_AVATAR_IMAGES = 9,
            INTERNAL_GAR_CLIENT_ACTION_UPDATE_AVATAR_IMAGE = 10
        }

        enum InternalIdentityProvider {
            INTERNAL_UNSET_IDENTITY_PROVIDER = 0,
            INTERNAL_GOOGLE = 1,
            INTERNAL_PTC = 2,
            INTERNAL_FACEBOOK = 3,
            INTERNAL_BACKGROUND = 4,
            INTERNAL_INTERNAL = 5,
            INTERNAL_SFIDA = 6,
            INTERNAL_SUPER_AWESOME = 7,
            INTERNAL_DEVELOPER = 8,
            INTERNAL_SHARED_SECRET = 9,
            INTERNAL_POSEIDON = 10,
            INTERNAL_NINTENDO = 11,
            INTERNAL_APPLE = 12,
            INTERNAL_NIANTIC_SHARED_LOGIN_TOKEN = 13,
            INTERNAL_GUEST_LOGIN_TOKEN = 14,
            INTERNAL_EIGHTH_WALL = 15,
            INTERNAL_PTC_OAUTH = 16
        }

        enum InternalInvitationType {
            INVITATION_TYPE_UNSET = 0,
            INVITATION_TYPE_CODE = 1,
            INVITATION_TYPE_FACEBOOK = 2,
            INVITATION_TYPE_SERVER_REQUEST = 3,
            INVITATION_TYPE_NIANTIC_SOCIAL_GRAPH = 4,
            INVITATION_TYPE_ADDRESS_BOOK_IMPORT = 5
        }

        enum InternalNotificationState {
            INTERNAL_NOTIFICATION_STATE_UNSET_STATE = 0,
            INTERNAL_NOTIFICATION_STATE_VIEWED = 1
        }

        enum InternalPlatformClientAction {
            INTERNAL_UNKNOWN_PLATFORM_CLIENT_ACTION = 0,
            INTERNAL_REGISTER_PUSH_NOTIFICATION = 5000,
            INTERNAL_UNREGISTER_PUSH_NOTIFICATION = 5001,
            INTERNAL_UPDATE_NOTIFICATION_STATUS = 5002,
            INTERNAL_OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 5003,
            INTERNAL_DOWNLOAD_GAME_MASTER_TEMPLATES = 5004,
            INTERNAL_GET_INVENTORY = 5005,
            INTERNAL_REDEEM_PASSCODE = 5006,
            INTERNAL_PING = 5007,
            INTERNAL_ADD_LOGIN_ACTION = 5008,
            INTERNAL_REMOVE_LOGIN_ACTION = 5009,
            INTERNAL_LIST_LOGIN_ACTION = 5010,
            INTERNAL_ADD_NEW_POI = 5011,
            INTERNAL_PROXY_SOCIAL_ACTION = 5012,
            INTERNAL_DEPRECATED_CLIENT_TELEMETRY = 5013,
            INTERNAL_GET_AVAILABLE_SUBMISSIONS = 5014,
            INTERNAL_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 5015,
            INTERNAL_REPLACE_LOGIN_ACTION = 5016,
            INTERNAL_PROXY_SOCIAL_SIDE_CHANNEL_ACTION = 5017,
            INTERNAL_COLLECT_CLIENT_TELEMETRY = 5018,
            INTERNAL_PURCHASE_SKU = 5019,
            INTERNAL_GET_AVAILABLE_SKUS_AND_BALANCES = 5020,
            INTERNAL_REDEEM_GOOGLE_RECEIPT = 5021,
            INTERNAL_REDEEM_APPLE_RECEIPT = 5022,
            INTERNAL_REDEEM_DESKTOP_RECEIPT = 5023,
            INTERNAL_UPDATE_FITNESS_METRICS = 5024,
            INTERNAL_GET_FITNESS_REPORT = 5025,
            INTERNAL_GET_CLIENT_TELEMETRY_SETTINGS = 5026,
            INTERNAL_PING_ASYNC = 5027,
            INTERNAL_REGISTER_BACKGROUND_SERVICE = 5028,
            INTERNAL_GET_CLIENT_BGMODE_SETTINGS = 5029,
            INTERNAL_PING_DOWNSTREAM = 5030,
            INTERNAL_SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 5032,
            INTERNAL_REQUEST_GEOFENCE_UPDATES = 5033,
            INTERNAL_UPDATE_PLAYER_LOCATION = 5034,
            INTERNAL_GENERATE_GMAP_SIGNED_URL = 5035,
            INTERNAL_GET_GMAP_SETTINGS = 5036,
            INTERNAL_REDEEM_SAMSUNG_RECEIPT = 5037,
            INTERNAL_ADD_NEW_ROUTE = 5038,
            INTERNAL_GET_OUTSTANDING_WARNINGS = 5039,
            INTERNAL_ACKNOWLEDGE_WARNINGS = 5040,
            INTERNAL_SUBMIT_POI_IMAGE = 5041,
            INTERNAL_SUBMIT_POI_TEXT_METADATA_UPDATE = 5042,
            INTERNAL_SUBMIT_POI_LOCATION_UPDATE = 5043,
            INTERNAL_SUBMIT_POI_TAKEDOWN_REQUEST = 5044,
            INTERNAL_GET_WEB_TOKEN_ACTION = 5045,
            INTERNAL_GET_ADVENTURE_SYNC_SETTINGS = 5046,
            INTERNAL_UPDATE_ADVENTURE_SYNC_SETTINGS = 5047,
            INTERNAL_SET_BIRTHDAY = 5048,
            INTERNAL_FETCH_NEWSFEED_ACTION = 5049,
            INTERNAL_MARK_NEWSFEED_READ_ACTION = 5050
        }

        enum InternalPlatformWarningType {
            INTERNAL_PLATFORM_WARNING_UNSET = 0,
            INTERNAL_PLATFORM_WARNING_STRIKE1 = 1,
            INTERNAL_PLATFORM_WARNING_STRIKE2 = 2,
            INTERNAL_PLATFORM_WARNING_STRIKE3 = 3
        }

        enum InternalSocialAction {
            SOCIAL_ACTION_UNKNOWN_SOCIAL_ACTION = 0,
            SOCIAL_ACTION_SEARCH_PLAYER = 10000,
            SOCIAL_ACTION_SEND_FRIEND_INVITE = 10002,
            SOCIAL_ACTION_CANCEL_FRIEND_INVITE = 10003,
            SOCIAL_ACTION_ACCEPT_FRIEND_INVITE = 10004,
            SOCIAL_ACTION_DECLINE_FRIEND_INVITE = 10005,
            SOCIAL_ACTION_LIST_FRIENDS = 10006,
            SOCIAL_ACTION_LIST_OUTGOING_FRIEND_INVITES = 10007,
            SOCIAL_ACTION_LIST_INCOMING_FRIEND_INVITES = 10008,
            SOCIAL_ACTION_REMOVE_FRIEND = 10009,
            SOCIAL_ACTION_LIST_FRIEND_STATUS = 10010,
            SOCIAL_ACTION_SEND_FACEBOOK_FRIEND_INVITE = 10011,
            SOCIAL_ACTION_IS_MY_FRIEND = 10012,
            SOCIAL_ACTION_CREATE_INVITE_CODE = 10013,
            SOCIAL_ACTION_GET_FACEBOOK_FRIEND_LIST = 10014,
            SOCIAL_ACTION_UPDATE_FACEBOOK_STATUS = 10015,
            SOCIAL_ACTION_SAVE_PLAYER_SETTINGS = 10016,
            SOCIAL_ACTION_GET_PLAYER_SETTINGS = 10017,
            SOCIAL_ACTION_GET_NIANTIC_FRIEND_LIST_DELETED = 10018,
            SOCIAL_ACTION_GET_NIANTIC_FRIEND_DETAILS_DELETED = 10019,
            SOCIAL_ACTION_SEND_NIANTIC_FRIEND_INVITE_DELETED = 10020,
            SOCIAL_ACTION_SET_ACCOUNT_SETTINGS = 10021,
            SOCIAL_ACTION_GET_ACCOUNT_SETTINGS = 10022,
            SOCIAL_ACTION_ADD_FAVORITE_FRIEND = 10023,
            SOCIAL_ACTION_REMOVE_FAVORITE_FRIEND = 10024,
            SOCIAL_ACTION_BLOCK_ACCOUNT = 10025,
            SOCIAL_ACTION_UNBLOCK_ACCOUNT = 10026,
            SOCIAL_ACTION_GET_OUTGING_BLOCKS = 10027,
            SOCIAL_ACTION_IS_ACCOUNT_BLOCKED = 10028,
            SOCIAL_ACTION_LIST_FRIEND_ACTIVITIES = 10029,
            SOCIAL_ACTION_REGISTER_PUSH_NOTIFICATION = 10101,
            SOCIAL_ACTION_UNREGISTER_PUSH_NOTIFICATION = 10102,
            SOCIAL_ACTION_UPDATE_NOTIFICATION = 10103,
            SOCIAL_ACTION_OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 10104,
            SOCIAL_ACTION_GET_INBOX = 10105,
            SOCIAL_ACTION_LIST_OPT_OUT_NOTIFICATION_CATEGORIES = 10106,
            SOCIAL_ACTION_GET_SIGNED_URL = 10201,
            SOCIAL_ACTION_SUBMIT_IMAGE = 10202,
            SOCIAL_ACTION_GET_PHOTOS = 10203,
            SOCIAL_ACTION_DELETE_PHOTO = 10204,
            SOCIAL_ACTION_FLAG_PHOTO = 10205,
            SOCIAL_ACTION_UPDATE_PROFILE_V2 = 20001,
            SOCIAL_ACTION_UPDATE_FRIENDSHIP_V2 = 20002,
            SOCIAL_ACTION_GET_PROFILE_V2 = 20003,
            SOCIAL_ACTION_INVITE_GAME_V2 = 20004,
            SOCIAL_ACTION_RESERVED_ACTION_2 = 20005,
            SOCIAL_ACTION_LIST_FRIENDS_V2 = 20006,
            SOCIAL_ACTION_GET_FRIEND_DETAILS_V2 = 20007,
            SOCIAL_ACTION_GET_CLIENT_FEATURE_FLAGS_V2 = 20008,
            SOCIAL_ACTION_RESERVED_ACTION_1 = 20009,
            SOCIAL_ACTION_GET_INCOMING_GAME_INVITES_V2 = 20010,
            SOCIAL_ACTION_UPDATE_INCOMING_GAME_INVITE_V2 = 20011,
            SOCIAL_ACTION_DISMISS_OUTGOING_GAME_INVITES_V2 = 20012,
            SOCIAL_ACTION_SYNC_CONTACT_LIST_V2 = 20013,
            SOCIAL_ACTION_SEND_CONTACT_LIST_FRIEND_INVITE_V2 = 20014,
            SOCIAL_ACTION_REFER_CONTACT_LIST_FRIEND_V2 = 20015,
            SOCIAL_ACTION_GET_CONTACT_LIST_INFO_V2 = 20016,
            SOCIAL_ACTION_DISMISS_CONTACT_LIST_UPDATE_V2 = 20017,
            SOCIAL_ACTION_NOTIFY_CONTACT_LIST_FRIENDS_V2 = 20018,
            SOCIAL_ACTION_RESERVED_ACTION_6 = 20019,
            SOCIAL_ACTION_RESERVED_ACTION_7 = 20020,
            SOCIAL_ACTION_RESERVED_ACTION_3 = 20400,
            SOCIAL_ACTION_RESERVED_ACTION_4 = 20401,
            SOCIAL_ACTION_RESERVED_ACTION_5 = 20402,
            SOCIAL_ACTION_GET_FRIEND_RECOMMENDATION = 20500
        }

        enum InternalSource {
            DEFAULT_UNSET = 0,
            MODERATION = 1,
            ANTICHEAT = 2,
            RATE_LIMITED = 3
        }

        enum InvasionTelemetryIds {
            INVASION_TELEMETRY_IDS_UNDEFINED_INVASION_EVENT = 0,
            INVASION_TELEMETRY_IDS_INVASION_NPC_TAP = 1,
            INVASION_TELEMETRY_IDS_INVASION_BATTLE_STARTED = 2,
            INVASION_TELEMETRY_IDS_INVASION_BATTLE_FINISHED = 3,
            INVASION_TELEMETRY_IDS_INVASION_ENCOUNTER_STARTED = 4,
            INVASION_TELEMETRY_IDS_INVASION_ENCOUNTER_FINISHED = 5,
            INVASION_TELEMETRY_IDS_INVASION_POKEMON_PURIFIED = 6,
            INVASION_TELEMETRY_IDS_INVASION_AFTER_POI_EXITED = 7,
            INVASION_TELEMETRY_IDS_INVASION_RADAR_VIEW_OPENED = 8,
            INVASION_TELEMETRY_IDS_INVASION_RADAR_VIEW_CLOSED = 9,
            INVASION_TELEMETRY_IDS_INVASION_RADAR_VIEW_EMPTY = 10,
            INVASION_TELEMETRY_IDS_INVASION_DECOY_FOUND = 11,
            INVASION_TELEMETRY_IDS_INVASION_GIOVANNI_FOUND = 12,
            INVASION_TELEMETRY_IDS_INVASION_BALLOON_TAP = 13
        }

        enum InventoryGuiContext {
            CTX_UNKNOWN = 0,
            MAIN_MENU = 1,
            GYM_PREP = 2,
            PARTY_SELECT = 3,
            RAID_LOBBY = 4,
            BREAD_LOBBY = 5,
            POKEMON_INFO = 6,
            SPONSORED_GIFT_INVENTORY_FULL = 7,
            COMBAT_HUB_INVENTORY_FULL = 8,
            QUICK_SHOP_INVENTORY_FULL = 9
        }

        enum InventoryUpgradeType {
            UPGRADE_UNSET = 0,
            INCREASE_ITEM_STORAGE = 1,
            INCREASE_POKEMON_STORAGE = 2,
            INCREASE_POSTCARD_STORAGE = 3
        }

        enum IrisFtueVersion {
            CLASSIC = 0,
            MVP_AUG_30 = 1
        }

        enum IrisSocialEvent {
            IRIS_SOCIAL_EVENT_UNSET = 0,
            USER_ENTERED_EXPERIENCE = 1,
            CAMERA_PERMISSIONS_APPROVED = 2,
            IRIS_SOCIAL_SCENE_TUTORIAL_STEPS_SHOWN = 3,
            POKEMON_PLACEMENT_TUTORIAL_SHOWN = 4,
            SAFETY_PROMPT_ACKNOWLEDGED = 5,
            HINT_IMAGE_ACKNOWLEDGED = 6,
            VISUAL_CUES_SHOWN = 7,
            LOCALIZATION_INTENTIONALLY_PAUSED = 8,
            LOCALIZATION_SUCCESSFUL = 9,
            INTERRUPTION_EXITING_PLAYER_BOUNDS = 10,
            INTERRUPTION_TRACKING_LOST = 11,
            INTERRUPTION_APP_BACKGROUNDED = 12,
            INTERRUPTION_OTHER = 13,
            SCENE_LOADED = 14,
            POKEBALL_BUTTON_CLICKED = 15,
            POKEMON_SELECTED = 16,
            POKEMON_PLACED = 17,
            POKEMON_RECALLED = 18,
            POKEMON_REPLACED = 19,
            POKEMON_PLACEMENT_EDITED = 20,
            RETURN_TO_CAMERA_SCENE = 21,
            EXIT_EXPERIENCE = 22,
            VPS_DIAGNOSTICS_FEEDBACK_PRESENTED = 23,
            PICTURE_TAKEN = 24,
            LOCALIZATION_TIMEOUT = 25,
            DIAG_SLOW_DOWN = 26,
            DIAG_LOOKUP = 27,
            DIAG_OBSTRUCTED = 28,
            DIAG_AVOID_GLARE = 29,
            DIAG_BLURRY_IMAGE = 30,
            DIAG_FIND_BETTER_LIGHTING = 31,
            DIAG_LOOK_AT_POI = 32,
            DIAG_SLOW_NETWORK = 33,
            LOCALIZATION_POINTED_AT_GROUND = 34,
            LOCALIZATION_SUMMONED_GROUND_UI = 35,
            LOCALIZATION_LIMITED_DETECTED = 36,
            LOCALIZATION_LIMITED_GYUDANCE_INITIATED = 37,
            VPS_SESSION_GENERATED = 38,
            FEEDBACK_CANT_FIND_LANDMARK = 39,
            FEEDBACK_HINT_IMAGE_UNCLEAR = 40,
            FEEDBACK_DONT_KNOW_WHAT_TO_DO = 41,
            FEEDBACK_NOTHING_IS_HAPPENING = 42,
            FEEDBACK_UNSUITABLE_AR_LOCATION = 43,
            FEEDBACK_CANT_PLACE_POKEMON = 44,
            FEEDBACK_CANT_FIND_BOUNDS = 45,
            FEEDBACK_CANT_TAKE_PICTURE = 46,
            FEEDBACK_DONT_KNOW_WHAT_TO_DO_GAMEPLAY = 47,
            FEEDBACK_UNSUITABLE_POKEMON_PLACEMENT = 48,
            LOCALIZATION_LIMITED_NEARBY_FINISH = 49,
            FEEDBACK_BOUNDS_TOO_SMALL = 50,
            EJECTION_WEAK_CONNECTION = 51,
            EJECTION_SERVER_RESPONSE_ERROR = 52,
            EJECTION_ASSET_LOADING_FAILURE = 53,
            EJECTION_THERMAL_WARNING = 54,
            EJECTION_THERMAL_CRITICAL = 55,
            WEATHER_WARNING_NOTIFICATION_SHOWN = 56,
            WEATHER_WARNING_MODAL_SHOWN = 57
        }

        enum IrisSocialPokemonExpression {
            POKEMON_EXPRESSION_UNSET = 0,
            SMILE_AND_WAVE = 1
        }

        enum Item {
            ITEM_UNKNOWN = 0,
            ITEM_POKE_BALL = 1,
            ITEM_GREAT_BALL = 2,
            ITEM_ULTRA_BALL = 3,
            ITEM_MASTER_BALL = 4,
            ITEM_PREMIER_BALL = 5,
            ITEM_BEAST_BALL = 6,
            ITEM_WILD_BALL = 7,
            ITEM_WILD_BALL_PREMIER = 8,
            ITEM_POTION = 101,
            ITEM_SUPER_POTION = 102,
            ITEM_HYPER_POTION = 103,
            ITEM_MAX_POTION = 104,
            ITEM_REVIVE = 201,
            ITEM_MAX_REVIVE = 202,
            ITEM_LUCKY_EGG = 301,
            ITEM_MAX_BOOST = 302,
            ITEM_LUCKY_FRIEND_APPLICATOR = 303,
            ITEM_SINGLE_STAT_INCREASE = 304,
            ITEM_TRIPLE_STAT_INCREASE = 305,
            ITEM_INCENSE_ORDINARY = 401,
            ITEM_INCENSE_SPICY = 402,
            ITEM_INCENSE_COOL = 403,
            ITEM_INCENSE_FLORAL = 404,
            ITEM_INCENSE_BELUGA_BOX = 405,
            ITEM_INCENSE_DAILY_ADVENTURE = 406,
            ITEM_INCENSE_SPARKLY = 407,
            ITEM_INCENSE_DAY_BONUS = 408,
            ITEM_INCENSE_NIGHT_BONUS = 409,
            ITEM_TROY_DISK = 501,
            ITEM_TROY_DISK_GLACIAL = 502,
            ITEM_TROY_DISK_MOSSY = 503,
            ITEM_TROY_DISK_MAGNETIC = 504,
            ITEM_TROY_DISK_RAINY = 505,
            ITEM_TROY_DISK_SPARKLY = 506,
            ITEM_X_ATTACK = 602,
            ITEM_X_DEFENSE = 603,
            ITEM_X_MIRACLE = 604,
            ITEM_BEANS = 650,
            ITEM_BREAKFAST = 651,
            ITEM_RAZZ_BERRY = 701,
            ITEM_BLUK_BERRY = 702,
            ITEM_NANAB_BERRY = 703,
            ITEM_WEPAR_BERRY = 704,
            ITEM_PINAP_BERRY = 705,
            ITEM_GOLDEN_RAZZ_BERRY = 706,
            ITEM_GOLDEN_NANAB_BERRY = 707,
            ITEM_GOLDEN_PINAP_BERRY = 708,
            ITEM_POFFIN = 709,
            ITEM_SPECIAL_CAMERA = 801,
            ITEM_STICKER_INVENTORY = 802,
            ITEM_POSTCARD_INVENTORY = 803,
            ITEM_INCUBATOR_BASIC_UNLIMITED = 901,
            ITEM_INCUBATOR_BASIC = 902,
            ITEM_INCUBATOR_SUPER = 903,
            ITEM_POKEMON_STORAGE_UPGRADE = 1001,
            ITEM_ITEM_STORAGE_UPGRADE = 1002,
            ITEM_POSTCARD_STORAGE_UPGRADE = 1003,
            ITEM_SUN_STONE = 1101,
            ITEM_KINGS_ROCK = 1102,
            ITEM_METAL_COAT = 1103,
            ITEM_DRAGON_SCALE = 1104,
            ITEM_UP_GRADE = 1105,
            ITEM_GEN4_EVOLUTION_STONE = 1106,
            ITEM_GEN5_EVOLUTION_STONE = 1107,
            ITEM_OTHER_EVOLUTION_STONE_A = 1150,
            ITEM_OTHER_EVOLUTION_STONE_MAPLE_A = 1151,
            ITEM_OTHER_EVOLUTION_STONE_MAPLE_B = 1152,
            ITEM_RESOURCE_CROWNED_ZACIAN = 1153,
            ITEM_RESOURCE_CROWNED_ZAMAZENTA = 1154,
            ITEM_MOVE_REROLL_FAST_ATTACK = 1201,
            ITEM_MOVE_REROLL_SPECIAL_ATTACK = 1202,
            ITEM_MOVE_REROLL_ELITE_FAST_ATTACK = 1203,
            ITEM_MOVE_REROLL_ELITE_SPECIAL_ATTACK = 1204,
            ITEM_MOVE_REROLL_OTHER_SPECIAL_ATTACK_A = 1250,
            ITEM_RARE_CANDY = 1301,
            ITEM_XL_RARE_CANDY = 1302,
            ITEM_FUSION_RESOURCE_DAWNWINGS_NECROZMA = 1350,
            ITEM_FUSION_RESOURCE_DUSKMANE_NECROZMA = 1351,
            ITEM_FUSION_RESOURCE_BLACK_KYUREM = 1352,
            ITEM_FUSION_RESOURCE_WHITE_KYUREM = 1353,
            ITEM_FUSION_RESOURCE_ICERIDER_CALYREX = 1354,
            FUSION_RESOURCE_SPECTRALRIDER_CALYREX = 1355,
            ITEM_FREE_RAID_TICKET = 1401,
            ITEM_PAID_RAID_TICKET = 1402,
            ITEM_STAR_PIECE = 1404,
            ITEM_FRIEND_GIFT_BOX = 1405,
            ITEM_TEAM_CHANGE = 1406,
            ITEM_ROUTE_MAKER = 1407,
            ITEM_REMOTE_RAID_TICKET = 1408,
            ITEM_S_RAID_TICKET = 1409,
            ITEM_LEADER_MAP_FRAGMENT = 1501,
            ITEM_LEADER_MAP = 1502,
            ITEM_GIOVANNI_MAP = 1503,
            ITEM_SHADOW_GEM_FRAGMENT = 1504,
            ITEM_SHADOW_GEM = 1505,
            ITEM_MP = 1506,
            ITEM_MP_REPLENISH = 1507,
            ITEM_GLOBAL_EVENT_TICKET = 1600,
            ITEM_EVENT_TICKET_PINK = 1601,
            ITEM_EVENT_TICKET_GRAY = 1602,
            ITEM_GLOBAL_EVENT_TICKET_TO_GIFT = 1603,
            ITEM_EVENT_TICKET_PINK_TO_GIFT = 1604,
            ITEM_EVENT_TICKET_GRAY_TO_GIFT = 1605,
            ITEM_BATTLE_PASS_TICKET = 1606,
            ITEM_EVERGREEN_TICKET = 1607,
            ITEM_EVERGREEN_TICKET_TO_GIFT = 1608,
            ITEM_DEPRECATED_1 = 1609,
            ITEM_TICKET_CITY_SAFARI_00 = 1610,
            ITEM_TICKET_CITY_SAFARI_01 = 1611,
            ITEM_TICKET_CITY_SAFARI_02 = 1612,
            ITEM_TICKET_CITY_SAFARI_03 = 1613,
            ITEM_TICKET_CITY_SAFARI_04 = 1614,
            ITEM_EVENT_TICKET_01 = 1615,
            ITEM_EVENT_TICKET_02 = 1616,
            ITEM_EVENT_TICKET_03 = 1617,
            ITEM_EVENT_TICKET_04 = 1618,
            ITEM_EVENT_TICKET_05 = 1619,
            ITEM_EVENT_TICKET_06 = 1620,
            ITEM_EVENT_TICKET_07 = 1621,
            ITEM_EVENT_TICKET_08 = 1622,
            ITEM_EVENT_TICKET_09 = 1623,
            ITEM_EVENT_TICKET_10 = 1624,
            ITEM_EVENT_TICKET_01_TO_GIFT = 1625,
            ITEM_EVENT_TICKET_02_TO_GIFT = 1626,
            ITEM_EVENT_TICKET_03_TO_GIFT = 1627,
            ITEM_EVENT_TICKET_04_TO_GIFT = 1628,
            ITEM_EVENT_TICKET_05_TO_GIFT = 1629,
            ITEM_EVENT_TICKET_06_TO_GIFT = 1630,
            ITEM_EVENT_TICKET_07_TO_GIFT = 1631,
            ITEM_EVENT_TICKET_08_TO_GIFT = 1632,
            ITEM_EVENT_TICKET_09_TO_GIFT = 1633,
            ITEM_EVENT_TICKET_10_TO_GIFT = 1634,
            ITEM_EVENT_PASS_POINT_GO_TOUR_01 = 2001,
            ITEM_EVENT_PASS_POINT_GO_TOUR_02 = 2002,
            ITEM_EVENT_PASS_POINT_GO_TOUR_03 = 2003,
            ITEM_EVENT_PASS_POINT_GO_TOUR_04 = 2004,
            ITEM_EVENT_PASS_POINT_GO_FEST_01 = 2021,
            ITEM_EVENT_PASS_POINT_GO_FEST_02 = 2022,
            ITEM_EVENT_PASS_POINT_GO_FEST_03 = 2023,
            ITEM_EVENT_PASS_POINT_GO_FEST_04 = 2024,
            ITEM_EVENT_PASS_POINT_GO_WILD_AREA_01 = 2041,
            ITEM_EVENT_PASS_POINT_GO_WILD_AREA_02 = 2042,
            ITEM_EVENT_PASS_POINT_GO_WILD_AREA_03 = 2043,
            ITEM_EVENT_PASS_POINT_GO_WILD_AREA_04 = 2044,
            ITEM_EVENT_PASS_POINT_LIVE_OPS_01 = 2101,
            ITEM_EVENT_PASS_POINT_LIVE_OPS_02 = 2102,
            ITEM_EVENT_PASS_POINT_LIVE_OPS_03 = 2103,
            ITEM_EVENT_PASS_POINT_LIVE_OPS_04 = 2104
        }

        enum ItemUseTelemetryIds {
            ITEM_USE_TELEMETRY_IDS_UNDEFINED_ITEM_EVENT = 0,
            ITEM_USE_TELEMETRY_IDS_USE_ITEM = 1,
            ITEM_USE_TELEMETRY_IDS_RECYCLE_ITEM = 2,
            ITEM_USE_TELEMETRY_IDS_UPDATE_ITEM_EQUIPPED = 3
        }

        enum LayerKind {
            LAYER_UNDEFINED = 0,
            LAYER_BOUNDARIES = 1,
            LAYER_BUILDINGS = 2,
            LAYER_LANDUSE = 4,
            LAYER_PLACES = 5,
            LAYER_ROADS = 7,
            LAYER_TRANSIT = 8,
            LAYER_WATER = 9,
            LAYER_BIOME = 11
        }

        enum LocationCard {
            LOCATION_CARD_UNSET = 0,
            LC_2023_LASVEGAS_GOTOUR_001 = 1,
            LC_2023_JEJU_AIRADVENTURES_001 = 2,
            LC_2023_NYC_GOFEST_001 = 3,
            LC_2023_LONDON_GOFEST_001 = 4,
            LC_2023_OSAKA_GOFEST_001 = 5,
            LC_2023_SEOUL_CITYSAFARI_001 = 6,
            LC_2023_BARCELONA_CITYSAFARI_001 = 7,
            LC_2023_MEXICOCITY_CITYSAFARI_001 = 8,
            LC_2024_LOSANGELES_GOTOUR_001 = 9,
            LC_2024_BALI_AIRADVENTURES_001 = 10,
            LC_2024_TAINAN_CITYSAFARI_001 = 11,
            LC_2024_SENDAI_GOFEST_001 = 12,
            LC_2024_MADRID_GOFEST_001 = 13,
            LC_2024_NYC_GOFEST_001 = 14,
            LC_SPECIALBACKGROUND_2024_GLOBAL_GOFEST_RADIANCE_001 = 15,
            LC_SPECIALBACKGROUND_2024_GLOBAL_GOFEST_UMBRA_001 = 16,
            LC_SPECIALBACKGROUND_2024_GLOBAL_GOFEST_COMBINATION_001 = 17,
            LC_SPECIALBACKGROUND_TEAM_BLUE = 18,
            LC_SPECIALBACKGROUND_TEAM_RED = 19,
            LC_SPECIALBACKGROUND_TEAM_YELLOW = 20,
            LC_2024_SURABAYA_AIRADVENTURES_001 = 21,
            LC_2024_YOGYAKARTA_AIRADVENTURES_001 = 22,
            LC_2024_JAKARTA_AIRADVENTURES_001 = 23,
            LC_SPECIAL_BACKGROUND_2024_GLOBAL_GOFEST_ULTRA_WORMHOLE_001 = 24,
            LC_SPECIAL_BACKGROUND_2024_GLOBAL_GOFEST_SUN_ULTRA_WORMHOLE_001 = 25,
            LC_SPECIAL_BACKGROUND_2024_GLOBAL_GOFEST_MOON_ULTRA_WORMHOLE_001 = 26,
            LC_2024_INCHEON_SAFARI_ZONE_001 = 27,
            LC_2024_HONOLULU_WORLD_CHAMPIONSHIPS_001 = 28,
            LC_2024_MLB_001 = 29,
            LC_2024_MLB_002 = 30,
            LC_2024_MLB_003 = 31,
            LC_2024_MLB_004 = 32,
            LC_2024_MLB_005 = 33,
            LC_2024_MLB_006 = 34,
            LC_2024_MLB_007 = 35,
            LC_2024_MLB_008 = 36,
            LC_2024_MLB_009 = 37,
            LC_2024_MLB_010 = 38,
            LC_2024_MLB_011 = 39,
            LC_2024_MLB_012 = 40,
            LC_2024_MLB_013 = 41,
            LC_2024_MLB_014 = 42,
            LC_2024_MLB_015 = 43,
            LC_2024_MLB_016 = 44,
            LC_2024_MLB_017 = 45,
            LC_2024_MLB_018 = 46,
            LC_2024_MLB_019 = 47,
            LC_2024_MLB_020 = 48,
            LC_2024_MLB_021 = 49,
            LC_2024_MLB_022 = 50,
            LC_2024_MLB_023 = 51,
            LC_2024_MLB_024 = 52,
            LC_2024_MLB_025 = 53,
            LC_2024_MLB_026 = 54,
            LC_2024_MLB_027 = 55,
            LC_2024_MLB_028 = 56,
            LC_2024_MLB_029 = 57,
            LC_2024_MLB_030 = 58,
            LC_2024_FUKUOKA_GOWA_001 = 59,
            LC_SPECIALBACKGROUND_2024_GLOBAL_GOWA_001 = 60,
            LC_2024_HONGKONG_CITYSAFARI_001 = 61,
            LC_2024_SAOPAULO_CITYSAFARI_001 = 62,
            LC_2025_NEWTAIPEICITY_GOTOUR_001 = 63,
            LC_2025_LOSANGELES_GOTOUR_001 = 64,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOTOUR_WHITE_001 = 65,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOTOUR_BLACK_001 = 66,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOTOUR_BLACK_WHITE_001 = 67,
            LC_SPECIALBACKGROUND_2025_SEASON17 = 69,
            LC_SPECIALBACKGROUND_2024_DECEMBERCDRECAP = 70,
            LC_SPECIALBACKGROUND_2025_GLOBAL_ENIGMA_001 = 71,
            LC_2024_MILAN_CITYSAFARI_001 = 72,
            LC_2024_MUMBAI_CITYSAFARI_001 = 73,
            LC_2024_SANTIAGO_CITYSAFARI_001 = 74,
            LC_2024_SINGAPORE_CITYSAFARI_001 = 75,
            LC_SPECIALBACKGROUND_2025_S18 = 76,
            LC_2025_OSAKA_EVENT_001 = 77,
            LC_2025_OSAKA_GOFEST_001 = 78,
            LC_2025_JERSEYCITY_GOFEST_001 = 79,
            LC_2025_PARIS_GOFEST_001 = 80,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_REGI_001 = 81,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_REGI_002 = 82,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_REGI_003 = 83,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_REGI_004 = 84,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_REGI_005 = 85,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_REGI_006 = 86,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_SWORD_001 = 87,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_SHIELD_001 = 88,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_DD_001 = 89,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_SWORD_CROWNED_001 = 90,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_SHIELD_CROWNED_001 = 91,
            LC_SPECIALBACKGROUND_2025_GLOBAL_GOFEST_DD_CROWNED_001 = 92,
            LC_2025_OSAKA_EVENT_002 = 93,
            LC_2025_OSAKA_EVENT_003 = 94,
            LC_2025_OSAKA_EVENT_004 = 95,
            LC_2025_OSAKA_EVENT_005 = 96,
            LC_2025_OSAKA_EVENT_006 = 97,
            LC_2025_CHERRY_BLOSSOM_FESTIVAL = 98,
            LC_2025_OSAKA_EVENT_007 = 99
        }

        enum LoginActionTelemetryIds {
            LOGIN_ACTION_TELEMETRY_IDS_UNDEFINED_LOGIN_ACTION = 0,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_AGE_GATE = 1,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_NEW_PLAYER = 2,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_EXISTING_PLAYER = 3,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_GOOGLE = 4,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_GOOGLE = 5,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_GOOGLE = 6,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_FACEBOOK = 7,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_FACEBOOK = 8,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_FACEBOOK = 9,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_PTC = 10,
            LOGIN_ACTION_TELEMETRY_IDS_EXIT_PTC = 11,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_PTC_REGISTER = 12,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_PTC_SIGN_IN = 13,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_PTC_SIGN_IN = 14,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_PTC_SIGN_IN = 15,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_SUPERAWESOME = 16,
            LOGIN_ACTION_TELEMETRY_IDS_EXIT_SUPERAWESOME = 17,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_SUPERAWESOME_REGISTER = 18,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_SUPERAWESOME_FORGOT_PASSWORD = 19,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_SUPERAWESOME_SIGN_IN = 20,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_SUPERAWESOME_SIGN_IN = 21,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_SUPERAWESOME_SIGN_IN = 22,
            LOGIN_ACTION_TELEMETRY_IDS_EXIT_NEW_PLAYER = 23,
            LOGIN_ACTION_TELEMETRY_IDS_EXIT_EXISTING_PLAYER = 24,
            LOGIN_ACTION_TELEMETRY_IDS_LOGIN_STARTED = 25,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_APPLE = 26,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_APPLE = 27,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_APPLE = 28,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_GUEST = 29,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_GUEST = 30,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_GUEST = 31,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_PTC_OAUTH = 32,
            LOGIN_ACTION_TELEMETRY_IDS_EXIT_PTC_OAUTH = 33,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_PTC_OAUTH_REGISTER = 34,
            LOGIN_ACTION_TELEMETRY_IDS_CLICK_PTC_OAUTH_SIGN_IN = 35,
            LOGIN_ACTION_TELEMETRY_IDS_CANCEL_PTC_OAUTH_SIGN_IN = 36,
            LOGIN_ACTION_TELEMETRY_IDS_COMPLETE_PTC_OAUTH_SIGN_IN = 37
        }

        enum MapEventsTelemetryIds {
            MAP_EVENTS_TELEMETRY_IDS_UNDEFINED_MAP_EVENT = 0,
            MAP_EVENTS_TELEMETRY_IDS_ITEM_BAG = 1,
            MAP_EVENTS_TELEMETRY_IDS_MAIN_MENU = 2,
            MAP_EVENTS_TELEMETRY_IDS_POKEDEX = 3,
            MAP_EVENTS_TELEMETRY_IDS_PROFILE = 4,
            MAP_EVENTS_TELEMETRY_IDS_SETTINGS = 5,
            MAP_EVENTS_TELEMETRY_IDS_SHOP_FROM_MAP = 6,
            MAP_EVENTS_TELEMETRY_IDS_GYM = 7,
            MAP_EVENTS_TELEMETRY_IDS_POKESTOP = 8,
            MAP_EVENTS_TELEMETRY_IDS_RESEARCH = 9,
            MAP_EVENTS_TELEMETRY_IDS_COMPASS = 10,
            MAP_EVENTS_TELEMETRY_IDS_NEARBY = 11
        }

        enum MapNodeDataType {
            MAP_NODE_DATA_TYPE_ORB = 0,
            MAP_NODE_DATA_TYPE_LEARNED_FEATURES = 1
        }

        enum MementoType {
            MEMENTO_POSTCARD = 0
        }

        enum Method {
            METHOD_UNSET = 0,
            METHOD_GET_PLAYER = 2,
            METHOD_GET_HOLOHOLO_INVENTORY = 4,
            METHOD_DOWNLOAD_SETTINGS = 5,
            METHOD_DOWNLOAD_ITEM_TEMPLATES = 6,
            METHOD_DOWNLOAD_REMOTE_CONFIG_VERSION = 7,
            METHOD_REGISTER_BACKGROUND_DEVICE = 8,
            METHOD_GET_PLAYER_DAY = 9,
            METHOD_ACKNOWLEDGE_PUNISHMENT = 10,
            METHOD_GET_SERVER_TIME = 11,
            METHOD_GET_LOCAL_TIME = 12,
            METHOD_SET_PLAYER_STATUS = 20,
            METHOD_DOWNLOAD_GAME_CONFIG_VERSION = 21,
            METHOD_GET_GPS_BOOKMARKS = 22,
            METHOD_UPDATE_GPS_BOOKMARKS = 23,
            METHOD_FORT_SEARCH = 101,
            METHOD_ENCOUNTER = 102,
            METHOD_CATCH_POKEMON = 103,
            METHOD_FORT_DETAILS = 104,
            METHOD_GET_MAP_OBJECTS = 106,
            METHOD_FORT_DEPLOY_POKEMON = 110,
            METHOD_FORT_RECALL_POKEMON = 111,
            METHOD_RELEASE_POKEMON = 112,
            METHOD_USE_ITEM_POTION = 113,
            METHOD_USE_ITEM_CAPTURE = 114,
            METHOD_USE_ITEM_FLEE = 115,
            METHOD_USE_ITEM_REVIVE = 116,
            METHOD_GET_PLAYER_PROFILE = 121,
            METHOD_EVOLVE_POKEMON = 125,
            METHOD_GET_HATCHED_EGGS = 126,
            METHOD_ENCOUNTER_TUTORIAL_COMPLETE = 127,
            METHOD_LEVEL_UP_REWARDS = 128,
            METHOD_CHECK_AWARDED_BADGES = 129,
            METHOD_RECYCLE_INVENTORY_ITEM = 137,
            METHOD_COLLECT_DAILY_BONUS = 138,
            METHOD_USE_ITEM_XP_BOOST = 139,
            METHOD_USE_ITEM_EGG_INCUBATOR = 140,
            METHOD_USE_INCENSE = 141,
            METHOD_GET_INCENSE_POKEMON = 142,
            METHOD_INCENSE_ENCOUNTER = 143,
            METHOD_ADD_FORT_MODIFIER = 144,
            METHOD_DISK_ENCOUNTER = 145,
            METHOD_UPGRADE_POKEMON = 147,
            METHOD_SET_FAVORITE_POKEMON = 148,
            METHOD_NICKNAME_POKEMON = 149,
            METHOD_EQUIP_BADGE = 150,
            METHOD_SET_CONTACT_SETTINGS = 151,
            METHOD_SET_BUDDY_POKEMON = 152,
            METHOD_GET_BUDDY_WALKED = 153,
            METHOD_USE_ITEM_ENCOUNTER = 154,
            METHOD_GYM_DEPLOY = 155,
            METHOD_GYM_GET_INFO = 156,
            METHOD_GYM_START_SESSION = 157,
            METHOD_GYM_BATTLE_ATTACK = 158,
            METHOD_JOIN_LOBBY = 159,
            METHOD_LEAVE_LOBBY = 160,
            METHOD_SET_LOBBY_VISIBILITY = 161,
            METHOD_SET_LOBBY_POKEMON = 162,
            METHOD_GET_RAID_DETAILS = 163,
            METHOD_GYM_FEED_POKEMON = 164,
            METHOD_START_RAID_BATTLE = 165,
            METHOD_ATTACK_RAID = 166,
            METHOD_AWARD_POKECOIN = 167,
            METHOD_USE_ITEM_STARDUST_BOOST = 168,
            METHOD_REASSIGN_PLAYER = 169,
            METHOD_REDEEM_POI_PASSCODE = 170,
            METHOD_CONVERT_CANDY_TO_XL_CANDY = 171,
            METHOD_IS_SKU_AVAILABLE = 172,
            METHOD_USE_ITEM_BULK_HEAL = 173,
            METHOD_USE_ITEM_BATTLE_BOOST = 174,
            METHOD_USE_ITEM_LUCKY_FRIEND_APPLICATOR = 175,
            METHOD_USE_ITEM_STAT_INCREASE = 176,
            METHOD_GET_ASSET_DIGEST = 300,
            METHOD_GET_DOWNLOAD_URLS = 301,
            METHOD_GET_ASSET_VERSION = 302,
            METHOD_CLAIM_CODENAME = 403,
            METHOD_SET_AVATAR = 404,
            METHOD_SET_PLAYER_TEAM = 405,
            METHOD_MARK_TUTORIAL_COMPLETE = 406,
            METHOD_UPDATE_PERFORMANCE_METRICS = 407,
            METHOD_SET_NEUTRAL_AVATAR = 408,
            METHOD_LIST_AVATAR_STORE_ITEMS = 409,
            METHOD_LIST_AVATAR_APPEARANCE_ITEMS = 410,
            METHOD_NEUTRAL_AVATAR_BADGE_REWARD = 450,
            METHOD_CHECK_CHALLENGE = 600,
            METHOD_VERIFY_CHALLENGE = 601,
            METHOD_ECHO = 666,
            METHOD_SFIDA_REGISTRATION = 800,
            METHOD_SFIDA_ACTION_LOG = 801,
            METHOD_SFIDA_CERTIFICATION = 802,
            METHOD_SFIDA_UPDATE = 803,
            METHOD_SFIDA_ACTION = 804,
            METHOD_SFIDA_DOWSER = 805,
            METHOD_SFIDA_CAPTURE = 806,
            METHOD_LIST_AVATAR_CUSTOMIZATIONS = 807,
            METHOD_SET_AVATAR_ITEM_AS_VIEWED = 808,
            METHOD_GET_INBOX = 809,
            METHOD_LIST_GYM_BADGES = 811,
            METHOD_GET_GYM_BADGE_DETAILS = 812,
            METHOD_USE_ITEM_MOVE_REROLL = 813,
            METHOD_USE_ITEM_RARE_CANDY = 814,
            METHOD_AWARD_FREE_RAID_TICKET = 815,
            METHOD_FETCH_ALL_NEWS = 816,
            METHOD_MARK_READ_NEWS_ARTICLE = 817,
            METHOD_GET_PLAYER_DISPLAY_INFO = 818,
            METHOD_BELUGA_TRANSACTION_START = 819,
            METHOD_BELUGA_TRANSACTION_COMPLETE = 820,
            METHOD_SFIDA_ASSOCIATE = 822,
            METHOD_SFIDA_CHECK_PAIRING = 823,
            METHOD_SFIDA_DISASSOCIATE = 824,
            METHOD_WAINA_GET_REWARDS = 825,
            METHOD_WAINA_SUBMIT_SLEEP_DATA = 826,
            METHOD_SATURDAY_TRANSACTION_START = 827,
            METHOD_SATURDAY_TRANSACTION_COMPLETE = 828,
            METHOD_REIMBURSE_ITEM = 829,
            METHOD_LIFT_USER_AGE_CONFIRMATION = 830,
            METHOD_GET_NEW_QUESTS = 900,
            METHOD_GET_QUEST_DETAILS = 901,
            METHOD_COMPLETE_QUEST = 902,
            METHOD_REMOVE_QUEST = 903,
            METHOD_QUEST_ENCOUNTER = 904,
            METHOD_COMPLETE_QUEST_STAMP_CARD = 905,
            METHOD_PROGRESS_QUEST = 906,
            METHOD_START_QUEST_INCIDENT = 907,
            METHOD_READ_QUEST_DIALOG = 908,
            METHOD_SEND_GIFT = 950,
            METHOD_OPEN_GIFT = 951,
            METHOD_GIFT_DETAILS = 952,
            METHOD_DELETE_GIFT = 953,
            METHOD_SAVE_PLAYER_SNAPSHOT = 954,
            METHOD_GET_FRIENDSHIP_MILESTONE_REWARDS = 955,
            METHOD_CHECK_SEND_GIFT = 956,
            METHOD_SET_FRIEND_NICKNAME = 957,
            METHOD_DELETE_GIFT_FROM_INVENTORY = 958,
            METHOD_SAVE_SOCIAL_PLAYER_SETTINGS = 959,
            METHOD_OPEN_TRADING = 970,
            METHOD_UPDATE_TRADING = 971,
            METHOD_CONFIRM_TRADING = 972,
            METHOD_CANCEL_TRADING = 973,
            METHOD_GET_TRADING = 974,
            METHOD_GET_FITNESS_REWARDS = 980,
            METHOD_GET_COMBAT_PLAYER_PROFILE = 990,
            METHOD_GENERATE_COMBAT_CHALLENGE_ID = 991,
            METHOD_CREATE_COMBAT_CHALLENGE = 992,
            METHOD_OPEN_COMBAT_CHALLENGE = 993,
            METHOD_GET_COMBAT_CHALLENGE = 994,
            METHOD_ACCEPT_COMBAT_CHALLENGE = 995,
            METHOD_DECLINE_COMBAT_CHALLENGE = 996,
            METHOD_CANCEL_COMBAT_CHALLENGE = 997,
            METHOD_SUBMIT_COMBAT_CHALLENGE_POKEMONS = 998,
            METHOD_SAVE_COMBAT_PLAYER_PREFERENCES = 999,
            METHOD_OPEN_COMBAT_SESSION = 1000,
            METHOD_UPDATE_COMBAT = 1001,
            METHOD_QUIT_COMBAT = 1002,
            METHOD_GET_COMBAT_RESULTS = 1003,
            METHOD_UNLOCK_SPECIAL_MOVE = 1004,
            METHOD_GET_NPC_COMBAT_REWARDS = 1005,
            METHOD_COMBAT_FRIEND_REQUEST = 1006,
            METHOD_OPEN_NPC_COMBAT_SESSION = 1007,
            METHOD_START_TUTORIAL_ACTION = 1008,
            METHOD_GET_TUTORIAL_EGG_ACTION = 1009,
            METHOD_SEND_PROBE = 1020,
            METHOD_PROBE_DATA = 1021,
            METHOD_COMBAT_DATA = 1022,
            METHOD_COMBAT_CHALLENGE_DATA = 1023,
            METHOD_CHECK_PHOTOBOMB = 1101,
            METHOD_CONFIRM_PHOTOBOMB = 1102,
            METHOD_GET_PHOTOBOMB = 1103,
            METHOD_ENCOUNTER_PHOTOBOMB = 1104,
            METHOD_GET_SIGNED_GMAP_URL_DEPRECATED = 1105,
            METHOD_CHANGE_TEAM = 1106,
            METHOD_GET_WEB_TOKEN = 1107,
            METHOD_COMPLETE_SNAPSHOT_SESSION = 1110,
            METHOD_COMPLETE_WILD_SNAPSHOT_SESSION = 1111,
            METHOD_START_INCIDENT = 1200,
            METHOD_INVASION_COMPLETE_DIALOGUE = 1201,
            METHOD_INVASION_OPEN_COMBAT_SESSION = 1202,
            METHOD_INVASION_BATTLE_UPDATE = 1203,
            METHOD_INVASION_ENCOUNTER = 1204,
            METHOD_PURIFY_POKEMON = 1205,
            METHOD_GET_ROCKET_BALLOON = 1206,
            METHOD_START_ROCKET_BALLOON_INCIDENT = 1207,
            METHOD_VS_SEEKER_START_MATCHMAKING = 1300,
            METHOD_CANCEL_MATCHMAKING = 1301,
            METHOD_GET_MATCHMAKING_STATUS = 1302,
            METHOD_COMPLETE_VS_SEEKER_AND_RESTART_CHARGING = 1303,
            METHOD_GET_VS_SEEKER_STATUS = 1304,
            METHOD_COMPLETE_COMBAT_COMPETITIVE_SEASON_ACTION = 1305,
            METHOD_CLAIM_VS_SEEKER_REWARDS = 1306,
            METHOD_VS_SEEKER_REWARD_ENCOUNTER = 1307,
            METHOD_ACTIVATE_VS_SEEKER = 1308,
            METHOD_GET_BUDDY_MAP = 1350,
            METHOD_GET_BUDDY_STATS = 1351,
            METHOD_FEED_BUDDY = 1352,
            METHOD_OPEN_BUDDY_GIFT = 1353,
            METHOD_PET_BUDDY = 1354,
            METHOD_GET_BUDDY_HISTORY = 1355,
            METHOD_UPDATE_ROUTE_DRAFT = 1400,
            METHOD_GET_MAP_FORTS = 1401,
            METHOD_SUBMIT_ROUTE_DRAFT = 1402,
            METHOD_GET_PUBLISHED_ROUTES = 1403,
            METHOD_START_ROUTE = 1404,
            METHOD_GET_ROUTES = 1405,
            METHOD_PROGRESS_ROUTE = 1406,
            METHOD_PROCESS_TAPPABLE = 1408,
            METHOD_LIST_ROUTE_BADGES = 1409,
            METHOD_CANCEL_ROUTE = 1410,
            METHOD_LIST_ROUTE_STAMPS = 1411,
            METHOD_RATE_ROUTE = 1412,
            METHOD_CREATE_ROUTE_DRAFT = 1413,
            METHOD_DELETE_ROUTE_DRAFT = 1414,
            METHOD_REPORT_ROUTE = 1415,
            METHOD_SPAWN_TAPPABLE = 1416,
            METHOD_ROUTE_ENCOUNTER = 1417,
            METHOD_CAN_REPORT_ROUTE = 1418,
            METHOD_ROUTE_UPTATE_SEEN = 1420,
            METHOD_RECALL_ROUTE_DRAFT = 1421,
            METHOD_ROUTES_NEARBY_NOTIF_SHOWN = 1422,
            METHOD_NPC_ROUTE_GIFT = 1423,
            METHOD_GET_ROUTE_CREATIONS = 1424,
            METHOD_APPEAL_ROUTE = 1425,
            METHOD_GET_ROUTE_DRAFT = 1426,
            METHOD_FAVORITE_ROUTE = 1427,
            METHOD_CREATE_ROUTE_SHORTCODE = 1428,
            METHOD_GET_ROUTE_BY_SHORTCODE = 1429,
            METHOD_CREATE_BUDDY_MUTLIPLAYER_SESSION = 1456,
            METHOD_JOIN_BUDDY_MULTIPLAYER_SESSION = 1457,
            METHOD_LEAVE_BUDDY_MULTIPLAYER_SESSION = 1458,
            METHOD_MEGA_EVOLVE_POKEMON = 1502,
            METHOD_REMOTE_GIFT_PING = 1503,
            METHOD_SEND_RAID_INVITATION = 1504,
            METHOD_SEND_BREAD_BATTLE_INVITATION = 1505,
            METHOD_GET_DAILY_ENCOUNTER = 1601,
            METHOD_DAILY_ENCOUNTER = 1602,
            METHOD_OPEN_SPONSORED_GIFT = 1650,
            METHOD_SPONSORED_GIFT_REPORT_INTERACTION = 1651,
            METHOD_SAVE_PLAYER_PREFERENCES = 1652,
            METHOD_PROFANITY_CHECK = 1653,
            METHOD_GET_TIMED_GROUP_CHALLENGE = 1700,
            METHOD_GET_NINTENDO_ACCOUNT = 1710,
            METHOD_UNLINK_NINTENDO_ACCOUNT = 1711,
            METHOD_GET_NINTENDO_OAUTH2_URL = 1712,
            METHOD_TRANSFER_TO_POKEMON_HOME = 1713,
            METHOD_REPORT_AD_FEEDBACK = 1716,
            METHOD_CREATE_POKEMON_TAG = 1717,
            METHOD_DELETE_POKEMON_TAG = 1718,
            METHOD_EDIT_POKEMON_TAG = 1719,
            METHOD_SET_POKEMON_TAGS_FOR_POKEMON = 1720,
            METHOD_GET_POKEMON_TAGS = 1721,
            METHOD_CHANGE_POKEMON_FORM = 1722,
            METHOD_CHOOSE_EVENT_VARIANT = 1723,
            METHOD_BUTTERFLY_COLLECTOR_REWARD_ENCOUNTER = 1724,
            METHOD_GET_ADDITIONAL_POKEMON_DETAILS = 1725,
            METHOD_CREATE_ROUTE_PIN = 1726,
            METHOD_LIKE_ROUTE_PIN = 1727,
            METHOD_VIEW_ROUTE_PIN = 1728,
            METHOD_GET_REFERRAL_CODE = 1800,
            METHOD_ADD_REFERRER = 1801,
            METHOD_SEND_FRIEND_INVITE_VIA_REFERRAL_CODE = 1802,
            METHOD_GET_MILESTONES = 1803,
            METHOD_MARK_MILESTONES_AS_VIEWED = 1804,
            METHOD_GET_MILESTONES_PREVIEW = 1805,
            METHOD_COMPLETE_MILESTONE = 1806,
            METHOD_GET_GEOFENCED_AD = 1820,
            METHOD_POWER_UP_POKESTOP_ENCOUNTER = 1900,
            METHOD_GET_PLAYER_STAMP_COLLECTIONS = 1901,
            METHOD_SAVE_STAMP = 1902,
            METHOD_CLAIM_STAMP_COLLECTION_REWARD = 1904,
            METHOD_CHANGE_STAMP_COLLECTION_PLAYER_DATA = 1905,
            METHOD_CHECK_STAMP_GIFT_ABILITY = 1906,
            METHOD_DELETE_POSTCARDS = 1909,
            METHOD_CREATE_POSTCARD = 1910,
            METHOD_UPDATE_POSTCARD = 1911,
            METHOD_DELETE_POSTCARD = 1912,
            METHOD_GET_MEMENTO_LIST = 1913,
            METHOD_UPLOAD_RAID_CLIENT_LOG = 1914,
            METHOD_SKIP_ENTER_REFERRAL_CODE = 1915,
            METHOD_UPLOAD_COMBAT_CLIENT_LOG = 1916,
            METHOD_COMBAT_SYNC_SERVER_OFFSET = 1917,
            METHOD_CHECK_GIFTING_ELIGIBILITY = 2000,
            METHOD_REDEEM_TICKET_GIFT_FOR_FRIEND = 2001,
            METHOD_GET_INCENSE_RECAP = 2002,
            METHOD_ACKNOWLEDGE_INCENSE_RECAP = 2003,
            METHOD_BOOT_RAID = 2004,
            METHOD_GET_POKESTOP_ENCOUNTER = 2005,
            METHOD_ENCOUNTER_POKESTOP_ENCOUNTER = 2006,
            METHOD_POLL_PLAYER_SPAWNABLE_POKEMON = 2007,
            METHOD_GET_QUEST_UI = 2008,
            METHOD_GET_ELIGIBLE_COMBAT_LEAGUES = 2009,
            METHOD_SEND_FRIEND_REQUEST_VIA_PLAYER_IDS = 2010,
            METHOD_GET_RAID_LOBBY_COUNTER = 2011,
            METHOD_USE_NON_COMBAT_MOVE = 2014,
            METHOD_CHECK_POKEMON_SIZE_CONTEST_ELIGIBILITY = 2100,
            METHOD_UPDATE_POKEMON_SIZE_CONTEST_ENTRY = 2101,
            METHOD_TRANSFER_POKEMON_SIZE_CONTEST_ENTRY = 2102,
            METHOD_REMOVE_POKEMON_SIZE_CONTEST_ENTRY = 2103,
            METHOD_GET_POKEMON_SIZE_CONTEST_ENTRY = 2104,
            METHOD_GET_CONTEST_DATA = 2105,
            METHOD_GET_CONTESTS_UNCLAIMED_REWARDS = 2106,
            METHOD_CLAIM_CONTESTS_REWARDS = 2107,
            METHOD_GET_ENTERED_CONTEST = 2108,
            METHOD_GET_POKEMON_SIZE_CONTEST_FRIEND_ENTRY = 2109,
            METHOD_CHECK_CONTEST_ELIGIBILITY = 2150,
            METHOD_UPDATE_CONTEST_ENTRY = 2151,
            METHOD_TRANSFER_CONTEST_ENTRY = 2152,
            METHOD_GET_CONTEST_FRIEND_ENTRY = 2153,
            METHOD_GET_CONTEST_ENTRY = 2154,
            METHOD_CREATE_PARTY = 2300,
            METHOD_JOIN_PARTY = 2301,
            METHOD_START_PARTY = 2302,
            METHOD_LEAVE_PARTY = 2303,
            METHOD_GET_PARTY = 2304,
            METHOD_UPDATE_PARTY_LOCATION = 2305,
            METHOD_SEND_PARTY_DARK_LAUNCH_LOG = 2306,
            METHOD_START_PARTY_QUEST = 2308,
            METHOD_COMPLETE_PARTY_QUEST = 2309,
            METHOD_GET_BONUS_ATTRACTED_POKEMON = 2350,
            METHOD_GET_BONUSES = 2352,
            METHOD_BADGE_REWARD_ENCOUNTER = 2360,
            METHOD_NPC_UPDATE_STATE = 2400,
            METHOD_NPC_SEND_GIFT = 2401,
            METHOD_NPC_OPEN_GIFT = 2402,
            METHOD_JOIN_BREAD_LOBBY = 2450,
            METHOD_PREPARE_BREAD_LOBBY = 2453,
            METHOD_LEAVE_BREAD_LOBBY = 2455,
            METHOD_START_BREAD_BATTLE = 2456,
            METHOD_GET_BREAD_LOBBY_DETAILS = 2457,
            METHOD_START_MP_WALK_QUEST = 2458,
            METHOD_ENHANCE_BREAD_MOVE = 2459,
            METHOD_STATION_POKEMON = 2460,
            METHOD_LOOT_STATION = 2461,
            METHOD_GET_STATION_DETAILS = 2462,
            METHOD_MARK_SAVE_FOR_LATER = 2463,
            METHOD_USE_SAVE_FOR_LATER = 2464,
            METHOD_REMOVE_SAVE_FOR_LATER = 2465,
            METHOD_GET_SAVE_FOR_LATER_ENTRIES = 2466,
            METHOD_GET_MP_SUMMARY = 2467,
            METHOD_REPLENISH_MP = 2468,
            METHOD_REPORT_STATION = 2470,
            METHOD_DEBUG_RESET_DAILY_MP = 2471,
            METHOD_RELEASE_STATIONED_POKEMON = 2472,
            METHOD_COMPLETE_BREAD_BATTLE = 2473,
            METHOD_ENCOUNTER_STATION_SPAWN = 2475,
            METHOD_GET_NUM_STATION_ASSISTS = 2476,
            METHOD_PT_TWO = 2501,
            METHOD_PT_THREE = 2502,
            METHOD_GET_VPS_EVENTS = 3000,
            METHOD_UPDATE_VPS_EVENTS = 3001,
            METHOD_ADD_PTC_LOGIN_ACTION = 3002,
            METHOD_CLAIM_PTC_LINKING_REWARD = 3003,
            METHOD_CAN_CLAIM_PTC_REWARD_ACTION = 3004,
            METHOD_CONTRIBUTE_PARTY_ITEMS = 3005,
            METHOD_CONSUME_PARTY_ITEMS = 3006,
            METHOD_REMOVE_PTC_LOGIN = 3007,
            METHOD_SEND_PARTY_PLAY_INVITE = 3008,
            METHOD_CONSUME_STICKERS = 3009,
            METHOD_COMPLETE_RAID_BATTLE = 3010,
            METHOD_SYNC_BATTLE_INVENTORY = 3011,
            METHOD_PREVIEW_CONTRIBUTE_PARTY_ITEMS = 3015,
            METHOD_KICK_FROM_PARTY = 3016,
            METHOD_FUSE_POKEMON = 3017,
            METHOD_UNFUSE_POKEMON = 3018,
            METHOD_GET_IRIS_SOCIAL_SCENE = 3019,
            METHOD_UPDATE_IRIS_SOCIAL_SCENE = 3020,
            METHOD_GET_CHANGE_POKEMON_FORM_PREVIEW = 3021,
            METHOD_GET_FUSE_POKEMON_PREVIEW = 3022,
            METHOD_GET_UNFUSE_POKEMON_PREVIEW = 3023,
            METHOD_PROCESS_PLAYER_INBOX = 3024,
            METHOD_GET_SURVEY_ELIGIBILITY = 3025,
            METHOD_UPDATE_SURVEY_ELIGIBILITY = 3026,
            METHOD_SMART_GLASSES_SYNC_SETTINGS = 3027,
            METHOD_COMPLETE_VISIT_PAGE_QUEST = 3030,
            METHOD_GET_EVENT_RSVPS = 3031,
            METHOD_CREATE_EVENT_RSVP = 3032,
            METHOD_CANCEL_EVENT_RSVP = 3033,
            METHOD_CLAIM_EVENT_PASS_REWARDS = 3034,
            METHOD_CLAIM_ALL_EVENT_PASS_REWARDS = 3035,
            METHOD_GET_EVENT_RSVP_COUNT = 3036,
            METHOD_SEND_RSVP_INVITATION = 3039,
            METHOD_UPDATE_EVENT_RSVP_SELECTION = 3040,
            METHOD_GET_STATION_INFO = 3051,
            METHOD_AGE_CONFIRMATION = 3052,
            METHOD_CHANGE_STAT_INCREASE_GOAL = 3053
        }

        enum NMAMethod {
            NMA_METHOD_UNSET = 0,
            NMA_GET_PLAYER = 1,
            NMA_GET_SURVEYOR_PROJECTS = 2,
            NMA_GET_SERVER_CONFIG = 3,
            NMA_UPDATE_SURVEYOR_PROJECT = 4,
            NMA_UPDATE_USER_ONBOARDING = 5
        }

        enum NMAOnboardingCompletion {
            NMA_ONBOARDING_COMPLETION_NOT_SPECIFIED = 0,
            NMA_ONBOARDING_COMPLETION_TERMS_OF_SERVICE_COMFIRMATION = 1,
            NMA_ONBOARDING_COMPLETION_PRIVACY_POLICY_CONFIRMATION = 2
        }

        enum NMARole {
            MNA_UNDEFINED = 0,
            NMA_SURVEYOR = 1,
            NMA_DEVELOPER = 2,
            NMA_ADMIN = 3,
            NMA_USER = 4
        }

        enum NewsPageTelemetryIds {
            NEWS_PAGE_TELEMETRY_IDS_UNDEFINED_NEWS_EVENT = 0,
            NEWS_PAGE_TELEMETRY_IDS_NEWS_VIEWED = 1,
            NEWS_PAGE_TELEMETRY_IDS_NEWS_DISMISSED = 2,
            NEWS_PAGE_TELEMETRY_IDS_NEWS_LINK_CLICKED = 3,
            NEWS_PAGE_TELEMETRY_IDS_NEWS_UPDATED_APP = 4
        }

        enum NianticStatementOfReason {
            SOR_UNSET = 0,
            SOR_DANGEROUS_GOODS_AND_SERVICES = 1,
            SOR_GAMEPLAY_FAIRNESS = 2,
            SOR_CHILD_SAFETY = 3,
            SOR_VIOLENT_ACTORS = 4,
            SOR_SEXUAL_CONTENT = 5,
            SOR_GRAPHIC_VIOLENCE_AND_THREATS = 6,
            SOR_SELF_HARM_AND_SUICIDE = 7,
            SOR_BULLYING_AND_HARASSMENT = 8,
            SOR_HATEFUL_CONTENT = 9,
            SOR_PRIVATE_INFORMATION = 10,
            SOR_MISINFORMATION = 11,
            SOR_IMPERSONATION = 12,
            SOR_SPAM = 13
        }

        enum NominationType {
            REGULAR = 0,
            PROVISIONAL = 1
        }

        enum NonCombatMoveType {
            NON_COMBAT_MOVE_TYPE_UNSET = 0,
            FAST_ATTACK = 1,
            CHARGED_ATTACK = 2,
            CHARGED_ATTACK_2 = 3
        }

        enum NotificationCategory {
            NOTIFICATION_CATEGORY_UNSET = 0,
            NOTIFICATION_CATEGORY_GYM_REMOVAL = 1,
            NOTIFICATION_CATEGORY_POKEMON_HUNGRY = 2,
            NOTIFICATION_CATEGORY_POKEMON_WON = 3,
            NOTIFICATION_CATEGORY_GIFTBOX_INCOMING = 6,
            NOTIFICATION_CATEGORY_GIFTBOX_DELIVERED = 7,
            NOTIFICATION_CATEGORY_FRIENDSHIP_MILESTONE_REWARD = 8,
            NOTIFICATION_CATEGORY_GYM_BATTLE_FRIENDSHIP_INCREMENT = 9,
            NOTIFICATION_CATEGORY_BGMODE_EGG_HATCH = 11,
            NOTIFICATION_CATEGORY_BGMODE_BUDDY_CANDY = 12,
            NOTIFICATION_CATEGORY_BGMODE_WEEKLY_FITNESS_REPORT = 13,
            NOTIFICATION_CATEGORY_COMBAT_CHALLENGE_OPENED = 14,
            NOTIFICATION_CATEGORY_BGMODE_OFF_SESSION_DISTANCE = 15,
            NOTIFICATION_CATEGORY_BGMODE_POI_PROXIMITY = 16,
            NOTIFICATION_CATEGORY_LUCKY_FRIEND = 17,
            NOTIFICATION_CATEGORY_BGMODE_NAMED_BUDDY_CANDY = 18,
            NOTIFICATION_CATEGORY_APP_BADGE_ONLY = 19,
            NOTIFICATION_CATEGORY_COMBAT_VS_SEEKER_CHARGED = 20,
            NOTIFICATION_CATEGORY_COMBAT_COMPETITIVE_SEASON_END = 21,
            NOTIFICATION_CATEGORY_BUDDY_HUNGRY = 22,
            NOTIFICATION_CATEGORY_BUDDY_FOUND_GIFT = 24,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_LEVEL_MILESTONE = 25,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_WALKING = 26,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_CARE = 27,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_BATTLE = 28,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_PHOTO = 29,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_POI = 30,
            NOTIFICATION_CATEGORY_BGMODE_BUDDY_FOUND_GIFT = 31,
            NOTIFICATION_CATEGORY_BUDDY_ATTRACTIVE_POI = 32,
            NOTIFICATION_CATEGORY_BGMODE_BUDDY_ATTRACTIVE_POI = 33,
            NOTIFICATION_CATEGORY_ROUTE_SUBMISSION_ACCEPTED = 34,
            NOTIFICATION_CATEGORY_ROUTE_SUBMISSION_REJECTED = 35,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_ATTRACTIVE_POI = 36,
            NOTIFICATION_CATEGORY_POI_PASSCODE_REDEEMED = 37,
            NOTIFICATION_CATEGORY_NO_EGGS_INCUBATING = 38,
            NOTIFICATION_CATEGORY_RETENTION_UNOPENED_GIFTS = 39,
            NOTIFICATION_CATEGORY_RETENTION_STARPIECE = 40,
            NOTIFICATION_CATEGORY_RETENTION_INCENSE = 41,
            NOTIFICATION_CATEGORY_RETENTION_LUCKY_EGG = 42,
            NOTIFICATION_CATEGORY_RETENTION_ADVSYNC_REWARDS = 43,
            NOTIFICATION_CATEGORY_RETENTION_EGGS_NOT_INCUBATING = 44,
            NOTIFICATION_CATEGORY_RETENTION_POWER_WALK = 45,
            NOTIFICATION_CATEGORY_RETENTION_FUN_WITH_FRIENDS = 46,
            NOTIFICATION_CATEGORY_BUDDY_REMOTE_GIFT = 47,
            NOTIFICATION_CATEGORY_BGMODE_BUDDY_REMOTE_GIFT = 48,
            NOTIFICATION_CATEGORY_REMOTE_RAID_INVITATION = 49,
            NOTIFICATION_CATEGORY_ITEM_REWARDS = 50,
            NOTIFICATION_CATEGORY_TIMED_GROUP_CHALLENGE_STARTED = 51,
            NOTIFICATION_CATEGORY_TIMED_GROUP_CHALLENGE_GOAL_MET = 52,
            NOTIFICATION_CATEGORY_DEEP_LINKING = 53,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_VISIT_POWERED_UP_FORT = 54,
            NOTIFICATION_CATEGORY_POKEDEX_UNLOCKED_CATEGORY_LIST = 55,
            NOTIFICATION_CATEGORY_CONTACT_SIGNED_UP = 56,
            NOTIFICATION_CATEGORY_POSTCARD_SAVED_BY_FRIEND = 57,
            NOTIFICATION_CATEGORY_TICKET_GIFT_NOTIFIED = 58,
            NOTIFICATION_CATEGORY_TICKET_GIFT_RECEIVED = 59,
            NOTIFICATION_CATEGORY_DAILY_ADVENTURE_INCENSE_UNUSED = 60,
            NOTIFICATION_CATEGORY_CAMPFIRE_INVITE = 61,
            NOTIFICATION_CATEGORY_BGMODE_UNCAUGHT_DISTANCE = 62,
            NOTIFICATION_CATEGORY_BGMODE_OPEN_GYM_SPOT = 63,
            NOTIFICATION_CATEGORY_BGMODE_NO_EGGS_INCUBATING = 64,
            NOTIFICATION_CATEGORY_WEEKLY_REMINDER_KM = 65,
            NOTIFICATION_CATEGORY_EXTERNAL_REWARD = 66,
            NOTIFICATION_CATEGORY_SLEEP_REWARD = 67,
            NOTIFICATION_CATEGORY_PARTY_PLAY_INVITATION = 68,
            NOTIFICATION_CATEGORY_BUDDY_AFFECTION_ROUTE = 69,
            NOTIFICATION_CATEGORY_CAMPFIRE_RAID_READY = 70,
            NOTIFICATION_CATEGORY_TAPPABLE_ZYGARDE_CELL = 71,
            NOTIFICATION_CATEGORY_DAILY_CATCH_STREAK = 72,
            NOTIFICATION_CATEGORY_CAMPFIRE_EVENT_REMINDER = 73,
            NOTIFICATION_CATEGORY_POKEMON_RETURNED_FROM_IRIS_SOCIAL_SCENE = 74,
            NOTIFICATION_CATEGORY_DAILY_SPIN_STREAK = 75,
            NOTIFICATION_CATEGORY_CAMPFIRE_MEETUP = 76,
            NOTIFICATION_CATEGORY_POKEMON_RETURNED_FROM_STATION = 77,
            NOTIFICATION_CATEGORY_CAMPFIRE_CHECK_IN_REWARD = 78,
            NOTIFICATION_CATEGORY_PERSONALIZED_RESEARCH_AVAILABLE = 79,
            NOTIFICATION_CATEGORY_CLAIM_FREE_RAID_PASS = 80,
            NOTIFICATION_CATEGORY_BGMODE_TRACKED_POKEMON_PROXIMITY = 81,
            NOTIFICATION_CATEGORY_DAILY_CATCH_STREAK_KEEP_EARLY = 82,
            NOTIFICATION_CATEGORY_DAILY_CATCH_STREAK_KEEP_LATE = 83,
            NOTIFICATION_CATEGORY_DAILY_CATCH_STREAK_FINISH_EARLY = 84,
            NOTIFICATION_CATEGORY_DAILY_CATCH_STREAK_FINISH_LATE = 85,
            NOTIFICATION_CATEGORY_BATTLE_TGR_FROM_BALLOON = 86,
            NOTIFICATION_CATEGORY_EVOLVE_TO_UNLOCK_POKEDEX_ENTRY = 87,
            NOTIFICATION_CATEGORY_LURE_MODULE_PLACED_NEARBY = 88,
            NOTIFICATION_CATEGORY_EVENT_RSVP = 89,
            NOTIFICATION_CATEGORY_EVENT_RSVP_INVITATION = 90
        }

        enum NotificationState {
            NOTIFICATION_STATE_UNSET_STATE = 0,
            NOTIFICATION_STATE_VIEWED = 1
        }

        enum NotificationType {
            NOTIFICATION_TYPE_NO_NOTIFICATIONS = 0,
            NOTIFICATION_TYPE_POKEMON_NOTIFICATIONS = 1,
            NOTIFICATION_TYPE_POKESTOP_NOTIFICATIONS = 2,
            NOTIFICATION_TYPE_SYSTEM_NOTIFICATIONS = 4
        }

        enum NullValue {
            null_value = 0
        }

        enum OnboardingArStatus {
            ONBOARDING_AR_STATUS_UNSET = 0,
            ONBOARDING_AR_STATUS_OFF = 1,
            ONBOARDING_AR_STATUS_AR_STANDARD = 2,
            ONBOARDING_AR_STATUS_AR_PLUS = 3
        }

        enum OnboardingEventIds {
            ONBOARDING_EVENT_IDS_TOS_ACCEPTED = 0,
            ONBOARDING_EVENT_IDS_PRIVACY_ACCEPTED = 1,
            ONBOARDING_EVENT_IDS_CONVERSATION = 2,
            ONBOARDING_EVENT_IDS_ENCOUNTER_ENTER = 3,
            ONBOARDING_EVENT_IDS_ENCOUNTER_LEAVE = 4,
            ONBOARDING_EVENT_IDS_AVATAR_SELECTION = 5,
            ONBOARDING_EVENT_IDS_AVATAR_GENDER = 6,
            ONBOARDING_EVENT_IDS_AVATAR_GENDER_CHOSEN = 7,
            ONBOARDING_EVENT_IDS_AVATAR_HEAD_CHOSEN = 8,
            ONBOARDING_EVENT_IDS_AVATAR_BODY_CHOSEN = 9,
            ONBOARDING_EVENT_IDS_AVATAR_TRY_AGAIN = 10,
            ONBOARDING_EVENT_IDS_AVATAR_ACCEPTED = 11,
            ONBOARDING_EVENT_IDS_NAME_ENTRY = 12,
            ONBOARDING_EVENT_IDS_NAME_UNAVAILABLE = 13,
            ONBOARDING_EVENT_IDS_NAME_ACCEPTED = 14,
            ONBOARDING_EVENT_IDS_POKEDEX_TUTORIAL_STARTED = 15,
            ONBOARDING_EVENT_IDS_POKEDEX_TUTORIAL_INFO_PANEL_EXIT_PRESSED = 16,
            ONBOARDING_EVENT_IDS_POKEDEX_EXIT_PRESSED = 17,
            ONBOARDING_EVENT_IDS_EGG_TUTORIAL_STARTED = 18,
            ONBOARDING_EVENT_IDS_EGG_TUTORIAL_PRESS = 19,
            ONBOARDING_EVENT_IDS_EGG_TUTORIAL_FINISHED = 20,
            ONBOARDING_EVENT_IDS_POKESTOP_LETSGO = 21,
            ONBOARDING_EVENT_IDS_WILD_POKEMON_ENCOUNTER_ENTERED = 22,
            ONBOARDING_EVENT_IDS_WILD_POKEMON_CAUGHT = 23,
            ONBOARDING_EVENT_IDS_AR_STANDARD_ENABLED = 24,
            ONBOARDING_EVENT_IDS_AR_STANDARD_REJECTED = 25,
            ONBOARDING_EVENT_IDS_AR_PLUS_ENABLED = 26,
            ONBOARDING_EVENT_IDS_AR_PLUS_REJECTED = 27,
            ONBOARDING_EVENT_IDS_SEE_TOS_MODAL = 28,
            ONBOARDING_EVENT_IDS_TOS_DECLINED = 29,
            ONBOARDING_EVENT_IDS_SEE_PRIVACY_MODAL = 30,
            ONBOARDING_EVENT_IDS_INTRO_DIALOG_COMPLETE = 31,
            ONBOARDING_EVENT_IDS_CATCH_DIALOG_COMPLETE = 32,
            ONBOARDING_EVENT_IDS_USERNAME_DIALOG_COMPLETE = 33,
            ONBOARDING_EVENT_IDS_POKESTOP_DIALOG_COMPLETE = 34,
            ONBOARDING_EVENT_IDS_ACCEPTED_TOS = 35
        }

        enum OnboardingPathIds {
            ONBOARDING_PATH_IDS_V1 = 0,
            ONBOARDING_PATH_IDS_V2 = 1,
            ONBOARDING_PATH_IDS_VERSION_1 = 2
        }

        enum PageType {
            PAGE_UNSET = 0,
            APPRAISE = 1,
            OPEN_CAMPFIRE = 2,
            OPEN_NEARBY_RAID = 3,
            OPEN_PARTY_PLAY = 4,
            OPEN_ROUTES = 5
        }

        enum PartyQuestStatus {
            PARTY_QUEST_UNKNOWN = 0,
            PARTY_QUEST_WAITING_PARTY_TO_START = 1,
            PARTY_QUEST_SELECTING = 2,
            PARTY_QUEST_ACTIVE = 3,
            PARTY_QUEST_COMPLETED_AND_AWARDING = 4,
            PARTY_QUEST_NOT_AVAILABLE = 5,
            PARTY_QUEST_COMPLETED = 6
        }

        enum PartyStatus {
            PARTY_UNKNOWN = 0,
            PARTY_WAITING_TO_START = 1,
            PARTY_NORMAL = 2,
            PARTY_DISBANDED = 3
        }

        enum PartyType {
            PARTY_TYPE_UNSET = 0,
            PARTY_TYPE_PARTY_PLAY_PARTY = 1,
            PARTY_TYPE_WEEKLY_CHALLENGE_PARTY = 2
        }

        enum PathType {
            PATH_TYPE_UNSET = 0,
            PATH_TYPE_ACYCLIC = 1,
            PATH_TYPE_LOOP = 2
        }

        enum PermissionContextTelemetryIds {
            PERMISSION_CONTEXT_TELEMETRY_IDS_UNDEFINED_PERMISSION_CONTEXT = 0,
            PERMISSION_CONTEXT_TELEMETRY_IDS_EGG_HATCH = 1,
            PERMISSION_CONTEXT_TELEMETRY_IDS_BUDDY_CANDY_FOUND = 2,
            PERMISSION_CONTEXT_TELEMETRY_IDS_PLAYER_PROFILE_CLICKED = 3,
            PERMISSION_CONTEXT_TELEMETRY_IDS_SMART_WATCH_INSTALLED = 4,
            PERMISSION_CONTEXT_TELEMETRY_IDS_SFIDA_SESSION_STARTED = 5,
            PERMISSION_CONTEXT_TELEMETRY_IDS_SETTINGS_TOGGLE = 6,
            PERMISSION_CONTEXT_TELEMETRY_IDS_NEARBY_PANEL_OPENED = 7,
            PERMISSION_CONTEXT_TELEMETRY_IDS_FTUE_PROMPT = 8,
            PERMISSION_CONTEXT_TELEMETRY_IDS_LEVEL_UP_PROMPT = 9,
            PERMISSION_CONTEXT_TELEMETRY_IDS_ROUTE_CREATION = 10
        }

        enum PermissionFlowStepTelemetryIds {
            PERMISSION_FLOW_STEP_TELEMETRY_IDS_UNDEFINED_PERMISSION_FLOW_STEP = 0,
            PERMISSION_FLOW_STEP_TELEMETRY_IDS_INITIAL_PROMPT = 1,
            PERMISSION_FLOW_STEP_TELEMETRY_IDS_FITNESS_PERMISSION = 2,
            PERMISSION_FLOW_STEP_TELEMETRY_IDS_LOCATION_PERMISSION = 3,
            PERMISSION_FLOW_STEP_TELEMETRY_IDS_ACTIVITY_PERMISSIONS = 4
        }

        enum PermissionType {
            PERMISSION_TYPE_UNSET = 0,
            PERMISSION_TYPE_READ_CONTACTS = 1
        }

        enum PinCategory {
            PIN_CATEGORY_UNSET = 0,
            PIN_CATEGORY_1 = 1,
            PIN_CATEGORY_2 = 2,
            PIN_CATEGORY_3 = 3,
            PIN_CATEGORY_4 = 4,
            PIN_CATEGORY_5 = 5,
            PIN_CATEGORY_6 = 6,
            PIN_CATEGORY_7 = 7,
            PIN_CATEGORY_8 = 8,
            PIN_CATEGORY_9 = 9,
            PIN_CATEGORY_10 = 10
        }

        enum Platform {
            PLATFORM_UNSET = 0,
            PLATFORM_IOS = 1,
            PLATFORM_ANDROID = 2,
            PLATFORM_OSX = 3,
            PLATFORM_WINDOWS = 4,
            PLATFORM_APPLE_WATCH = 5
        }

        enum PlatformClientAction {
            PLATFORM_UNKNOWN_PLATFORM_CLIENT_ACTION = 0,
            PLATFORM_REGISTER_PUSH_NOTIFICATION = 5000,
            PLATFORM_UNREGISTER_PUSH_NOTIFICATION = 5001,
            PLATFORM_UPDATE_NOTIFICATION_STATUS = 5002,
            PLATFORM_OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 5003,
            PLATFORM_DOWNLOAD_GAME_MASTER_TEMPLATES = 5004,
            PLATFORM_GET_INVENTORY = 5005,
            PLATFORM_REDEEM_PASSCODE = 5006,
            PLATFORM_PING = 5007,
            PLATFORM_ADD_LOGIN_ACTION = 5008,
            PLATFORM_REMOVE_LOGIN_ACTION = 5009,
            PLATFORM_LIST_LOGIN_ACTION = 5010,
            PLATFORM_ADD_NEW_POI = 5011,
            PLATFORM_PROXY_SOCIAL_ACTION = 5012,
            PLATFORM_DEPRECATED_CLIENT_TELEMETRY = 5013,
            PLATFORM_GET_AVAILABLE_SUBMISSIONS = 5014,
            PLATFORM_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 5015,
            PLATFORM_REPLACE_LOGIN_ACTION = 5016,
            PLATFORM_PROXY_SOCIAL_SIDE_CHANNEL_ACTION = 5017,
            PLATFORM_COLLECT_CLIENT_TELEMETRY = 5018,
            PLATFORM_PURCHASE_SKU = 5019,
            PLATFORM_GET_AVAILABLE_SKUS_AND_BALANCES = 5020,
            PLATFORM_REDEEM_GOOGLE_RECEIPT = 5021,
            PLATFORM_REDEEM_APPLE_RECEIPT = 5022,
            PLATFORM_REDEEM_DESKTOP_RECEIPT = 5023,
            PLATFORM_UPDATE_FITNESS_METRICS = 5024,
            PLATFORM_GET_FITNESS_REPORT = 5025,
            PLATFORM_GET_CLIENT_TELEMETRY_SETTINGS = 5026,
            PLATFORM_PING_ASYNC = 5027,
            PLATFORM_REGISTER_BACKGROUND_SERVICE = 5028,
            PLATFORM_GET_CLIENT_BGMODE_SETTINGS = 5029,
            PLATFORM_PING_DOWNSTREAM = 5030,
            PLATFORM_SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 5032,
            PLATFORM_REQUEST_GEOFENCE_UPDATES = 5033,
            PLATFORM_UPDATE_PLAYER_LOCATION = 5034,
            PLATFORM_GENERATE_GMAP_SIGNED_URL = 5035,
            PLATFORM_GET_GMAP_SETTINGS = 5036,
            PLATFORM_REDEEM_SAMSUNG_RECEIPT = 5037,
            PLATFORM_ADD_NEW_ROUTE = 5038,
            PLATFORM_GET_OUTSTANDING_WARNINGS = 5039,
            PLATFORM_ACKNOWLEDGE_WARNINGS = 5040,
            PLATFORM_SUBMIT_POI_IMAGE = 5041,
            PLATFORM_SUBMIT_POI_TEXT_METADATA_UPDATE = 5042,
            PLATFORM_SUBMIT_POI_LOCATION_UPDATE = 5043,
            PLATFORM_SUBMIT_POI_TAKEDOWN_REQUEST = 5044,
            PLATFORM_GET_WEB_TOKEN_ACTION = 5045,
            PLATFORM_GET_ADVENTURE_SYNC_SETTINGS = 5046,
            PLATFORM_UPDATE_ADVENTURE_SYNC_SETTINGS = 5047,
            PLATFORM_SET_BIRTHDAY = 5048,
            PLATFORM_FETCH_NEWSFEED_ACTION = 5049,
            PLATFORM_MARK_NEWSFEED_READ_ACTION = 5050
        }

        enum PlatformWarningType {
            PLATFORM_WARNING_UNSET = 0,
            PLATFORM_WARNING_STRIKE1 = 1,
            PLATFORM_WARNING_STRIKE2 = 2,
            PLATFORM_WARNING_STRIKE3 = 3
        }

        enum PlayerAvatarType {
            PLAYER_AVATAR_MALE = 0,
            PLAYER_AVATAR_FEMALE = 1,
            PLAYER_AVATAR_NEUTRAL = 2
        }

        enum PlayerBonusType {
            PLAYER_BONUS_UNSET = 0,
            TIME_BONUS = 1,
            SPACE_BONUS = 2,
            DAY_BONUS = 3,
            NIGHT_BONUS = 4,
            FREEZE_BONUS = 5,
            SLOW_BONUS = 6,
            ATTACK_BONUS = 7,
            DEFENSE_BONUS = 8
        }

        enum PlayerSubmissionTypeProto {
            PLAYER_SUBMISSION_TYPE_PROTO_TYPE_UNSPECIFIED = 0,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_SUBMISSION = 1,
            PLAYER_SUBMISSION_TYPE_PROTO_ROUTE_SUBMISSION = 2,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_IMAGE_SUBMISSION = 3,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_TEXT_METADATA_UPDATE = 4,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_LOCATION_UPDATE = 5,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_TAKEDOWN_REQUEST = 6,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_AR_VIDEO_SUBMISSION = 7,
            PLAYER_SUBMISSION_TYPE_PROTO_SPONSOR_POI_REPORT = 8,
            PLAYER_SUBMISSION_TYPE_PROTO_SPONSOR_POI_LOCATION_UPDATE = 9,
            PLAYER_SUBMISSION_TYPE_PROTO_POI_CATEGORY_VOTE_SUBMISSION = 10,
            PLAYER_SUBMISSION_TYPE_PROTO_MAPPING_REQUEST = 11,
            PLAYER_SUBMISSION_TYPE_PROTO_NEW_PRIVATE_POI = 12
        }

        enum PlayerZoneCompliance {
            UNSET_ZONE = 0,
            SAFE_TO_JOIN_ZONE = 1,
            WARNING_TO_JOIN_ZONE = 2,
            SAFE_TO_PLAY_ZONE = 3,
            WARNING_TO_PLAY_ZONE = 4,
            NONCOMPLIANT_ZONE = 5,
            NONCOMPLIANT_2_ZONE = 6,
            MISSING_LOCATION_ZONE = 7
        }

        enum PoiImageType {
            POI_IMAGE_TYPE_UNSET = 0,
            POI_IMAGE_TYPE_MAIN = 1,
            POI_IMAGE_TYPE_SURROUNDING = 2
        }

        enum PoiInvalidReason {
            POI_INVALID_REASON_INVALID_REASON_UNSPECIFIED = 0,
            POI_INVALID_REASON_NO_PEDESTRIAN_ACCESS = 1,
            POI_INVALID_REASON_OBSTRUCTS_EMERGENCY_SERVICES = 2,
            POI_INVALID_REASON_PRIVATE_RESIDENTIAL_PROPERTY = 3,
            POI_INVALID_REASON_SCHOOL = 4,
            POI_INVALID_REASON_PERMANENTLY_REMOVED = 5,
            POI_INVALID_REASON_DUPLICATE = 6,
            POI_INVALID_REASON_NOT_SUITABLE_FOR_AR = 7,
            POI_INVALID_REASON_UNSAFE = 8,
            POI_INVALID_REASON_SENSITIVE = 9,
            POI_INVALID_REASON_LOCATION_DOES_NOT_EXIST = 10,
            POI_INVALID_REASON_ABUSE = 11
        }

        enum PokecoinSource {
            SOURCE_UNSET = 0,
            SOURCE_GYM_DEFENDER = 1,
            SOURCE_REFERRAL_BONUS = 2
        }

        enum PokedexCategory {
            POKEDEX_CATEGORY_UNSET = 0,
            POKEDEX_CATEGORY_ALL = 1,
            POKEDEX_CATEGORY_MEGA = 2,
            POKEDEX_CATEGORY_SHINY = 11,
            POKEDEX_CATEGORY_LUCKY = 12,
            POKEDEX_CATEGORY_THREE_STAR = 13,
            POKEDEX_CATEGORY_FOUR_STAR = 14,
            POKEDEX_CATEGORY_SHADOW = 15,
            POKEDEX_CATEGORY_PURIFIED = 16,
            POKEDEX_CATEGORY_COSTUME = 17,
            POKEDEX_CATEGORY_BREAD_MODE = 18,
            POKEDEX_CATEGORY_BREAD_DOUGH_MODE = 19,
            POKEDEX_CATEGORY_SHINY_THREE_STAR = 101,
            POKEDEX_CATEGORY_SHINY_FOUR_STAR = 102,
            POKEDEX_CATEGORY_SIZE_XXS = 201,
            POKEDEX_CATEGORY_SIZE_XXL = 202
        }

        enum PokedexGenerationId {
            GENERATION_UNSET = 0,
            GENERATION_GEN1 = 1,
            GENERATION_GEN2 = 2,
            GENERATION_GEN3 = 3,
            GENERATION_GEN4 = 4,
            GENERATION_GEN5 = 5,
            GENERATION_GEN6 = 6,
            GENERATION_GEN7 = 7,
            GENERATION_GEN8 = 8,
            GENERATION_GEN8A = 9,
            GENERATION_GEN9 = 10,
            GENERATION_MELTAN = 1002
        }

        enum PokemonBadge {
            POKEMON_BADGE_UNSET = 0,
            POKEMON_BADGE_BEST_BUDDY = 1
        }

        enum PokemonGoPlusIds {
            POKEMON_GO_PLUS_IDS_UNDEFINED_POKEMON_GO_PLUS_EVENT = 0,
            POKEMON_GO_PLUS_IDS_CANNOT_CONNECT_TO_PGP = 1,
            POKEMON_GO_PLUS_IDS_REGISTERING_PGP_FAILED = 2,
            POKEMON_GO_PLUS_IDS_REGISTERING_RETRY = 3,
            POKEMON_GO_PLUS_IDS_CONNECTION_SUCCESS = 4,
            POKEMON_GO_PLUS_IDS_PGP_DISCONNECTED_BY_USER = 5,
            POKEMON_GO_PLUS_IDS_PGP_DISCONNECTED_BY_TIMEOUT = 6,
            POKEMON_GO_PLUS_IDS_PGP_DISCONNECTED_BY_ERROR = 7,
            POKEMON_GO_PLUS_IDS_PGP_LOW_BATTERY = 8,
            POKEMON_GO_PLUS_IDS_BLUETOOTH_SENT_ERROR = 9,
            POKEMON_GO_PLUS_IDS_PGP_SEEN_BY_DEVICE = 10,
            POKEMON_GO_PLUS_IDS_POKEMON_CAUGHT = 11,
            POKEMON_GO_PLUS_IDS_POKEMON_NOT_CAUGHT = 12,
            POKEMON_GO_PLUS_IDS_POKEMON_NOT_CAUGHT_DUE_ERROR = 13,
            POKEMON_GO_PLUS_IDS_POKESTOP_SPUN = 14,
            POKEMON_GO_PLUS_IDS_POKESTOP_NOT_SPUN_DUE_ERROR = 15
        }

        enum PokemonHomeTelemetryIds {
            POKEMON_HOME_TELEMETRY_IDS_UNDEFINED_POKEMON_HOME_EVENT = 0,
            POKEMON_HOME_TELEMETRY_IDS_OPEN_SETTINGS = 1,
            POKEMON_HOME_TELEMETRY_IDS_SIGN_IN = 2,
            POKEMON_HOME_TELEMETRY_IDS_SELECTED_POKEMON = 3
        }

        enum PokemonIndividualStatType {
            POKEMON_INDIVIDUAL_STAT_TYPE_STAT_UNSET = 0,
            POKEMON_INDIVIDUAL_STAT_TYPE_ATTACK = 1,
            POKEMON_INDIVIDUAL_STAT_TYPE_DEFENSE = 2,
            POKEMON_INDIVIDUAL_STAT_TYPE_STAMINA = 3
        }

        enum PokemonInventoryTelemetryIds {
            POKEMON_INVENTORY_TELEMETRY_IDS_UNDEFINED_POKEMON_INVENTORY_EVENT = 0,
            POKEMON_INVENTORY_TELEMETRY_IDS_OPEN = 1,
            POKEMON_INVENTORY_TELEMETRY_IDS_SORTING_CHANGE = 2,
            POKEMON_INVENTORY_TELEMETRY_IDS_FILTER = 3
        }

        enum PokemonTagColor {
            POKEMON_TAG_COLOR_UNSET = 0,
            POKEMON_TAG_COLOR_BLUE = 1,
            POKEMON_TAG_COLOR_GREEN = 2,
            POKEMON_TAG_COLOR_PURPLE = 3,
            POKEMON_TAG_COLOR_YELLOW = 4,
            POKEMON_TAG_COLOR_RED = 5,
            POKEMON_TAG_COLOR_ORANGE = 6,
            POKEMON_TAG_COLOR_GREY = 7,
            POKEMON_TAG_COLOR_BLACK = 8
        }

        enum PostcardSource {
            POSTCARD_SOURCE_UNKNOWN = 0,
            POSTCARD_SOURCE_SELF = 1,
            POSTCARD_SOURCE_FRIEND = 2,
            POSTCARD_SOURCE_FRIEND_ANONYMIZED = 3,
            POSTCARD_SOURCE_FRIEND_ANONYMIZED_FROM_DELETION_OR_UNFRIEND = 4,
            POSTCARD_SOURCE_GIFT_TRADE = 5,
            POSTCARD_SOURCE_GIFT_TRADE_ANONYMIZED = 6,
            POSTCARD_SOURCE_GIFT_TRADE_ANONYMIZED_FROM_DELETION = 7
        }

        enum ProfilePageTelemetryIds {
            PROFILE_PAGE_TELEMETRY_IDS_UNDEFINED_PROFILE_PAGE = 0,
            PROFILE_PAGE_TELEMETRY_IDS_SHOP_FROM_PROFILE = 1,
            PROFILE_PAGE_TELEMETRY_IDS_LOG = 2,
            PROFILE_PAGE_TELEMETRY_IDS_SET_BUDDY = 3,
            PROFILE_PAGE_TELEMETRY_IDS_CUSTOMIZE_AVATAR = 4
        }

        enum PushGatewayTelemetryIds {
            PUSH_GATEWAY_TELEMETRY_IDS_UNDEFINED_PUSH_GATEWAY_EVENT = 0,
            PUSH_GATEWAY_TELEMETRY_IDS_WEB_SOCKET_STARTED = 1,
            PUSH_GATEWAY_TELEMETRY_IDS_WEB_SOCKET_FAILED = 2,
            PUSH_GATEWAY_TELEMETRY_IDS_WEB_SOCKET_TIMEOUT = 3,
            PUSH_GATEWAY_TELEMETRY_IDS_NEW_INBOX_DOWNSTREAM = 4
        }

        enum PushNotificationTelemetryIds {
            PUSH_NOTIFICATION_TELEMETRY_IDS_UNDEFINED_PUSH_NOTIFICATION_EVENT = 0,
            PUSH_NOTIFICATION_TELEMETRY_IDS_OPEN_APP = 1
        }

        enum QuestEncounterType {
            QUEST_ENCOUNTER_UNSET = 0,
            ULTRA_BEAST = 1
        }

        enum QuestType {
            QUEST_UNSET = 0,
            QUEST_FIRST_CATCH_OF_THE_DAY = 1,
            QUEST_FIRST_POKESTOP_OF_THE_DAY = 2,
            QUEST_MULTI_PART = 3,
            QUEST_CATCH_POKEMON = 4,
            QUEST_SPIN_POKESTOP = 5,
            QUEST_HATCH_EGG = 6,
            QUEST_COMPLETE_GYM_BATTLE = 7,
            QUEST_COMPLETE_RAID_BATTLE = 8,
            QUEST_COMPLETE_QUEST = 9,
            QUEST_TRANSFER_POKEMON = 10,
            QUEST_FAVORITE_POKEMON = 11,
            QUEST_AUTOCOMPLETE = 12,
            QUEST_USE_BERRY_IN_ENCOUNTER = 13,
            QUEST_UPGRADE_POKEMON = 14,
            QUEST_EVOLVE_POKEMON = 15,
            QUEST_LAND_THROW = 16,
            QUEST_GET_BUDDY_CANDY = 17,
            QUEST_BADGE_RANK = 18,
            QUEST_PLAYER_LEVEL = 19,
            QUEST_JOIN_RAID = 20,
            QUEST_COMPLETE_BATTLE = 21,
            QUEST_ADD_FRIEND = 22,
            QUEST_TRADE_POKEMON = 23,
            QUEST_SEND_GIFT = 24,
            QUEST_EVOLVE_INTO_POKEMON = 25,
            QUEST_COMPLETE_COMBAT = 27,
            QUEST_TAKE_SNAPSHOT = 28,
            QUEST_BATTLE_TEAM_ROCKET = 29,
            QUEST_PURIFY_POKEMON = 30,
            QUEST_FIND_TEAM_ROCKET = 31,
            QUEST_FIRST_GRUNT_OF_THE_DAY = 32,
            QUEST_BUDDY_FEED = 33,
            QUEST_BUDDY_EARN_AFFECTION_POINTS = 34,
            QUEST_BUDDY_PET = 35,
            QUEST_BUDDY_LEVEL = 36,
            QUEST_BUDDY_WALK = 37,
            QUEST_BUDDY_YATTA = 38,
            QUEST_USE_INCENSE = 39,
            QUEST_BUDDY_FIND_SOUVENIR = 40,
            QUEST_COLLECT_AS_REWARDS = 41,
            QUEST_WALK = 42,
            QUEST_MEGA_EVOLVE_POKEMON = 43,
            QUEST_GET_STARDUST = 44,
            QUEST_MINI_COLLECTION = 45,
            QUEST_GEOTARGETED_AR_SCAN = 46,
            QUEST_BUDDY_EVOLUTION_WALK = 50,
            QUEST_GBL_RANK = 51,
            QUEST_CHARGE_ATTACK = 53,
            QUEST_CHANGE_POKEMON_FORM = 54,
            QUEST_BATTLE_EVENT_NPC = 55,
            QUEST_EARN_FORT_POWER_UP_POINTS = 56,
            QUEST_TAKE_WILD_SNAPSHOT = 57,
            QUEST_USE_POKEMON_ITEM = 58,
            QUEST_OPEN_GIFT = 59,
            QUEST_EARN_XP = 60,
            QUEST_BATTLE_PLAYER_TEAM_LEADER = 61,
            QUEST_FIRST_ROUTE_OF_THE_DAY = 62,
            QUEST_SUBMIT_SLEEP_DATA = 63,
            QUEST_ROUTE_TRAVEL = 64,
            QUEST_ROUTE_COMPLETE = 65,
            QUEST_COLLECT_TAPPABLE = 66,
            QUEST_ACTIVATE_TRAINER_ABILITY = 67,
            QUEST_NPC_SEND_GIFT = 68,
            QUEST_NPC_OPEN_GIFT = 69,
            QUEST_PTC_OAUTH_LINK = 70,
            QUEST_FIGHT_POKEMON = 71,
            QUEST_USE_NON_COMBAT_MOVE = 72,
            QUEST_FUSE_POKEMON = 73,
            QUEST_UNFUSE_POKEMON = 74,
            QUEST_WALK_METERS = 75,
            QUEST_CHANGE_INTO_POKEMON_FORM = 76,
            QUEST_FUSE_INTO_POKEMON = 77,
            QUEST_UNFUSE_INTO_POKEMON = 78,
            QUEST_COLLECT_MP = 82,
            QUEST_LOOT_STATION = 83,
            QUEST_COMPLETE_BREAD_BATTLE = 84,
            QUEST_USE_BREAD_MOVE = 85,
            QUEST_UNLOCK_BREAD_MOVE = 86,
            QUEST_ENHANCE_BREAD_MOVE = 87,
            QUEST_COLLECT_STAMP = 88,
            QUEST_COMPLETE_BREAD_DOUGH_BATTLE = 89,
            QUEST_VISIT_PAGE = 90,
            QUEST_USE_INCUBATOR = 91,
            QUEST_CHOOSE_BUDDY = 92,
            QUEST_USE_LURE_MODULE = 93,
            QUEST_USE_LUCKY_EGG = 94,
            QUEST_PIN_POSTCARD = 95,
            QUEST_FEED_GYM_POKEMON = 96,
            QUEST_USE_STAR_PIECE = 97,
            QUEST_POKEMON_REACH_CP = 98
        }

        enum RaidInteractionSource {
            RAID_INTERACTION_SOURCE_DEFAULT_SOURCE = 0,
            RAID_INTERACTION_SOURCE_FRIEND_INVITE_IN_GAME_NOTIFICATION = 1,
            RAID_INTERACTION_SOURCE_FRIEND_INVITE_PUSH_NOTIFICATION = 2,
            RAID_INTERACTION_SOURCE_FRIEND_INVITE_NEARBY = 3,
            RAID_INTERACTION_SOURCE_FRIEND_LIST = 4,
            RAID_INTERACTION_SOURCE_NEARBY_RAID = 5,
            RAID_INTERACTION_SOURCE_NEARBY_UPCOMING_RSVP_RAID = 6,
            RAID_INTERACTION_SOURCE_RSVP_IN_GAME_NOTIFICATION = 7,
            RAID_INTERACTION_SOURCE_RSVP_PUSH_NOTIFICATION = 8,
            RAID_INTERACTION_SOURCE_PARTY_HUD = 9
        }

        enum RaidLevel {
            RAID_LEVEL_UNSET = 0,
            RAID_LEVEL_1 = 1,
            RAID_LEVEL_2 = 2,
            RAID_LEVEL_3 = 3,
            RAID_LEVEL_4 = 4,
            RAID_LEVEL_5 = 5,
            RAID_LEVEL_MEGA = 6,
            RAID_LEVEL_MEGA_5 = 7,
            RAID_LEVEL_ULTRA_BEAST = 8,
            RAID_LEVEL_EXTENDED_EGG = 9,
            RAID_LEVEL_PRIMAL = 10,
            RAID_LEVEL_1_SHADOW = 11,
            RAID_LEVEL_2_SHADOW = 12,
            RAID_LEVEL_3_SHADOW = 13,
            RAID_LEVEL_4_SHADOW = 14,
            RAID_LEVEL_5_SHADOW = 15
        }

        enum RaidLocationRequirement {
            RAID_LOCATION_REQUERIMENT_BOTH = 0,
            RAID_LOCATION_REQUERIMENT_IN_PERSON = 1,
            RAID_LOCATION_REQUERIMENT_REMOTE = 2
        }

        enum RaidPlaquePipStyle {
            RAID_PLAQUE_STYLE_UNSET = 0,
            RAID_PLAQUE_STYLE_TRIANGLE = 1,
            RAID_PLAQUE_STYLE_DIAMOND = 2,
            RAID_PLAQUE_STYLE_STAR = 3
        }

        enum RaidTelemetryIds {
            RAID_TELEMETRY_IDS_UNDEFINED_RAID_EVENT = 0,
            RAID_TELEMETRY_IDS_APPROACH_ENTER = 1,
            RAID_TELEMETRY_IDS_APPROACH_CLICK_SPINNER = 2,
            RAID_TELEMETRY_IDS_APPROACH_JOIN = 3,
            RAID_TELEMETRY_IDS_APPROACH_TICKET_CONFIRMATION = 4,
            RAID_TELEMETRY_IDS_APPROACH_CLICK_TUTORIAL = 5,
            RAID_TELEMETRY_IDS_APPROACH_CLICK_SHOP = 6,
            RAID_TELEMETRY_IDS_APPROACH_CLICK_INSPECT = 7,
            RAID_TELEMETRY_IDS_LOBBY_ENTER = 8,
            RAID_TELEMETRY_IDS_LOBBY_CLICK_INVENTORY = 9,
            RAID_TELEMETRY_IDS_LOBBY_CLICK_EXIT = 10,
            RAID_TELEMETRY_IDS_LOBBY_TAP_AVATAR = 11,
            RAID_TELEMETRY_IDS_LOBBY_CLICK_REJOIN_BATTLE = 12,
            RAID_TELEMETRY_IDS_LOBBY_CLICK_LOBBY_PUBLIC = 13,
            RAID_TELEMETRY_IDS_MVT_CLICK_SHARE = 14
        }

        enum RaidVisualType {
            RAID_VISUAL_TYPE_UNSET = 0,
            RAID_VISUAL_TYPE_NORMAL = 1,
            RAID_VISUAL_TYPE_EXCLUSIVE = 2,
            RAID_VISUAL_TYPE_MEGA = 3,
            RAID_VISUAL_TYPE_LEGENDARY_MEGA = 4,
            RAID_VISUAL_TYPE_EXTENDED = 5,
            RAID_VISUAL_TYPE_PRIMAL = 6,
            RAID_VISUAL_TYPE_SHADOW = 7
        }

        enum ReferralRole {
            REFERRAL_ROLE_UNDEFINED = 0,
            REFERRAL_ROLE_REFERRER = 1,
            REFERRAL_ROLE_NEW_REFEREE = 2,
            REFERRAL_ROLE_LAPSED_REFEREE = 3
        }

        enum ReferralSource {
            REFERRAL_SOURCE_UNDEFINED_SOURCE = 0,
            REFERRAL_SOURCE_INVITE_PAGE = 1,
            REFERRAL_SOURCE_ADDRESS_BOOK = 2,
            REFERRAL_SOURCE_IMAGE_SHARE = 3
        }

        enum ReferralTelemetryIds {
            REFERRAL_TELEMETRY_IDS_UNDEFINED_REFERRAL_EVENT = 0,
            REFERRAL_TELEMETRY_IDS_OPEN_INVITE_PAGE = 1,
            REFERRAL_TELEMETRY_IDS_TAP_SHARE_CODE = 2,
            REFERRAL_TELEMETRY_IDS_TAP_COPY_CODE = 3,
            REFERRAL_TELEMETRY_IDS_TAP_HAVE_REFERRAL_CODE = 4,
            REFERRAL_TELEMETRY_IDS_INPUT_CODE = 5,
            REFERRAL_TELEMETRY_IDS_INPUT_CODE_SUCCESS = 6,
            REFERRAL_TELEMETRY_IDS_MILESTONE_REWARD_CLAIMED = 7,
            REFERRAL_TELEMETRY_IDS_OPEN_APP_THROUGH_DEEP_LINK = 8
        }

        enum RemoteRaidInviteAcceptSource {
            REMOTE_RAID_INVITE_ACCEPT_SOURCE_UNDEFINED_REMOTE_RAID_INVITE_ACCEPT_SOURCE = 0,
            REMOTE_RAID_INVITE_ACCEPT_SOURCE_REMOTE_RAID_IN_APP = 1,
            REMOTE_RAID_INVITE_ACCEPT_SOURCE_REMOTE_RAID_PUSH_NOTIFICATION = 2,
            REMOTE_RAID_INVITE_ACCEPT_SOURCE_REMOTE_RAID_NEARBY_WINDOW = 3
        }

        enum RemoteRaidJoinSource {
            REMOTE_RAID_JOIN_SOURCE_UNDEFINED_REMOTE_RAID_JOIN_SOURCE = 0,
            REMOTE_RAID_JOIN_SOURCE_REMOTE_RAID_USED_MAP = 1,
            REMOTE_RAID_JOIN_SOURCE_REMOTE_RAID_NEARBY_GUI = 2,
            REMOTE_RAID_JOIN_SOURCE_REMOTE_RAID_INVITED_BY_FRIEND = 3,
            REMOTE_RAID_JOIN_SOURCE_REMOTE_RAID_RSVP_NOTIFICATION = 4
        }

        enum RemoteRaidTelemetryIds {
            REMOTE_RAID_TELEMETRY_IDS_UNDEFINED_REMOTE_RAID_EVENT = 0,
            REMOTE_RAID_TELEMETRY_IDS_REMOTE_RAID_LOBBY_ENTER = 1,
            REMOTE_RAID_TELEMETRY_IDS_REMOTE_RAID_INVITE_SENT = 2,
            REMOTE_RAID_TELEMETRY_IDS_REMOTE_RAID_INVITE_ACCEPTED = 3,
            REMOTE_RAID_TELEMETRY_IDS_REMOTE_RAID_INVITE_REJECTED = 4
        }

        enum RouteDiscoveryTelemetryIds {
            ROUTE_DISCOVERY_TELEMETRY_IDS_ROUTE_DISCOVERY_OPEN = 0,
            ROUTE_DISCOVERY_TELEMETRY_IDS_ROUTE_DISCOVERY_ABANDON = 1,
            ROUTE_DISCOVERY_TELEMETRY_IDS_ROUTE_DISCOVERY_ROUTE_SELECTED = 2,
            ROUTE_DISCOVERY_TELEMETRY_IDS_ROUTE_DISCOVERY_PAGE_SCROLL = 3
        }

        enum RouteErrorTelemetryIds {
            ROUTE_ERROR_TELEMETRY_IDS_ROUTE_ERROR_DEFAULT = 0
        }

        enum RouteInclineType {
            ROUTE_INCLINE_TYPE_UNSET = 0,
            ROUTE_INCLINE_TYPE_FLAT = 1,
            ROUTE_INCLINE_TYPE_MOSTLY_FLAT = 2,
            ROUTE_INCLINE_TYPE_SLIGHTLY_HILLY = 3,
            ROUTE_INCLINE_TYPE_VERY_HILLY = 4,
            ROUTE_INCLINE_TYPE_STEEP_INCLINE = 5,
            ROUTE_INCLINE_TYPE_STEEP_DECLINE = 6,
            ROUTE_INCLINE_DYNAMIC_STEEP = 50
        }

        enum RouteType {
            ROUTE_TYPE_UNSET = 0,
            ROUTE_TYPE_ORGANIC = 1,
            ROUTE_TYPE_OFFICIAL = 2,
            ROUTE_TYPE_EVENT = 3,
            ROUTE_TYPE_SPONSORED = 4
        }

        enum RpcNotificationCategory {
            UNSET_NOTIFICATION_CATEGORY = 0,
            GYM_REMOVAL = 1,
            POKEMON_HUNGRY = 2,
            POKEMON_WON = 3,
            GIFTBOX_INCOMING = 6,
            GIFTBOX_DELIVERED = 7,
            FRIENDSHIP_MILESTONE_REWARD = 8,
            GYM_BATTLE_FRIENDSHIP_INCREMENT = 9,
            BGMODE_EGG_HATCH = 11,
            BGMODE_BUDDY_CANDY = 12,
            BGMODE_WEEKLY_FITNESS_REPORT = 13,
            COMBAT_CHALLENGE_OPENED = 14,
            BGMODE_OFF_SESSION_DISTANCE = 15,
            BGMODE_POI_PROXIMITY = 16,
            LUCKY_FRIEND = 17,
            BGMODE_NAMED_BUDDY_CANDY = 18,
            APP_BADGE_ONLY = 19,
            COMBAT_VS_SEEKER_CHARGED = 20,
            COMBAT_COMPETITIVE_SEASON_END = 21,
            BUDDY_HUNGRY = 22,
            BUDDY_FOUND_GIFT = 24,
            BUDDY_AFFECTION_LEVEL_MILESTONE = 25,
            BUDDY_AFFECTION_WALKING = 26,
            BUDDY_AFFECTION_CARE = 27,
            BUDDY_AFFECTION_BATTLE = 28,
            BUDDY_AFFECTION_PHOTO = 29,
            BUDDY_AFFECTION_POI = 30,
            BGMODE_BUDDY_FOUND_GIFT = 31,
            BUDDY_ATTRACTIVE_POI = 32,
            BGMODE_BUDDY_ATTRACTIVE_POI = 33,
            ROUTE_SUBMISSION_ACCEPTED = 34,
            ROUTE_SUBMISSION_REJECTED = 35,
            BUDDY_AFFECTION_ATTRACTIVE_POI = 36,
            POI_PASSCODE_REDEEMED = 37,
            NO_EGGS_INCUBATING = 38,
            RETENTION_UNOPENED_GIFTS = 39,
            RETENTION_STARPIECE = 40,
            RETENTION_INCENSE = 41,
            RETENTION_LUCKY_EGG = 42,
            RETENTION_ADVSYNC_REWARDS = 43,
            RETENTION_EGGS_NOT_INCUBATING = 44,
            RETENTION_POWER_WALK = 45,
            RETENTION_FUN_WITH_FRIENDS = 46,
            BUDDY_REMOTE_GIFT = 47,
            BGMODE_BUDDY_REMOTE_GIFT = 48,
            REMOTE_RAID_INVITATION = 49,
            ITEM_REWARDS = 50,
            TIMED_GROUP_CHALLENGE_STARTED = 51,
            TIMED_GROUP_CHALLENGE_GOAL_MET = 52,
            DEEP_LINKING = 53,
            BUDDY_AFFECTION_VISIT_POWERED_UP_FORT = 54,
            POKEDEX_UNLOCKED_CATEGORY_LIST = 55,
            CONTACT_SIGNED_UP = 56,
            POSTCARD_SAVED_BY_FRIEND = 57,
            TICKET_GIFT_NOTIFIED = 58,
            TICKET_GIFT_RECEIVED = 59,
            DAILY_ADVENTURE_INCENSE_UNUSED = 60,
            CAMPFIRE_INVITE = 61,
            BGMODE_UNCAUGHT_DISTANCE = 62,
            BGMODE_OPEN_GYM_SPOT = 63,
            BGMODE_NO_EGGS_INCUBATING = 64,
            WEEKLY_REMINDER_KM = 65,
            EXTERNAL_REWARD = 66,
            SLEEP_REWARD = 67,
            PARTY_PLAY_INVITATION = 68,
            BUDDY_AFFECTION_ROUTE = 69,
            CAMPFIRE_RAID_READY = 70,
            TAPPABLE_ZYGARDE_CELL = 71,
            DAILY_CATCH_STREAK = 72,
            CAMPFIRE_EVENT_REMINDER = 73,
            POKEMON_RETURNED_FROM_IRIS_SOCIAL_SCENE = 74,
            DAILY_SPIN_STREAK = 75,
            CAMPFIRE_MEETUP = 76,
            POKEMON_RETURNED_FROM_STATION = 77,
            CAMPFIRE_CHECK_IN_REWARD = 78,
            PERSONALIZED_RESEARCH_AVAILABLE = 79,
            CLAIM_FREE_RAID_PASS = 80,
            BGMODE_TRACKED_POKEMON_PROXIMITY = 81,
            DAILY_CATCH_STREAK_KEEP_EARLY = 82,
            DAILY_CATCH_STREAK_KEEP_LATE = 83,
            DAILY_CATCH_STREAK_FINISH_EARLY = 84,
            DAILY_CATCH_STREAK_FINISH_LATE = 85,
            BATTLE_TGR_FROM_BALLOON = 86,
            EVOLVE_TO_UNLOCK_POKEDEX_ENTRY = 87,
            LURE_MODULE_PLACED_NEARBY = 88,
            EVENT_RSVP = 89,
            EVENT_RSVP_INVITATION = 90
        }

        enum RsvpSelection {
            UNSET_SELECTION = 0,
            GOING = 1,
            MAYBE = 2,
            DECLINED = 3
        }

        enum SaturdayCompositionData {
            DATA_0 = 0,
            DATA_1 = 1,
            DATA_2 = 2,
            DATA_3 = 3,
            DATA_4 = 4,
            DATA_5 = 5,
            DATA_6 = 6,
            DATA_7 = 7,
            DATA_8 = 8,
            DATA_9 = 9,
            DATA_10 = 10,
            DATA_11 = 11,
            DATA_12 = 12,
            DATA_13 = 13,
            DATA_14 = 14,
            DATA_15 = 15,
            DATA_16 = 16,
            DATA_17 = 17,
            DATA_18 = 18,
            DATA_19 = 19,
            DATA_20 = 20,
            DATA_21 = 21,
            DATA_22 = 22,
            DATA_23 = 23,
            DATA_24 = 24,
            DATA_25 = 25,
            DATA_26 = 26,
            DATA_27 = 27,
            DATA_28 = 28,
            DATA_29 = 29,
            DATA_30 = 30,
            DATA_31 = 31,
            DATA_32 = 32,
            DATA_33 = 33,
            DATA_34 = 34,
            DATA_35 = 35,
            DATA_36 = 36,
            DATA_37 = 37,
            DATA_38 = 38,
            DATA_39 = 39,
            DATA_40 = 40,
            DATA_41 = 41,
            DATA_42 = 42,
            DATA_43 = 43,
            DATA_44 = 44,
            DATA_45 = 45,
            DATA_46 = 46,
            DATA_47 = 47,
            DATA_48 = 48,
            DATA_49 = 49,
            DATA_50 = 50,
            DATA_51 = 51,
            DATA_52 = 52,
            DATA_53 = 53,
            DATA_54 = 54,
            DATA_55 = 55,
            DATA_56 = 56,
            DATA_57 = 57,
            DATA_58 = 58,
            DATA_59 = 59,
            DATA_60 = 60,
            DATA_61 = 61,
            DATA_62 = 62,
            DATA_63 = 63
        }

        enum ScanTag {
            DEFAULT_SCAN = 0,
            PUBLIC = 1,
            PRIVATE = 2,
            WAYSPOT_CENTRIC = 3,
            FREE_FORM = 4,
            EXPERIMENTAL = 5
        }

        enum ShoppingPageScrollIds {
            SHOPPING_PAGE_SCROLL_IDS_UNDEFINED_SHOPPING_PAGE_SCROLL_TYPE = 0,
            SHOPPING_PAGE_SCROLL_IDS_LAST_SCROLL = 1,
            SHOPPING_PAGE_SCROLL_IDS_MAX_SCROLL = 2
        }

        enum ShoppingPageTelemetryIds {
            SHOPPING_PAGE_TELEMETRY_IDS_UNDEFINED_SHOPPING_PAGE_EVENT = 0,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_CUSTOMIZE_AVATAR = 1,
            SHOPPING_PAGE_TELEMETRY_IDS_QUICK_SHOP_MORE = 2,
            SHOPPING_PAGE_TELEMETRY_IDS_QUICK_SHOP_EXCHANGE = 3,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_SHOP = 4,
            SHOPPING_PAGE_TELEMETRY_IDS_QUIT_SHOP = 5,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_SKU = 6,
            SHOPPING_PAGE_TELEMETRY_IDS_QUIT_SKU = 7,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_SKU_EXCHANGE = 8,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_SHOP_AVATAR = 9,
            SHOPPING_PAGE_TELEMETRY_IDS_QUIT_SHOP_AVATAR = 10,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_AVATAR_TYPE = 11,
            SHOPPING_PAGE_TELEMETRY_IDS_QUIT_AVATAR_TYPE = 12,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_AVATAR_ITEM = 13,
            SHOPPING_PAGE_TELEMETRY_IDS_QUIT_AVATAR_ITEM = 14,
            SHOPPING_PAGE_TELEMETRY_IDS_CONFIRM_AVATAR_ITEM = 15,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_AVATAR_ITEM_COLOR = 16,
            SHOPPING_PAGE_TELEMETRY_IDS_QUIT_AVATAR_ITEM_COLOR = 17,
            SHOPPING_PAGE_TELEMETRY_IDS_CONFIRM_AVATAR_ITEM_COLOR = 18,
            SHOPPING_PAGE_TELEMETRY_IDS_CLICK_IAP_STORE_BANNER = 19
        }

        enum ShoppingPageTelemetrySource {
            SHOPPING_PAGE_TELEMETRY_SOURCE_UNDEFINED_SHOPPING_PAGE_SOURCE = 0,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_MAIN_MENU = 1,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_POKEMON_BAG_FULL = 2,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_INCUBATOR_SELECTOR = 3,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_POKESTOP_DISK_INTERACTION = 4,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_OPEN_GIFT_BAG_FULL = 5,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_FULL_ENCOUNTER = 6,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_FULL_RAID = 7,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_MORE = 8,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_AVATAR_ITEM = 9,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_POKEMON_ENCOUNTER = 10,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_PLAYER_PROFILE_PAGE = 11,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_STORE_FRONT = 12,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_AVATAR_CUSTOMIZATION_AWARD = 13,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_FIRST_TIME_USER_FLOW = 14,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_BADGE_DETAIL_AVATAR_REWARD = 15,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_DEEP_LINK = 16,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_MISSING_RAID_PASS = 17,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_MISSING_REMOTE_RAID_PASS = 18,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BUDDY_INTERACTION_POFFIN = 100,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BUDDY_QUICK_FEED_POFFIN = 101,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_MISSING_INCENSE_ORDINARY = 102,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_MISSING_LUCKY_EGG = 103,
            SHOPPING_PAGE_TELEMETRY_SOURCE_SOURCE_QUICK_SHOP_BAG_MISSING_STAR_PIECE = 104
        }

        enum SocialTelemetryIds {
            SOCIAL_TELEMETRY_IDS_UNDEFINED_SOCIAL = 0,
            SOCIAL_TELEMETRY_IDS_FRIEND_TAB = 1,
            SOCIAL_TELEMETRY_IDS_NOTIFICATION_TAB = 2,
            SOCIAL_TELEMETRY_IDS_FRIEND_PROFILE = 3,
            SOCIAL_TELEMETRY_IDS_OPEN_FRIEND_SHIP_LEVEL_DETAIL = 4,
            SOCIAL_TELEMETRY_IDS_CLOSE_OPEN_GIFT_CONFIRMATION = 5,
            SOCIAL_TELEMETRY_IDS_FRIEND_LIST_SORT_CHANGED = 6,
            SOCIAL_TELEMETRY_IDS_FRIEND_LIST_CLOSED = 7
        }

        enum Source {
            SOURCE_DEFAULT_UNSET = 0,
            SOURCE_MODERATION = 1,
            SOURCE_ANTICHEAT = 2,
            SOURCE_RATE_LIMITED = 3,
            SOURCE_WAYFARER = 4
        }

        enum SouvenirTypeId {
            SOUVENIR_UNSET = 0,
            SOUVENIR_LONE_EARRING = 1,
            SOUVENIR_SMALL_BOUQUET = 2,
            SOUVENIR_SKIPPING_STONE = 3,
            SOUVENIR_BEACH_GLASS = 4,
            SOUVENIR_TROPICAL_SHELL = 5,
            SOUVENIR_MUSHROOM = 6,
            SOUVENIR_CHALKY_STONE = 7,
            SOUVENIR_PINECONE = 8,
            SOUVENIR_TROPICAL_FLOWER = 9,
            SOUVENIR_FLOWER_FRUITS = 10,
            SOUVENIR_CACTUS_FLOWER = 11,
            SOUVENIR_STRETCHY_SPRING = 12,
            SOUVENIR_MARBLE = 13,
            SOUVENIR_TORN_TICKET = 14,
            SOUVENIR_PRETTY_LEAF = 15,
            SOUVENIR_CONFETTI = 16,
            SOUVENIR_PIKACHU_VISOR = 17,
            SOUVENIR_PAPER_AIRPLANE = 18,
            SOUVENIR_TINY_COMPASS = 19
        }

        enum SponsorPoiInvalidReason {
            SPONSOR_POI_INVALID_REASON_SPONSOR_POI_REASON_UNSPECIFIED = 0,
            SPONSOR_POI_INVALID_REASON_SPONSOR_POI_REASON_DOES_NOT_EXIST = 1,
            SPONSOR_POI_INVALID_REASON_SPONSOR_POI_REASON_NOT_SAFE = 2,
            SPONSOR_POI_INVALID_REASON_SPONSOR_POI_REASON_NOT_TRUTHFUL = 3,
            SPONSOR_POI_INVALID_REASON_SPONSOR_POI_REASON_NOT_FAMILY_FRIENDLY = 4,
            SPONSOR_POI_INVALID_REASON_SPONSOR_POI_REASON_OFFENSIVE_CONTENT = 5
        }

        enum StampCollectionType {
            COLLECT_TYPE_UNSET = 0,
            COLLECTION_TYPE_LID = 1,
            COLLECTION_TYPE_DESIGNATED = 3,
            COLLECTION_TYPE_FREE = 4
        }

        enum StatModifierType {
            UNSET_STAT_MODIFIER_TYPE = 0,
            ATTACK_STAGE = 1,
            DEFENSE_STAGE = 2,
            DAMAGE_DEALT_DELTA = 3,
            DAMAGE_TAKEN_DELTA = 4,
            ARBITRARY_COUNTER = 5,
            PARTY_POWER_DAMAGE_DEALT = 6
        }

        enum Store {
            STORE_UNSET = 0,
            STORE_APPLE = 1,
            STORE_GOOGLE = 2,
            STORE_SAMSUNG = 3
        }

        enum Syntax {
            proto2 = 0,
            proto3 = 1,
            editions = 2
        }

        enum Team {
            TEAM_UNSET = 0,
            TEAM_BLUE = 1,
            TEAM_RED = 2,
            TEAM_YELLOW = 3
        }

        enum TitanGeodataType {
            UNSPECIFIED_GEODATA_TYPE = 0,
            POI = 1
        }

        enum TitanPlayerSubmissionAction {
            TITAN_PLAYER_SUBMISSION_ACTION_UNKNOWN_GAME_POI_ACTION = 0,
            TITAN_PLAYER_SUBMISSION_ACTION_ADD_NEW_POI = 620000,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_AVAILABLE_SUBMISSIONS = 620001,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 620002,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_PLAYER_SUBMISSION_VALIDATION_SETTINGS = 620003,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_ADD_NEW_POI = 620004,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 620005,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_NEW_PRIVATE_POI = 620006,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_NEW_PRIVATE_POI = 620007,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_IMAGE = 620100,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_TEXT_METADATA_UPDATE = 620101,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_LOCATION_UPDATE = 620102,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_TAKEDOWN_REQUEST = 620103,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_SPONSOR_POI_REPORT = 620104,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_SPONSOR_POI_LOCATION_UPDATE = 620105,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_CATEGORY_VOTE = 620106,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_IMAGE = 620107,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_TEXT_METADATA_UPDATE = 620108,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_LOCATION_UPDATE = 620109,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_TAKEDOWN_REQUEST = 620110,
            TITAN_PLAYER_SUBMISSION_ACTION_ADD_NEW_ROUTE = 620200,
            TITAN_PLAYER_SUBMISSION_ACTION_GENERATE_GMAP_SIGNED_URL = 620300,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_GMAP_SETTINGS = 620301,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_AR_VIDEO_METADATA = 620400,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_GRAPESHOT_FILE_UPLOAD_URL = 620401,
            TITAN_PLAYER_SUBMISSION_ACTION_ASYNC_FILE_UPLOAD_COMPLETE = 620402,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_AR_MAPPING_SETTINGS = 620403,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_AR_VIDEO_METADATA = 620404,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_GET_GRAPESHOT_FILE_UPLOAD_URL = 620405,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_ASYNC_FILE_UPLOAD_COMPLETE = 620406,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_MAPPING_REQUEST = 620407,
            TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_MAPPING_REQUEST = 620408,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_IMAGES_FOR_POI = 620500,
            TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_PLAYER_IMAGE_VOTE_FOR_POI = 620501,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_IMAGE_GALLERY_SETTINGS = 620502,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_MAP_DATA = 620600,
            TITAN_PLAYER_SUBMISSION_ACTION_GET_POIS_IN_RADIUS = 620601
        }

        enum TitanPoiImageType {
            TITAN_POI_IMAGE_TYPE_UNSET = 0,
            TITAN_POI_IMAGE_TYPE_MAIN = 1,
            TITAN_POI_IMAGE_TYPE_SURROUNDING = 2
        }

        enum TrainerAbility {
            UNSET_TRAINER_ABILITY = 0,
            ABILITY_PARTY_POWER_DAMAGE_DEALT = 1
        }

        enum TutorialCompletion {
            LEGAL_SCREEN = 0,
            AVATAR_SELECTION = 1,
            ACCOUNT_CREATION = 2,
            POKEMON_CAPTURE = 3,
            NAME_SELECTION = 4,
            POKEMON_BERRY = 5,
            USE_ITEM = 6,
            FIRST_TIME_EXPERIENCE_COMPLETE = 7,
            POKESTOP_TUTORIAL = 8,
            GYM_TUTORIAL = 9,
            CHALLENGE_QUEST_TUTORIAL = 10,
            PRIVACY_POLICY_CONFIRMATION = 11,
            TRADING_TUTORIAL = 12,
            POI_SUBMISSION_TUTORIAL = 13,
            V1_START_TUTORIAL = 14,
            V2_START_TUTORIAL = 15,
            V2_CUSTOMIZED_AVATAR = 16,
            V2_CAUGHT_FIRST_WILD = 17,
            V2_FINISHED_TUTORIAL_CATCHES = 18,
            V2_NAME_SELECTION = 19,
            V2_EGG_GIVEN = 20,
            V2_START_EGG_TUTORIAL = 21,
            V2_COMPLETED_EGG_TUTORIAL = 22,
            AR_PHOTO_TUTORIAL = 23,
            STARTER_POKEMON_CAPTURED = 24,
            AR_PHOTO_FIRST_TIME_DIALOG = 25,
            AR_CLASSIC_PHOTO_TUTORIAL = 26,
            AR_PLUS_PHOTO_TUTORIAL = 27,
            INVASION_INTRODUCTION_DIALOG = 29,
            INVASION_ENCOUNTER_DIALOG = 30,
            INVASION_SHADOW_POKEMON_DIALOG = 31,
            ROUTES_CREATION = 32,
            INVASION_MAP_FRAGMENT_DIALOG = 33,
            INVASION_MAP_RECEIVED_DIALOG = 34,
            INVASION_MAP_2_RECEIVED_DIALOG = 35,
            BUDDY_WELCOME_PROMPT = 36,
            BUDDY_AR_PLUS_TUTORIAL = 37,
            BUDDY_FEED_TUTORIAL = 38,
            BUDDY_ON_MAP_PROMPT = 39,
            BATTLE_LEAGUE_HELP_TUTORIAL = 40,
            ARMP_TOS_CONFIRMATION = 41,
            BUDDY_REMOTE_GIFT_TUTORIAL = 42,
            XL_CANDY_TUTORIAL = 43,
            LEVEL_UP_PAGE_TUTORIAL = 44,
            DAILY_BONUS_ENCOUNTER_TUTORIAL = 45,
            SPONSORED_GIFT_TUTORIAL = 46,
            XGS_ONLINE_CONSENT_NOTE = 47,
            APP_TRACKING_OPTIN_REQUIRED_TUTORIAL = 48,
            APP_TRACKING_OPTIN_DIALOG = 49,
            ADDRESS_BOOK_IMPORT_PROMPT = 50,
            POKEMON_TAGS_INTRODUCTION = 51,
            GYM_TUTORIAL_BUTTON_PROMPT_SHOWN = 52,
            RAID_TUTORIAL_BUTTON_PROMPT_SHOWN = 53,
            POTION_AND_REVIVE_TUTORIAL_INTRODUCED = 54,
            POTION_AND_REVIVE_TUTORIAL_VIEWED = 55,
            POSTCARD_COLLECTION_TUTORIAL_VIEWED = 56,
            SHOULD_SHOW_POTION_AND_REVIVE_TUTORIAL = 57,
            RECEIVED_GIFT = 58,
            FRIEND_TUTORIAL_BUTTON_PROMPT_SHOWN = 59,
            SHOULD_SHOW_GIFT_TUTORIAL = 60,
            GIFT_TUTORIAL_INTRODUCED = 61,
            GIFT_TUTORIAL_COMPLETE = 62,
            CHALLENGE_CATCH_RAZZBERRY = 63,
            SHOULD_SHOW_LURE_TUTORIAL = 64,
            LURE_TUTORIAL_INTRODUCED = 65,
            LURE_BUTTON_PROMPT_SHOWN = 66,
            LURE_BUTTON_DIALOG_SHOWN = 67,
            REMOTE_RAID_TUTORIAL = 68,
            TRADE_TUTORIAL_INTRODUCED = 69,
            TRADE_TUTORIAL_COMPLETE = 70,
            LUCKY_FRIEND_TUTORIAL = 71,
            LUCKY_TRADE_TUTORIAL = 72,
            MEGA_LEVELS_TUTORIAL = 73,
            SPONSORED_WEB_AR_TUTORIAL = 74,
            BUTTERFLY_REGION_TUTORIAL = 75,
            SPONSORED_VIDEO_TUTORIAL = 76,
            ADDRESS_BOOK_IMPORT_PROMPT_V2 = 77,
            LOCATION_CARD_TUTORIAL = 78,
            MASTER_BALL_INTRODUCTION_PROMPT = 79,
            SHADOW_GEM_FRAGMENT_DIALOG = 80,
            SHADOW_GEM_RECEIVED_DIALOG = 81,
            RAID_TUTORIAL_SHADOW_BUTTON_PROMPT_SHOWN = 82,
            CONTESTS_TUTORIAL = 83,
            ROUTE_TRAVEL = 84,
            PARTY_PLAY_TUTORIAL = 85,
            PINECONE_TUTORIAL_0 = 86,
            PINECONE_TUTORIAL_1 = 87,
            PINECONE_TUTORIAL_2 = 88,
            PINECONE_TUTORIAL_3 = 89,
            PINECONE_TUTORIAL_4 = 90,
            PINECONE_TUTORIAL_5 = 91,
            BREAKFAST_TAPPABLE_TUTORIAL = 92,
            RAID_TUTORIAL_PARTY_PLAY_PROMPT_SHOWN = 93,
            NPC_EXPLORER_INTRODUCED = 94,
            NPC_TRAVELER_INTRODUCED = 95,
            NONCOMBAT_MOVE_PROMPT_SHOWN = 96,
            NONCOMBAT_SPACIAL_REND_PROMPT_SHOWN = 97,
            NONCOMBAT_ROAR_OF_TIME_PROMPT_SHOWN = 98,
            NONCOMBAT_SUNSTEEL_STRIKE_PROMPT_SHOWN = 99,
            NONCOMBAT_MOONGEIST_BEAM_PROMPT_SHOWN = 100,
            NONCOMBAT_MOVE_PROMPT_SHOWN_03 = 101,
            NONCOMBAT_MOVE_PROMPT_SHOWN_04 = 102,
            NONCOMBAT_MOVE_PROMPT_SHOWN_05 = 103,
            NONCOMBAT_MOVE_PROMPT_SHOWN_06 = 104,
            NONCOMBAT_MOVE_PROMPT_SHOWN_07 = 105,
            NONCOMBAT_MOVE_PROMPT_SHOWN_08 = 106,
            NONCOMBAT_MOVE_PROMPT_SHOWN_09 = 107,
            NONCOMBAT_MOVE_PROMPT_SHOWN_10 = 108,
            AR_PHOTOS_STICKERS_TUTORIAL = 109,
            FUSION_CALYREX_TUTORIAL = 110,
            FUSION_KYUREM_TUTORIAL = 111,
            FUSION_NECROZMA_TUTORIAL = 112,
            AR_IRIS_SOCIAL_TUTORIAL = 113,
            STATION_TUTORIAL_1 = 114,
            STATION_TUTORIAL_2 = 115,
            STATION_TUTORIAL_3 = 116,
            STATION_TUTORIAL_4 = 117,
            STATION_TUTORIAL_5 = 118,
            STATION_TUTORIAL_6 = 119,
            STATION_TUTORIAL_7 = 120,
            SPECIAL_BACKGROUND_TUTORIAL = 121,
            SPECIAL_BACKGROUND_FUSION_TUTORIAL = 122,
            BREAD_POKEMON_INFO_TUTORIAL = 123,
            BREAD_MOVE_INFO_TUTORIAL = 124,
            WILD_BALL_TUTORIAL = 125,
            IBFC_DETAILS_MORPEKO_TUTORIAL = 126,
            STRONG_ENCOUNTER_WILD_BALL_TUTORIAL = 127,
            WILD_BALL_DRAWER_PROMPT = 128,
            VPS_LOCALIZATION_TUTORIAL = 129,
            RAID_ATTENDANCE_ONLINE_DISCLAIMER = 130,
            RAID_ATTENDANCE_ONBOARDING = 131,
            SINISTEA_FORM_TUTORIAL = 132,
            MAX_BOOST_ITEM_TUTORIAL = 133,
            EVENT_PASS_TUTORIAL = 134,
            STAMP_RALLY_TUTORIAL = 135,
            LUCKY_FRIEND_APPLICATOR_TUTORIAL = 136,
            RSVP_TOAST_TUTORIAL = 137,
            RSVP_TUTORIAL = 138,
            NEARBY_GYM_TUTORIAL = 139,
            NEARBY_ROUTES_TUTORIAL = 140,
            STAMP_RALLY_GIFT_SEND_TUTORIAL = 141,
            STAMP_RALLY_GIFT_RECEIVE_TUTORIAL = 142,
            MAPLE_TUTORIAL = 143,
            RSVP_TOAST_TUTORIAL_MAP = 144,
            RSVP_TOAST_TUTORIAL_NEARBY = 145,
            REMOTE_MAX_BATTLE_TUTORIAL = 146,
            RSVP_ATTENDANCE_DETAILS_TUTORIAL = 147,
            IBFC_DETAILS_LIGHTWEIGHT_TUTORIAL = 148
        }

        enum TweenAction {
            TWEEN_ACTION_MOVE_X = 0,
            TWEEN_ACTION_MOVE_Y = 1,
            TWEEN_ACTION_MOVE_Z = 2,
            TWEEN_ACTION_MOVE_LOCAL_X = 3,
            TWEEN_ACTION_MOVE_LOCAL_Y = 4,
            TWEEN_ACTION_MOVE_LOCAL_Z = 5,
            TWEEN_ACTION_MOVE_CURVED = 6,
            TWEEN_ACTION_MOVE_CURVED_LOCAL = 7,
            TWEEN_ACTION_MOVE_SPLINE = 8,
            TWEEN_ACTION_MOVE_SPLINE_LOCAL = 9,
            TWEEN_ACTION_SCALE_X = 10,
            TWEEN_ACTION_SCALE_Y = 11,
            TWEEN_ACTION_SCALE_Z = 12,
            TWEEN_ACTION_ROTATE_X = 13,
            TWEEN_ACTION_ROTATE_Y = 14,
            TWEEN_ACTION_ROTATE_Z = 15,
            TWEEN_ACTION_ROTATE_AROUND = 16,
            TWEEN_ACTION_ROTATE_AROUND_LOCAL = 17,
            TWEEN_ACTION_CANVAS_ROTATEAROUND = 18,
            TWEEN_ACTION_CANVAS_ROTATEAROUND_LOCAL = 19,
            TWEEN_ACTION_CANVAS_PLAYSPRITE = 20,
            TWEEN_ACTION_ALPHA = 21,
            TWEEN_ACTION_TEXT_ALPHA = 22,
            TWEEN_ACTION_CANVAS_ALPHA = 23,
            TWEEN_ACTION_ALPHA_VERTEX = 24,
            TWEEN_ACTION_COLOR = 25,
            TWEEN_ACTION_CALLBACK_COLOR = 26,
            TWEEN_ACTION_TEXT_COLOR = 27,
            TWEEN_ACTION_CANVAS_COLOR = 28,
            TWEEN_ACTION_CALLBACK = 29,
            TWEEN_ACTION_MOVE = 30,
            TWEEN_ACTION_MOVE_LOCAL = 31,
            TWEEN_ACTION_ROTATE = 32,
            TWEEN_ACTION_ROTATE_LOCAL = 33,
            TWEEN_ACTION_SCALE = 34,
            TWEEN_ACTION_VALUE3 = 35,
            TWEEN_ACTION_GUI_MOVE = 36,
            TWEEN_ACTION_GUI_MOVE_MARGIN = 37,
            TWEEN_ACTION_GUI_SCALE = 38,
            TWEEN_ACTION_GUI_ALPHA = 39,
            TWEEN_ACTION_GUI_ROTATE = 40,
            TWEEN_ACTION_DELAYED_SOUND = 41,
            TWEEN_ACTION_CANVAS_MOVE = 42,
            TWEEN_ACTION_CANVAS_SCALE = 43
        }

        enum UserType {
            USER_TYPE_PLAYER = 0,
            USER_TYPE_DEVELOPER = 1,
            USER_TYPE_SURVEYOR = 2,
            USER_TYPE_DEVELOPER_8TH_WALL = 3
        }

        enum UsernameSuggestionTelemetryId {
            UNDEFINED_USERNAME_SUGGESTION_EVENT = 0,
            REFRESHED_NAME_SUGGESTIONS = 1,
            TAPPED_SUGGESTED_NAME = 2,
            USED_SUGGESTED_NAME = 3
        }

        enum VivillonRegion {
            VIVILLON_REGION_UNKNOWN = 0,
            VIVILLON_REGION_ARCHIPELAGO = 1,
            VIVILLON_REGION_CONTINENTAL = 2,
            VIVILLON_REGION_ELEGANT = 3,
            VIVILLON_REGION_FANCY = 4,
            VIVILLON_REGION_GARDEN = 5,
            VIVILLON_REGION_HIGH_PLAINS = 6,
            VIVILLON_REGION_ICY_SNOW = 7,
            VIVILLON_REGION_JUNGLE = 8,
            VIVILLON_REGION_MARINE = 9,
            VIVILLON_REGION_MEADOW = 10,
            VIVILLON_REGION_MODERN = 11,
            VIVILLON_REGION_MONSOON = 12,
            VIVILLON_REGION_OCEAN = 13,
            VIVILLON_REGION_POKEBALL = 14,
            VIVILLON_REGION_POLAR = 15,
            VIVILLON_REGION_RIVER = 16,
            VIVILLON_REGION_SANDSTORM = 17,
            VIVILLON_REGION_SAVANNA = 18,
            VIVILLON_REGION_SUN = 19,
            VIVILLON_REGION_TUNDRA = 20
        }

        enum VpsEnabledStatus {
            VPS_ENABLED_STATUS_UNSET = 0,
            VPS_RELEASE_ENABLED = 1,
            VPS_ADMIN_ENABLED = 2,
            VPS_NOT_ENABLED = 3,
            VPS_PRODUCTION_ENABLED = 4,
            VPS_TEMPORARILY_NOT_ALLOWED = 5,
            VPS_NOT_ALLOWED = 6
        }

        enum VpsEventType {
            VPS_EVENT_UNSET = 0,
            VPS_EVENT_SLEEPING_POKEMON = 1,
            VPS_EVENT_PHOTO_SAFARI = 2,
            VPS_EVENT_IRIS_SOCIAL = 3
        }

        enum VsEffectTag {
            UNSET_VS_EFFECT_TAG = 0,
            SHADOW_ENRAGE = 1,
            RAID_DEFENDER = 2,
            RAID_ATTACKER = 3
        }

        enum VsSeekerRewardTrack {
            VS_SEEKER_REWARD_TRACK_FREE = 0,
            VS_SEEKER_REWARD_TRACK_PREMIUM = 1
        }

        enum WebTelemetryIds {
            WEB_TELEMETRY_IDS_UNDEFINED_WEB_EVENT = 0,
            WEB_TELEMETRY_IDS_POINT_OF_INTEREST_DESCRIPTION_WEB_CLICK = 1,
            WEB_TELEMETRY_IDS_NEWS_WEB_CLICK = 2,
            WEB_TELEMETRY_IDS_ACTIVE_EVENT_WEB_CLICK = 3,
            WEB_TELEMETRY_IDS_UPCOMING_EVENT_WEB_CLICK = 4
        }

        interface IARBuddyMultiplayerSessionTelemetry {
            camera_permission_granted?: (boolean|null);
            host_time_to_publish_first_map?: (number|Long|null);
            host_number_of_maps_published?: (number|null);
            host_mapping_successful?: (boolean|null);
            lobby_connection_successful?: (boolean|null);
            time_from_start_of_session_to_sync?: (number|Long|null);
            sync_successful?: (boolean|null);
            session_length?: (number|Long|null);
            crash_count?: (number|null);
            duration_spent_in_lobby?: (number|Long|null);
            time_from_invite_to_lobby?: (number|Long|null);
            time_from_lobby_to_session?: (number|Long|null);
            length_of_ar_session?: (number|Long|null);
            players_connected?: (number|null);
            players_dropped?: (number|null);
            num_photos_taken?: (number|null);
            is_host?: (boolean|null);
        }

        class ARBuddyMultiplayerSessionTelemetry implements IARBuddyMultiplayerSessionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IARBuddyMultiplayerSessionTelemetry);
            public camera_permission_granted: boolean;
            public host_time_to_publish_first_map: (number|Long);
            public host_number_of_maps_published: number;
            public host_mapping_successful: boolean;
            public lobby_connection_successful: boolean;
            public time_from_start_of_session_to_sync: (number|Long);
            public sync_successful: boolean;
            public session_length: (number|Long);
            public crash_count: number;
            public duration_spent_in_lobby: (number|Long);
            public time_from_invite_to_lobby: (number|Long);
            public time_from_lobby_to_session: (number|Long);
            public length_of_ar_session: (number|Long);
            public players_connected: number;
            public players_dropped: number;
            public num_photos_taken: number;
            public is_host: boolean;
            public static encode(message: POGOProtos.Rpc.IARBuddyMultiplayerSessionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARBuddyMultiplayerSessionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARBuddyMultiplayerSessionTelemetry;
            public static toObject(message: POGOProtos.Rpc.ARBuddyMultiplayerSessionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKARClientEnvelope {
            age_level?: (POGOProtos.Rpc.ARDKARClientEnvelope.AgeLevel|null);
            ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
        }

        class ARDKARClientEnvelope implements IARDKARClientEnvelope {
            constructor(properties?: POGOProtos.Rpc.IARDKARClientEnvelope);
            public age_level: POGOProtos.Rpc.ARDKARClientEnvelope.AgeLevel;
            public ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            public static encode(message: POGOProtos.Rpc.IARDKARClientEnvelope, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKARClientEnvelope;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKARClientEnvelope;
            public static toObject(message: POGOProtos.Rpc.ARDKARClientEnvelope, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKARClientEnvelope {

            enum AgeLevel {
                unknown = 0,
                minor = 1,
                teen = 2,
                adult = 3
            }
        }

        interface IARDKARCommonMetadata {
            application_id?: (string|null);
            platform?: (string|null);
            manufacturer?: (string|null);
            device_model?: (string|null);
            user_id?: (string|null);
            client_id?: (string|null);
            developer_id?: (string|null);
            ardk_version?: (string|null);
            ardk_app_instance_id?: (string|null);
            request_id?: (string|null);
        }

        class ARDKARCommonMetadata implements IARDKARCommonMetadata {
            constructor(properties?: POGOProtos.Rpc.IARDKARCommonMetadata);
            public application_id: string;
            public platform: string;
            public manufacturer: string;
            public device_model: string;
            public user_id: string;
            public client_id: string;
            public developer_id: string;
            public ardk_version: string;
            public ardk_app_instance_id: string;
            public request_id: string;
            public static encode(message: POGOProtos.Rpc.IARDKARCommonMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKARCommonMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKARCommonMetadata;
            public static toObject(message: POGOProtos.Rpc.ARDKARCommonMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKAffineTransformProto {
            rotation?: (number[]|null);
            translation?: (number[]|null);
        }

        class ARDKAffineTransformProto implements IARDKAffineTransformProto {
            constructor(properties?: POGOProtos.Rpc.IARDKAffineTransformProto);
            public rotation: number[];
            public translation: number[];
            public static encode(message: POGOProtos.Rpc.IARDKAffineTransformProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKAffineTransformProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKAffineTransformProto;
            public static toObject(message: POGOProtos.Rpc.ARDKAffineTransformProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKAsyncFileUploadCompleteOutProto {
            error?: (POGOProtos.Rpc.ARDKAsyncFileUploadCompleteOutProto.ErrorStatus|null);
            submission_type?: (POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto|null);
            poi_id?: (string|null);
            post_action_game_info?: (Uint8Array|null);
        }

        class ARDKAsyncFileUploadCompleteOutProto implements IARDKAsyncFileUploadCompleteOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKAsyncFileUploadCompleteOutProto);
            public error: POGOProtos.Rpc.ARDKAsyncFileUploadCompleteOutProto.ErrorStatus;
            public submission_type: POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto;
            public poi_id: string;
            public post_action_game_info: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IARDKAsyncFileUploadCompleteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKAsyncFileUploadCompleteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKAsyncFileUploadCompleteOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKAsyncFileUploadCompleteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKAsyncFileUploadCompleteOutProto {

            enum ErrorStatus {
                unset = 0,
                server_update_failed = 1,
                missing_submission_id = 2,
                missing_submission_type = 3,
                missing_upload_status = 4
            }
        }

        interface IARDKAsyncFileUploadCompleteProto {
            submission_id?: (string|null);
            upload_status?: (POGOProtos.Rpc.ARDKAsyncFileUploadCompleteProto.Status|null);
            ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
        }

        class ARDKAsyncFileUploadCompleteProto implements IARDKAsyncFileUploadCompleteProto {
            constructor(properties?: POGOProtos.Rpc.IARDKAsyncFileUploadCompleteProto);
            public submission_id: string;
            public upload_status: POGOProtos.Rpc.ARDKAsyncFileUploadCompleteProto.Status;
            public ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            public static encode(message: POGOProtos.Rpc.IARDKAsyncFileUploadCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKAsyncFileUploadCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKAsyncFileUploadCompleteProto;
            public static toObject(message: POGOProtos.Rpc.ARDKAsyncFileUploadCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKAsyncFileUploadCompleteProto {

            enum Status {
                unset = 0,
                upload_done = 1,
                upload_failed = 2
            }
        }

        interface IARDKAvailableSubmissionsPerSubmissionType {
            player_submission_type?: (POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto|null);
            submissions_left?: (number|null);
            min_player_level?: (number|null);
            is_feature_enabled?: (boolean|null);
            time_window_for_submissions_limit_ms?: (number|Long|null);
            max_poi_distance_in_meters?: (number|null);
            blacklisted_os?: (string[]|null);
            blacklisted_device_id?: (string[]|null);
            is_whitelisted_user?: (boolean|null);
            is_upload_later_enabled?: (boolean|null);
            daily_new_submissions?: (number|null);
            max_submissions?: (number|null);
            is_wayfarer_onboarding_enabled?: (boolean|null);
        }

        class ARDKAvailableSubmissionsPerSubmissionType implements IARDKAvailableSubmissionsPerSubmissionType {
            constructor(properties?: POGOProtos.Rpc.IARDKAvailableSubmissionsPerSubmissionType);
            public player_submission_type: POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto;
            public submissions_left: number;
            public min_player_level: number;
            public is_feature_enabled: boolean;
            public time_window_for_submissions_limit_ms: (number|Long);
            public max_poi_distance_in_meters: number;
            public blacklisted_os: string[];
            public blacklisted_device_id: string[];
            public is_whitelisted_user: boolean;
            public is_upload_later_enabled: boolean;
            public daily_new_submissions: number;
            public max_submissions: number;
            public is_wayfarer_onboarding_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IARDKAvailableSubmissionsPerSubmissionType, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKAvailableSubmissionsPerSubmissionType;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKAvailableSubmissionsPerSubmissionType;
            public static toObject(message: POGOProtos.Rpc.ARDKAvailableSubmissionsPerSubmissionType, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKBoundingBoxProto {
            lo_x?: (number|null);
            lo_y?: (number|null);
            lo_z?: (number|null);
            hi_x?: (number|null);
            hi_y?: (number|null);
            hi_z?: (number|null);
        }

        class ARDKBoundingBoxProto implements IARDKBoundingBoxProto {
            constructor(properties?: POGOProtos.Rpc.IARDKBoundingBoxProto);
            public lo_x: number;
            public lo_y: number;
            public lo_z: number;
            public hi_x: number;
            public hi_y: number;
            public hi_z: number;
            public static encode(message: POGOProtos.Rpc.IARDKBoundingBoxProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKBoundingBoxProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKBoundingBoxProto;
            public static toObject(message: POGOProtos.Rpc.ARDKBoundingBoxProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKCameraParamsProto {
            width?: (number|null);
            height?: (number|null);
            fx?: (number|null);
            px?: (number|null);
            py?: (number|null);
            k?: (number|null);
            fy?: (number|null);
        }

        class ARDKCameraParamsProto implements IARDKCameraParamsProto {
            constructor(properties?: POGOProtos.Rpc.IARDKCameraParamsProto);
            public width: number;
            public height: number;
            public fx: number;
            public px: number;
            public py: number;
            public k: number;
            public fy: number;
            public static encode(message: POGOProtos.Rpc.IARDKCameraParamsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKCameraParamsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKCameraParamsProto;
            public static toObject(message: POGOProtos.Rpc.ARDKCameraParamsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKDepthRangeProto {
            near?: (number|null);
            far?: (number|null);
        }

        class ARDKDepthRangeProto implements IARDKDepthRangeProto {
            constructor(properties?: POGOProtos.Rpc.IARDKDepthRangeProto);
            public near: number;
            public far: number;
            public static encode(message: POGOProtos.Rpc.IARDKDepthRangeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKDepthRangeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKDepthRangeProto;
            public static toObject(message: POGOProtos.Rpc.ARDKDepthRangeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKExposureInfoProto {
            shutter?: (number|null);
            offset?: (number|null);
        }

        class ARDKExposureInfoProto implements IARDKExposureInfoProto {
            constructor(properties?: POGOProtos.Rpc.IARDKExposureInfoProto);
            public shutter: number;
            public offset: number;
            public static encode(message: POGOProtos.Rpc.IARDKExposureInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKExposureInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKExposureInfoProto;
            public static toObject(message: POGOProtos.Rpc.ARDKExposureInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKFrameProto {
            id?: (number|null);
            anchor?: (number|null);
            timestamp?: (number|null);
            camera?: (POGOProtos.Rpc.IARDKCameraParamsProto|null);
            transform?: (POGOProtos.Rpc.IARDKAffineTransformProto|null);
            exposure?: (POGOProtos.Rpc.IARDKExposureInfoProto|null);
            range?: (POGOProtos.Rpc.IARDKDepthRangeProto|null);
            quality?: (number|null);
            is_large_image?: (boolean|null);
            tracking_state?: (number|null);
        }

        class ARDKFrameProto implements IARDKFrameProto {
            constructor(properties?: POGOProtos.Rpc.IARDKFrameProto);
            public id: number;
            public anchor: number;
            public timestamp: number;
            public camera?: (POGOProtos.Rpc.IARDKCameraParamsProto|null);
            public transform?: (POGOProtos.Rpc.IARDKAffineTransformProto|null);
            public exposure?: (POGOProtos.Rpc.IARDKExposureInfoProto|null);
            public range?: (POGOProtos.Rpc.IARDKDepthRangeProto|null);
            public quality: number;
            public is_large_image: boolean;
            public tracking_state: number;
            public static encode(message: POGOProtos.Rpc.IARDKFrameProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKFrameProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKFrameProto;
            public static toObject(message: POGOProtos.Rpc.ARDKFrameProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKFramesProto {
            id?: (string|null);
            locations?: (POGOProtos.Rpc.IARDKLocationProto[]|null);
            frames?: (POGOProtos.Rpc.IARDKFrameProto[]|null);
            anchors?: (POGOProtos.Rpc.IARDKAffineTransformProto[]|null);
            keyframes?: (POGOProtos.Rpc.IARDKFrameProto[]|null);
        }

        class ARDKFramesProto implements IARDKFramesProto {
            constructor(properties?: POGOProtos.Rpc.IARDKFramesProto);
            public id: string;
            public locations: POGOProtos.Rpc.IARDKLocationProto[];
            public frames: POGOProtos.Rpc.IARDKFrameProto[];
            public anchors: POGOProtos.Rpc.IARDKAffineTransformProto[];
            public keyframes: POGOProtos.Rpc.IARDKFrameProto[];
            public static encode(message: POGOProtos.Rpc.IARDKFramesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKFramesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKFramesProto;
            public static toObject(message: POGOProtos.Rpc.ARDKFramesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGenerateGmapSignedUrlOutProto {
            result?: (POGOProtos.Rpc.ARDKGenerateGmapSignedUrlOutProto.Result|null);
            signed_url?: (string|null);
        }

        class ARDKGenerateGmapSignedUrlOutProto implements IARDKGenerateGmapSignedUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGenerateGmapSignedUrlOutProto);
            public result: POGOProtos.Rpc.ARDKGenerateGmapSignedUrlOutProto.Result;
            public signed_url: string;
            public static encode(message: POGOProtos.Rpc.IARDKGenerateGmapSignedUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGenerateGmapSignedUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGenerateGmapSignedUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGenerateGmapSignedUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKGenerateGmapSignedUrlOutProto {

            enum Result {
                unset = 0,
                success = 1,
                error_player_not_valid = 2,
                error_rate_limited = 3,
                error_missing_input = 4,
                error_unknown = 5
            }
        }

        interface IARDKGenerateGmapSignedUrlProto {
            latitude?: (number|null);
            longitude?: (number|null);
            width?: (number|null);
            height?: (number|null);
            zoom?: (number|null);
            language_code?: (string|null);
            country_code?: (string|null);
            map_style?: (string|null);
            map_type?: (string|null);
            icon_params?: (string|null);
        }

        class ARDKGenerateGmapSignedUrlProto implements IARDKGenerateGmapSignedUrlProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGenerateGmapSignedUrlProto);
            public latitude: number;
            public longitude: number;
            public width: number;
            public height: number;
            public zoom: number;
            public language_code: string;
            public country_code: string;
            public map_style: string;
            public map_type: string;
            public icon_params: string;
            public static encode(message: POGOProtos.Rpc.IARDKGenerateGmapSignedUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGenerateGmapSignedUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGenerateGmapSignedUrlProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGenerateGmapSignedUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetARMappingSettingsOutProto {
            is_client_scan_validation_enabled?: (boolean|null);
            client_scan_validation_blocked_os?: (string[]|null);
            client_scan_validation_blocked_device_id?: (string[]|null);
        }

        class ARDKGetARMappingSettingsOutProto implements IARDKGetARMappingSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetARMappingSettingsOutProto);
            public is_client_scan_validation_enabled: boolean;
            public client_scan_validation_blocked_os: string[];
            public client_scan_validation_blocked_device_id: string[];
            public static encode(message: POGOProtos.Rpc.IARDKGetARMappingSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetARMappingSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetARMappingSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetARMappingSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetARMappingSettingsProto {
        }

        class ARDKGetARMappingSettingsProto implements IARDKGetARMappingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetARMappingSettingsProto);
            public static encode(message: POGOProtos.Rpc.IARDKGetARMappingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetARMappingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetARMappingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetARMappingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetAvailableSubmissionsOutProto {
            submissions_left?: (number|null);
            min_player_level?: (number|null);
            has_valid_email?: (boolean|null);
            is_feature_enabled?: (boolean|null);
            time_window_for_submissions_limit_ms?: (number|Long|null);
            max_poi_distance_in_meters?: (number|null);
            blacklisted_os?: (string[]|null);
            availability_result_per_type?: (POGOProtos.Rpc.IARDKAvailableSubmissionsPerSubmissionType[]|null);
            blacklisted_device_id?: (string[]|null);
            max_poi_location_edit_move_distance_meters?: (number|null);
            is_upload_later_enabled?: (boolean|null);
            category_cloud_storage_directory_path?: (string|null);
            has_wayfarer_account?: (boolean|null);
            is_poi_submission_category_enabled?: (boolean|null);
            passed_wayfarer_quiz?: (boolean|null);
            urban_typology_cloud_storage_path?: (string|null);
        }

        class ARDKGetAvailableSubmissionsOutProto implements IARDKGetAvailableSubmissionsOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetAvailableSubmissionsOutProto);
            public submissions_left: number;
            public min_player_level: number;
            public has_valid_email: boolean;
            public is_feature_enabled: boolean;
            public time_window_for_submissions_limit_ms: (number|Long);
            public max_poi_distance_in_meters: number;
            public blacklisted_os: string[];
            public availability_result_per_type: POGOProtos.Rpc.IARDKAvailableSubmissionsPerSubmissionType[];
            public blacklisted_device_id: string[];
            public max_poi_location_edit_move_distance_meters: number;
            public is_upload_later_enabled: boolean;
            public category_cloud_storage_directory_path: string;
            public has_wayfarer_account: boolean;
            public is_poi_submission_category_enabled: boolean;
            public passed_wayfarer_quiz: boolean;
            public urban_typology_cloud_storage_path: string;
            public static encode(message: POGOProtos.Rpc.IARDKGetAvailableSubmissionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetAvailableSubmissionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetAvailableSubmissionsOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetAvailableSubmissionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetAvailableSubmissionsProto {
            submission_type?: (POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto|null);
            submission_types?: (POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto[]|null);
        }

        class ARDKGetAvailableSubmissionsProto implements IARDKGetAvailableSubmissionsProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetAvailableSubmissionsProto);
            public submission_type: POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto;
            public submission_types: POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto[];
            public static encode(message: POGOProtos.Rpc.IARDKGetAvailableSubmissionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetAvailableSubmissionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetAvailableSubmissionsProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetAvailableSubmissionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetGmapSettingsOutProto {
            result?: (POGOProtos.Rpc.ARDKGetGmapSettingsOutProto.Result|null);
            gmap_template_url?: (string|null);
            max_poi_distance_in_meters?: (number|null);
            min_zoom?: (number|null);
            max_zoom?: (number|null);
        }

        class ARDKGetGmapSettingsOutProto implements IARDKGetGmapSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetGmapSettingsOutProto);
            public result: POGOProtos.Rpc.ARDKGetGmapSettingsOutProto.Result;
            public gmap_template_url: string;
            public max_poi_distance_in_meters: number;
            public min_zoom: number;
            public max_zoom: number;
            public static encode(message: POGOProtos.Rpc.IARDKGetGmapSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetGmapSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetGmapSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetGmapSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKGetGmapSettingsOutProto {

            enum Result {
                unset = 0,
                success = 1,
                error_unknown = 2,
                error_missing_config = 3,
                error_no_unique_id = 4
            }
        }

        interface IARDKGetGmapSettingsProto {
        }

        class ARDKGetGmapSettingsProto implements IARDKGetGmapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetGmapSettingsProto);
            public static encode(message: POGOProtos.Rpc.IARDKGetGmapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetGmapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetGmapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetGmapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetGrapeshotUploadUrlOutProto {
            status?: (POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlOutProto.Status|null);
            file_context_to_grapeshot_data?: ({ [k: string]: POGOProtos.Rpc.IARDKGrapeshotUploadingDataProto }|null);
        }

        class ARDKGetGrapeshotUploadUrlOutProto implements IARDKGetGrapeshotUploadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetGrapeshotUploadUrlOutProto);
            public status: POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlOutProto.Status;
            public file_context_to_grapeshot_data: { [k: string]: POGOProtos.Rpc.IARDKGrapeshotUploadingDataProto };
            public static encode(message: POGOProtos.Rpc.IARDKGetGrapeshotUploadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKGetGrapeshotUploadUrlOutProto {

            enum Status {
                unset = 0,
                failure = 1,
                success = 2,
                missing_file_contexts = 3,
                duplicate_file_context = 4,
                missing_submission_type = 5,
                missing_submission_id = 6
            }
        }

        interface IARDKGetGrapeshotUploadUrlProto {
            submission_type?: (POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto|null);
            submission_id?: (string|null);
            file_upload_context?: (string[]|null);
        }

        class ARDKGetGrapeshotUploadUrlProto implements IARDKGetGrapeshotUploadUrlProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetGrapeshotUploadUrlProto);
            public submission_type: POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto;
            public submission_id: string;
            public file_upload_context: string[];
            public static encode(message: POGOProtos.Rpc.IARDKGetGrapeshotUploadUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetGrapeshotUploadUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetPlayerSubmissionValidationSettingsOutProto {
            banned_metadata_text?: (string[]|null);
        }

        class ARDKGetPlayerSubmissionValidationSettingsOutProto implements IARDKGetPlayerSubmissionValidationSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetPlayerSubmissionValidationSettingsOutProto);
            public banned_metadata_text: string[];
            public static encode(message: POGOProtos.Rpc.IARDKGetPlayerSubmissionValidationSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetPlayerSubmissionValidationSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetPlayerSubmissionValidationSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetPlayerSubmissionValidationSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetPlayerSubmissionValidationSettingsProto {
        }

        class ARDKGetPlayerSubmissionValidationSettingsProto implements IARDKGetPlayerSubmissionValidationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetPlayerSubmissionValidationSettingsProto);
            public static encode(message: POGOProtos.Rpc.IARDKGetPlayerSubmissionValidationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetPlayerSubmissionValidationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetPlayerSubmissionValidationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetPlayerSubmissionValidationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGetUploadUrlOutProto {
            status?: (POGOProtos.Rpc.ARDKGetUploadUrlOutProto.Status|null);
            signed_url?: (string|null);
            supporting_image_signed_url?: (string|null);
            context_signed_urls?: ({ [k: string]: string }|null);
        }

        class ARDKGetUploadUrlOutProto implements IARDKGetUploadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetUploadUrlOutProto);
            public status: POGOProtos.Rpc.ARDKGetUploadUrlOutProto.Status;
            public signed_url: string;
            public supporting_image_signed_url: string;
            public context_signed_urls: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IARDKGetUploadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetUploadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetUploadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetUploadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKGetUploadUrlOutProto {

            enum Status {
                unset = 0,
                failures = 1,
                success = 2,
                missing_image_contexts = 3,
                duplicate_image_contexts = 4
            }
        }

        interface IARDKGetUploadUrlProto {
            user_id?: (string|null);
            game_unique_id?: (string|null);
            submission_type?: (POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto|null);
            submission_id?: (string|null);
            image_contexts?: (string[]|null);
        }

        class ARDKGetUploadUrlProto implements IARDKGetUploadUrlProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGetUploadUrlProto);
            public user_id: string;
            public game_unique_id: string;
            public submission_type: POGOProtos.Rpc.ARDKPlayerSubmissionTypeProto;
            public submission_id: string;
            public image_contexts: string[];
            public static encode(message: POGOProtos.Rpc.IARDKGetUploadUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGetUploadUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGetUploadUrlProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGetUploadUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGrapeshotAuthenticationDataProto {
            authorization?: (string|null);
            date?: (string|null);
        }

        class ARDKGrapeshotAuthenticationDataProto implements IARDKGrapeshotAuthenticationDataProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto);
            public authorization: string;
            public date: string;
            public static encode(message: POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGrapeshotAuthenticationDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGrapeshotAuthenticationDataProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGrapeshotAuthenticationDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGrapeshotChunkDataProto {
            chunk_file_path?: (string|null);
            chunk_number?: (number|null);
            upload_authentication?: (POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto|null);
            delete_authentication?: (POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto|null);
        }

        class ARDKGrapeshotChunkDataProto implements IARDKGrapeshotChunkDataProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGrapeshotChunkDataProto);
            public chunk_file_path: string;
            public chunk_number: number;
            public upload_authentication?: (POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto|null);
            public delete_authentication?: (POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto|null);
            public static encode(message: POGOProtos.Rpc.IARDKGrapeshotChunkDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGrapeshotChunkDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGrapeshotChunkDataProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGrapeshotChunkDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGrapeshotComposeDataProto {
            target_file_path?: (string|null);
            authentication?: (POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto|null);
            hash?: (string|null);
        }

        class ARDKGrapeshotComposeDataProto implements IARDKGrapeshotComposeDataProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGrapeshotComposeDataProto);
            public target_file_path: string;
            public authentication?: (POGOProtos.Rpc.IARDKGrapeshotAuthenticationDataProto|null);
            public hash: string;
            public static encode(message: POGOProtos.Rpc.IARDKGrapeshotComposeDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGrapeshotComposeDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGrapeshotComposeDataProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGrapeshotComposeDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKGrapeshotUploadingDataProto {
            chunk_data?: (POGOProtos.Rpc.IARDKGrapeshotChunkDataProto[]|null);
            compose_data?: (POGOProtos.Rpc.IARDKGrapeshotComposeDataProto|null);
            gcs_bucket?: (string|null);
            number_of_chunks?: (number|null);
        }

        class ARDKGrapeshotUploadingDataProto implements IARDKGrapeshotUploadingDataProto {
            constructor(properties?: POGOProtos.Rpc.IARDKGrapeshotUploadingDataProto);
            public chunk_data: POGOProtos.Rpc.IARDKGrapeshotChunkDataProto[];
            public compose_data?: (POGOProtos.Rpc.IARDKGrapeshotComposeDataProto|null);
            public gcs_bucket: string;
            public number_of_chunks: number;
            public static encode(message: POGOProtos.Rpc.IARDKGrapeshotUploadingDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKGrapeshotUploadingDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKGrapeshotUploadingDataProto;
            public static toObject(message: POGOProtos.Rpc.ARDKGrapeshotUploadingDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKLocationE6Proto {
            latitude_e6?: (number|null);
            longitude_e6?: (number|null);
        }

        class ARDKLocationE6Proto implements IARDKLocationE6Proto {
            constructor(properties?: POGOProtos.Rpc.IARDKLocationE6Proto);
            public latitude_e6: number;
            public longitude_e6: number;
            public static encode(message: POGOProtos.Rpc.IARDKLocationE6Proto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKLocationE6Proto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKLocationE6Proto;
            public static toObject(message: POGOProtos.Rpc.ARDKLocationE6Proto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKLocationProto {
            timestamp?: (number|null);
            latitude?: (number|null);
            longitude?: (number|null);
            accuracy?: (number|null);
            elevation_meters?: (number|null);
            elevation_accuracy?: (number|null);
            heading_degrees?: (number|null);
            heading_accuracy?: (number|null);
            heading_timestamp?: (number|null);
            position_timestamp?: (number|null);
        }

        class ARDKLocationProto implements IARDKLocationProto {
            constructor(properties?: POGOProtos.Rpc.IARDKLocationProto);
            public timestamp: number;
            public latitude: number;
            public longitude: number;
            public accuracy: number;
            public elevation_meters: number;
            public elevation_accuracy: number;
            public heading_degrees: number;
            public heading_accuracy: number;
            public heading_timestamp: number;
            public position_timestamp: number;
            public static encode(message: POGOProtos.Rpc.IARDKLocationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKLocationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKLocationProto;
            public static toObject(message: POGOProtos.Rpc.ARDKLocationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKPlayerSubmissionResponseProto {
            status?: (POGOProtos.Rpc.ARDKPlayerSubmissionResponseProto.Status|null);
            submission_id?: (string|null);
            messages?: (string[]|null);
        }

        class ARDKPlayerSubmissionResponseProto implements IARDKPlayerSubmissionResponseProto {
            constructor(properties?: POGOProtos.Rpc.IARDKPlayerSubmissionResponseProto);
            public status: POGOProtos.Rpc.ARDKPlayerSubmissionResponseProto.Status;
            public submission_id: string;
            public messages: string[];
            public static encode(message: POGOProtos.Rpc.IARDKPlayerSubmissionResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKPlayerSubmissionResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKPlayerSubmissionResponseProto;
            public static toObject(message: POGOProtos.Rpc.ARDKPlayerSubmissionResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKPlayerSubmissionResponseProto {

            enum Status {
                unspecified = 0,
                success = 1,
                internal_error = 2,
                too_many_recent_submissions = 3,
                minor = 4,
                not_available = 5,
                invalid_input = 6,
                missing_image = 7,
                distance_validation_failed = 8
            }
        }

        interface IARDKPoiVideoSubmissionMetadataProto {
            poi_id?: (string|null);
            location?: (POGOProtos.Rpc.IARDKLocationE6Proto|null);
            player_level?: (number|null);
            user_type?: (POGOProtos.Rpc.ARDKUserType|null);
            is_private?: (boolean|null);
            geographic_coverage?: (string|null);
            built_form?: (string[]|null);
            scan_tags?: (POGOProtos.Rpc.ARDKScanTag[]|null);
            developer_id?: (string|null);
            ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
        }

        class ARDKPoiVideoSubmissionMetadataProto implements IARDKPoiVideoSubmissionMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IARDKPoiVideoSubmissionMetadataProto);
            public poi_id: string;
            public location?: (POGOProtos.Rpc.IARDKLocationE6Proto|null);
            public player_level: number;
            public user_type: POGOProtos.Rpc.ARDKUserType;
            public is_private: boolean;
            public geographic_coverage: string;
            public built_form: string[];
            public scan_tags: POGOProtos.Rpc.ARDKScanTag[];
            public developer_id: string;
            public ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            public static encode(message: POGOProtos.Rpc.IARDKPoiVideoSubmissionMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKPoiVideoSubmissionMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKPoiVideoSubmissionMetadataProto;
            public static toObject(message: POGOProtos.Rpc.ARDKPoiVideoSubmissionMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKPortalCurationImageResult {
        }

        class ARDKPortalCurationImageResult implements IARDKPortalCurationImageResult {
            constructor(properties?: POGOProtos.Rpc.IARDKPortalCurationImageResult);
            public static encode(message: POGOProtos.Rpc.IARDKPortalCurationImageResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKPortalCurationImageResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKPortalCurationImageResult;
            public static toObject(message: POGOProtos.Rpc.ARDKPortalCurationImageResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKPortalCurationImageResult {

            enum Result {
                unset = 0,
                success = 1,
                feature_disabled = 2,
                already_uploaded = 3,
                image_not_found = 4,
                image_too_big = 5,
                image_not_servable = 6,
                portal_not_found = 7
            }
        }

        interface IARDKRasterSizeProto {
            width?: (number|null);
            height?: (number|null);
        }

        class ARDKRasterSizeProto implements IARDKRasterSizeProto {
            constructor(properties?: POGOProtos.Rpc.IARDKRasterSizeProto);
            public width: number;
            public height: number;
            public static encode(message: POGOProtos.Rpc.IARDKRasterSizeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKRasterSizeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKRasterSizeProto;
            public static toObject(message: POGOProtos.Rpc.ARDKRasterSizeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKScanMetadataProto {
            id?: (string|null);
            image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            depth_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            start_timestamp?: (number|null);
            app_name?: (string|null);
            platform_name?: (string|null);
            model_name?: (string|null);
            manufacturer_name?: (string|null);
            poi?: (string|null);
            recorder?: (string|null);
            user_json?: (string|null);
            native_depth?: (boolean|null);
            origin?: (number[]|null);
            global_rotation?: (number[]|null);
            timezone_offset?: (number|null);
            recorder_version?: (number|null);
        }

        class ARDKScanMetadataProto implements IARDKScanMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IARDKScanMetadataProto);
            public id: string;
            public image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public depth_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public start_timestamp: number;
            public app_name: string;
            public platform_name: string;
            public model_name: string;
            public manufacturer_name: string;
            public poi: string;
            public recorder: string;
            public user_json: string;
            public native_depth: boolean;
            public origin: number[];
            public global_rotation: number[];
            public timezone_offset: number;
            public recorder_version: number;
            public static encode(message: POGOProtos.Rpc.IARDKScanMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKScanMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKScanMetadataProto;
            public static toObject(message: POGOProtos.Rpc.ARDKScanMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitNewPoiOutProto {
            status?: (POGOProtos.Rpc.ARDKSubmitNewPoiOutProto.Status|null);
            submission_id?: (string|null);
            messages?: (string[]|null);
            poi_id?: (string|null);
        }

        class ARDKSubmitNewPoiOutProto implements IARDKSubmitNewPoiOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitNewPoiOutProto);
            public status: POGOProtos.Rpc.ARDKSubmitNewPoiOutProto.Status;
            public submission_id: string;
            public messages: string[];
            public poi_id: string;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitNewPoiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitNewPoiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitNewPoiOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitNewPoiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ARDKSubmitNewPoiOutProto {

            enum Status {
                unset = 0,
                success = 1,
                failure = 2,
                internal_error = 3,
                too_many_recent_submissions = 4,
                invalid_input = 5,
                minor = 6,
                not_available = 7
            }
        }

        interface IARDKSubmitNewPoiProto {
            title?: (string|null);
            long_description?: (string|null);
            lat_e6?: (number|null);
            lng_e6?: (number|null);
            supporting_statement?: (string|null);
            async_file_upload?: (boolean|null);
            player_submitted_category_ids?: (string[]|null);
            category_suggestion?: (string|null);
            nomination_type?: (POGOProtos.Rpc.ARDKNominationType|null);
            developer_id?: (string|null);
        }

        class ARDKSubmitNewPoiProto implements IARDKSubmitNewPoiProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitNewPoiProto);
            public title: string;
            public long_description: string;
            public lat_e6: number;
            public lng_e6: number;
            public supporting_statement: string;
            public async_file_upload: boolean;
            public player_submitted_category_ids: string[];
            public category_suggestion: string;
            public nomination_type: POGOProtos.Rpc.ARDKNominationType;
            public developer_id: string;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitNewPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitNewPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitNewPoiProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitNewPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitPoiCategoryVoteRecordProto {
            poi_id?: (string|null);
            player_submitted_category_ids?: (string[]|null);
            category_suggestion?: (string|null);
        }

        class ARDKSubmitPoiCategoryVoteRecordProto implements IARDKSubmitPoiCategoryVoteRecordProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitPoiCategoryVoteRecordProto);
            public poi_id: string;
            public player_submitted_category_ids: string[];
            public category_suggestion: string;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitPoiCategoryVoteRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitPoiCategoryVoteRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitPoiCategoryVoteRecordProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitPoiCategoryVoteRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitPoiImageProto {
            poi_id?: (string|null);
            async_file_upload?: (boolean|null);
            developer_id?: (string|null);
            nomination_type?: (POGOProtos.Rpc.ARDKNominationType|null);
        }

        class ARDKSubmitPoiImageProto implements IARDKSubmitPoiImageProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitPoiImageProto);
            public poi_id: string;
            public async_file_upload: boolean;
            public developer_id: string;
            public nomination_type: POGOProtos.Rpc.ARDKNominationType;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitPoiImageProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitPoiImageProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitPoiImageProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitPoiImageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitPoiLocationUpdateProto {
            poi_id?: (string|null);
            location?: (POGOProtos.Rpc.IARDKLocationE6Proto|null);
        }

        class ARDKSubmitPoiLocationUpdateProto implements IARDKSubmitPoiLocationUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitPoiLocationUpdateProto);
            public poi_id: string;
            public location?: (POGOProtos.Rpc.IARDKLocationE6Proto|null);
            public static encode(message: POGOProtos.Rpc.IARDKSubmitPoiLocationUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitPoiLocationUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitPoiLocationUpdateProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitPoiLocationUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitPoiTakedownRequestProto {
            poi_id?: (string|null);
            invalid_reason?: (POGOProtos.Rpc.ARDKPoiInvalidReason|null);
        }

        class ARDKSubmitPoiTakedownRequestProto implements IARDKSubmitPoiTakedownRequestProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitPoiTakedownRequestProto);
            public poi_id: string;
            public invalid_reason: POGOProtos.Rpc.ARDKPoiInvalidReason;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitPoiTakedownRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitPoiTakedownRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitPoiTakedownRequestProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitPoiTakedownRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitPoiTextMetadataUpdateProto {
            poi_id?: (string|null);
            title?: (string|null);
            description?: (string|null);
        }

        class ARDKSubmitPoiTextMetadataUpdateProto implements IARDKSubmitPoiTextMetadataUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitPoiTextMetadataUpdateProto);
            public poi_id: string;
            public title: string;
            public description: string;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitPoiTextMetadataUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitPoiTextMetadataUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitPoiTextMetadataUpdateProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitPoiTextMetadataUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitSponsorPoiLocationUpdateProto {
            poi_id?: (string|null);
            location?: (POGOProtos.Rpc.IARDKLocationE6Proto|null);
        }

        class ARDKSubmitSponsorPoiLocationUpdateProto implements IARDKSubmitSponsorPoiLocationUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitSponsorPoiLocationUpdateProto);
            public poi_id: string;
            public location?: (POGOProtos.Rpc.IARDKLocationE6Proto|null);
            public static encode(message: POGOProtos.Rpc.IARDKSubmitSponsorPoiLocationUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitSponsorPoiLocationUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitSponsorPoiLocationUpdateProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitSponsorPoiLocationUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKSubmitSponsorPoiReportProto {
            poi_id?: (string|null);
            invalid_reason?: (POGOProtos.Rpc.ARDKSponsorPoiInvalidReason|null);
            additional_details?: (string|null);
        }

        class ARDKSubmitSponsorPoiReportProto implements IARDKSubmitSponsorPoiReportProto {
            constructor(properties?: POGOProtos.Rpc.IARDKSubmitSponsorPoiReportProto);
            public poi_id: string;
            public invalid_reason: POGOProtos.Rpc.ARDKSponsorPoiInvalidReason;
            public additional_details: string;
            public static encode(message: POGOProtos.Rpc.IARDKSubmitSponsorPoiReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKSubmitSponsorPoiReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKSubmitSponsorPoiReportProto;
            public static toObject(message: POGOProtos.Rpc.ARDKSubmitSponsorPoiReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKUploadPoiPhotoByUrlOutProto {
            status?: (POGOProtos.Rpc.ARDKPortalCurationImageResult.Result|null);
        }

        class ARDKUploadPoiPhotoByUrlOutProto implements IARDKUploadPoiPhotoByUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IARDKUploadPoiPhotoByUrlOutProto);
            public status: POGOProtos.Rpc.ARDKPortalCurationImageResult.Result;
            public static encode(message: POGOProtos.Rpc.IARDKUploadPoiPhotoByUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKUploadPoiPhotoByUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKUploadPoiPhotoByUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.ARDKUploadPoiPhotoByUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARDKUploadPoiPhotoByUrlProto {
            request_id?: (string|null);
            image_url?: (string|null);
        }

        class ARDKUploadPoiPhotoByUrlProto implements IARDKUploadPoiPhotoByUrlProto {
            constructor(properties?: POGOProtos.Rpc.IARDKUploadPoiPhotoByUrlProto);
            public request_id: string;
            public image_url: string;
            public static encode(message: POGOProtos.Rpc.IARDKUploadPoiPhotoByUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARDKUploadPoiPhotoByUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARDKUploadPoiPhotoByUrlProto;
            public static toObject(message: POGOProtos.Rpc.ARDKUploadPoiPhotoByUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IARPlusEncounterValuesProto {
            proximity?: (number|null);
            awareness?: (number|null);
            pokemon_frightened?: (boolean|null);
        }

        class ARPlusEncounterValuesProto implements IARPlusEncounterValuesProto {
            constructor(properties?: POGOProtos.Rpc.IARPlusEncounterValuesProto);
            public proximity: number;
            public awareness: number;
            public pokemon_frightened: boolean;
            public static encode(message: POGOProtos.Rpc.IARPlusEncounterValuesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ARPlusEncounterValuesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ARPlusEncounterValuesProto;
            public static toObject(message: POGOProtos.Rpc.ARPlusEncounterValuesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IASPermissionFlowTelemetry {
            initial_prompt?: (boolean|null);
            service_telemetry?: (POGOProtos.Rpc.ASServiceTelemetryIds[]|null);
            permission_telemetry?: (POGOProtos.Rpc.ASPermissionTelemetryIds|null);
            permission_status_telemetry?: (POGOProtos.Rpc.ASPermissionStatusTelemetryIds|null);
            success?: (boolean|null);
        }

        class ASPermissionFlowTelemetry implements IASPermissionFlowTelemetry {
            constructor(properties?: POGOProtos.Rpc.IASPermissionFlowTelemetry);
            public initial_prompt: boolean;
            public service_telemetry: POGOProtos.Rpc.ASServiceTelemetryIds[];
            public permission_telemetry: POGOProtos.Rpc.ASPermissionTelemetryIds;
            public permission_status_telemetry: POGOProtos.Rpc.ASPermissionStatusTelemetryIds;
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.IASPermissionFlowTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ASPermissionFlowTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ASPermissionFlowTelemetry;
            public static toObject(message: POGOProtos.Rpc.ASPermissionFlowTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAbilityEnergyMetadata {
            current_energy?: (number|null);
            energy_cost?: (number|null);
            max_energy?: (number|null);
            charge_rate?: ({ [k: string]: POGOProtos.Rpc.AbilityEnergyMetadata.IChargeRateSetting }|null);
            disabled?: (boolean|null);
        }

        class AbilityEnergyMetadata implements IAbilityEnergyMetadata {
            constructor(properties?: POGOProtos.Rpc.IAbilityEnergyMetadata);
            public current_energy: number;
            public energy_cost: number;
            public max_energy: number;
            public charge_rate: { [k: string]: POGOProtos.Rpc.AbilityEnergyMetadata.IChargeRateSetting };
            public disabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAbilityEnergyMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AbilityEnergyMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AbilityEnergyMetadata;
            public static toObject(message: POGOProtos.Rpc.AbilityEnergyMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AbilityEnergyMetadata {

            enum ChargeMultiplier {
                UNSET_MULTIPLIER = 0,
                PARTY_SIZE = 1
            }

            enum ChargeType {
                UNSET = 0,
                FAST_MOVE = 1,
                CHARGE_MOVE = 2
            }

            interface IChargeRateSetting {
                multiplier?: (POGOProtos.Rpc.AbilityEnergyMetadata.ChargeMultiplier|null);
                rate?: (number|null);
            }

            class ChargeRateSetting implements IChargeRateSetting {
                constructor(properties?: POGOProtos.Rpc.AbilityEnergyMetadata.IChargeRateSetting);
                public multiplier: POGOProtos.Rpc.AbilityEnergyMetadata.ChargeMultiplier;
                public rate: number;
                public static encode(message: POGOProtos.Rpc.AbilityEnergyMetadata.IChargeRateSetting, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AbilityEnergyMetadata.ChargeRateSetting;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AbilityEnergyMetadata.ChargeRateSetting;
                public static toObject(message: POGOProtos.Rpc.AbilityEnergyMetadata.ChargeRateSetting, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IAbilityLookupMap {
            lookup_location?: (POGOProtos.Rpc.AbilityLookupMap.AbilityLookupLocation|null);
            stat_modifier_type?: (POGOProtos.Rpc.StatModifierType|null);
        }

        class AbilityLookupMap implements IAbilityLookupMap {
            constructor(properties?: POGOProtos.Rpc.IAbilityLookupMap);
            public lookup_location: POGOProtos.Rpc.AbilityLookupMap.AbilityLookupLocation;
            public stat_modifier_type: POGOProtos.Rpc.StatModifierType;
            public static encode(message: POGOProtos.Rpc.IAbilityLookupMap, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AbilityLookupMap;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AbilityLookupMap;
            public static toObject(message: POGOProtos.Rpc.AbilityLookupMap, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AbilityLookupMap {

            enum AbilityLookupLocation {
                UNSET_ABILITY_LOCATION = 0,
                TRAINER_ACTIVE_POKEMON_STAT_MODIFIERS = 1
            }
        }

        interface IAbilityProto {
        }

        class AbilityProto implements IAbilityProto {
            constructor(properties?: POGOProtos.Rpc.IAbilityProto);
            public static encode(message: POGOProtos.Rpc.IAbilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AbilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AbilityProto;
            public static toObject(message: POGOProtos.Rpc.AbilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AbilityProto {

            enum AbilityType {
                UNSET_ABILITY_TYPE = 0,
                TRANSFORM_TO_OPPONENT = 1,
                SHADOW_ENRAGE = 2,
                SHADOW_SUPPRESS = 3,
                PARTY_POWER = 4,
                ENRAGE = 6,
                HUNGER_SWITCH = 7,
                STANCE_CHANGE = 8
            }
        }

        interface IAcceptCombatChallengeData {
            rpc_id?: (number|null);
            attacking_pokemon_indexes?: (number[]|null);
        }

        class AcceptCombatChallengeData implements IAcceptCombatChallengeData {
            constructor(properties?: POGOProtos.Rpc.IAcceptCombatChallengeData);
            public rpc_id: number;
            public attacking_pokemon_indexes: number[];
            public static encode(message: POGOProtos.Rpc.IAcceptCombatChallengeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcceptCombatChallengeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcceptCombatChallengeData;
            public static toObject(message: POGOProtos.Rpc.AcceptCombatChallengeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAcceptCombatChallengeOutProto {
            result?: (POGOProtos.Rpc.AcceptCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
        }

        class AcceptCombatChallengeOutProto implements IAcceptCombatChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.IAcceptCombatChallengeOutProto);
            public result: POGOProtos.Rpc.AcceptCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public static encode(message: POGOProtos.Rpc.IAcceptCombatChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcceptCombatChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcceptCombatChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.AcceptCombatChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AcceptCombatChallengeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_CHALLENGE_STATE = 2,
                ERROR_CHALLENGE_NOT_FOUND = 3,
                ERROR_POKEMON_NOT_IN_INVENTORY = 4,
                ERROR_NOT_ELIGIBLE_LEAGUE = 5,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 6,
                ERROR_OPPONENT_NOT_IN_RANGE = 7,
                ERROR_ALREADY_TIMEDOUT = 8,
                ERROR_ALREADY_CANCELLED = 9,
                ERROR_ACCESS_DENIED = 10
            }
        }

        interface IAcceptCombatChallengeProto {
            challenge_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
        }

        class AcceptCombatChallengeProto implements IAcceptCombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.IAcceptCombatChallengeProto);
            public challenge_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IAcceptCombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcceptCombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcceptCombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.AcceptCombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAcceptCombatChallengeResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.AcceptCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
        }

        class AcceptCombatChallengeResponseData implements IAcceptCombatChallengeResponseData {
            constructor(properties?: POGOProtos.Rpc.IAcceptCombatChallengeResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.AcceptCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
            public static encode(message: POGOProtos.Rpc.IAcceptCombatChallengeResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcceptCombatChallengeResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcceptCombatChallengeResponseData;
            public static toObject(message: POGOProtos.Rpc.AcceptCombatChallengeResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAccessibilitySettingsProto {
            enabled?: (boolean|null);
            plugin_enabled?: (boolean|null);
        }

        class AccessibilitySettingsProto implements IAccessibilitySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAccessibilitySettingsProto);
            public enabled: boolean;
            public plugin_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAccessibilitySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AccessibilitySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AccessibilitySettingsProto;
            public static toObject(message: POGOProtos.Rpc.AccessibilitySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAccountDeletionInitiatedTelemetry {
            account_deletion_status?: (string|null);
        }

        class AccountDeletionInitiatedTelemetry implements IAccountDeletionInitiatedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAccountDeletionInitiatedTelemetry);
            public account_deletion_status: string;
            public static encode(message: POGOProtos.Rpc.IAccountDeletionInitiatedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AccountDeletionInitiatedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AccountDeletionInitiatedTelemetry;
            public static toObject(message: POGOProtos.Rpc.AccountDeletionInitiatedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAcknowledgePunishmentOutProto {
            result?: (POGOProtos.Rpc.AcknowledgePunishmentOutProto.Result|null);
        }

        class AcknowledgePunishmentOutProto implements IAcknowledgePunishmentOutProto {
            constructor(properties?: POGOProtos.Rpc.IAcknowledgePunishmentOutProto);
            public result: POGOProtos.Rpc.AcknowledgePunishmentOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IAcknowledgePunishmentOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcknowledgePunishmentOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcknowledgePunishmentOutProto;
            public static toObject(message: POGOProtos.Rpc.AcknowledgePunishmentOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AcknowledgePunishmentOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IAcknowledgePunishmentProto {
            is_warn?: (boolean|null);
            is_suspended?: (boolean|null);
        }

        class AcknowledgePunishmentProto implements IAcknowledgePunishmentProto {
            constructor(properties?: POGOProtos.Rpc.IAcknowledgePunishmentProto);
            public is_warn: boolean;
            public is_suspended: boolean;
            public static encode(message: POGOProtos.Rpc.IAcknowledgePunishmentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcknowledgePunishmentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcknowledgePunishmentProto;
            public static toObject(message: POGOProtos.Rpc.AcknowledgePunishmentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAcknowledgeViewLatestIncenseRecapOutProto {
            result?: (POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapOutProto.Result|null);
        }

        class AcknowledgeViewLatestIncenseRecapOutProto implements IAcknowledgeViewLatestIncenseRecapOutProto {
            constructor(properties?: POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapOutProto);
            public result: POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapOutProto;
            public static toObject(message: POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AcknowledgeViewLatestIncenseRecapOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_RECAP_ALREADY_ACKNOWLEDGED = 2,
                ERROR_FEATURE_DISABLED = 3,
                ERROR_NO_LOG_TODAY = 4,
                ERROR_ACTIVE_INCENSE = 5
            }
        }

        interface IAcknowledgeViewLatestIncenseRecapProto {
        }

        class AcknowledgeViewLatestIncenseRecapProto implements IAcknowledgeViewLatestIncenseRecapProto {
            constructor(properties?: POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapProto);
            public static encode(message: POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapProto;
            public static toObject(message: POGOProtos.Rpc.AcknowledgeViewLatestIncenseRecapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAcknowledgeWarningsRequestProto {
            warning?: (POGOProtos.Rpc.PlatformWarningType[]|null);
        }

        class AcknowledgeWarningsRequestProto implements IAcknowledgeWarningsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IAcknowledgeWarningsRequestProto);
            public warning: POGOProtos.Rpc.PlatformWarningType[];
            public static encode(message: POGOProtos.Rpc.IAcknowledgeWarningsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcknowledgeWarningsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcknowledgeWarningsRequestProto;
            public static toObject(message: POGOProtos.Rpc.AcknowledgeWarningsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAcknowledgeWarningsResponseProto {
            success?: (boolean|null);
        }

        class AcknowledgeWarningsResponseProto implements IAcknowledgeWarningsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IAcknowledgeWarningsResponseProto);
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.IAcknowledgeWarningsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AcknowledgeWarningsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AcknowledgeWarningsResponseProto;
            public static toObject(message: POGOProtos.Rpc.AcknowledgeWarningsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IActionLogEntry {
            catch_pokemon?: (POGOProtos.Rpc.ICatchPokemonLogEntry|null);
            fort_search?: (POGOProtos.Rpc.IFortSearchLogEntry|null);
            buddy_pokemon?: (POGOProtos.Rpc.IBuddyPokemonLogEntry|null);
            raid_rewards?: (POGOProtos.Rpc.IRaidRewardsLogEntry|null);
            passcode_rewards?: (POGOProtos.Rpc.IPasscodeRewardsLogEntry|null);
            complete_quest?: (POGOProtos.Rpc.ICompleteQuestLogEntry|null);
            complete_quest_stamp_card?: (POGOProtos.Rpc.ICompleteQuestStampCardLogEntry|null);
            complete_quest_pokemon_encounter?: (POGOProtos.Rpc.ICompleteQuestPokemonEncounterLogEntry|null);
            beluga_transfer?: (POGOProtos.Rpc.IBelugaDailyTransferLogEntry|null);
            open_gift?: (POGOProtos.Rpc.IOpenGiftLogEntry|null);
            send_gift?: (POGOProtos.Rpc.ISendGiftLogEntry|null);
            trading?: (POGOProtos.Rpc.ITradingLogEntry|null);
            fitness_rewards?: (POGOProtos.Rpc.IFitnessRewardsLogEntry|null);
            combat?: (POGOProtos.Rpc.ICombatLogEntry|null);
            purify_pokemon?: (POGOProtos.Rpc.IPurifyPokemonLogEntry|null);
            invasion_victory?: (POGOProtos.Rpc.IInvasionVictoryLogEntry|null);
            vs_seeker_set?: (POGOProtos.Rpc.IVsSeekerSetLogEntry|null);
            vs_seeker_complete_season?: (POGOProtos.Rpc.IVsSeekerCompleteSeasonLogEntry|null);
            vs_seeker_win_rewards?: (POGOProtos.Rpc.IVsSeekerWinRewardsLogEntry|null);
            buddy_consumables?: (POGOProtos.Rpc.IBuddyConsumablesLogEntry|null);
            complete_referral_milestone?: (POGOProtos.Rpc.ICompleteReferralMilestoneLogEntry|null);
            daily_adventure_incense?: (POGOProtos.Rpc.IDailyAdventureIncenseLogEntry|null);
            complete_route_play?: (POGOProtos.Rpc.ICompleteRoutePlayLogEntry|null);
            butterfly_collector_rewards?: (POGOProtos.Rpc.IButterflyCollectorRewardsLogEntry|null);
            webstore_rewards?: (POGOProtos.Rpc.IWebstoreRewardsLogEntry|null);
            use_non_combat_move?: (POGOProtos.Rpc.IUseNonCombatMoveLogEntry|null);
            consume_stickers?: (POGOProtos.Rpc.IConsumeStickersLogEntry|null);
            loot_station?: (POGOProtos.Rpc.ILootStationLogEntry|null);
            iris_social_interaction?: (POGOProtos.Rpc.IIrisSocialInteractionLogEntry|null);
            bread_battle_rewards?: (POGOProtos.Rpc.IBreadBattleRewardsLogEntry|null);
            bread_battle_upgrade_rewards?: (POGOProtos.Rpc.IBreadBattleUpgradeRewardsLogEntry|null);
            event_pass_update?: (POGOProtos.Rpc.IEventPassUpdateLogEntry|null);
            claim_event_pass_rewards?: (POGOProtos.Rpc.IClaimEventPassRewardsLogEntry|null);
            stamp_collection_rewards?: (POGOProtos.Rpc.IStampCollectionRewardsLogEntry|null);
            stamp_collection_progress?: (POGOProtos.Rpc.IStampCollectionProgressLogEntry|null);
            tappable_rewards?: (POGOProtos.Rpc.IProcessTappableLogEntry|null);
            timestamp_ms?: (number|Long|null);
            sfida?: (boolean|null);
        }

        class ActionLogEntry implements IActionLogEntry {
            constructor(properties?: POGOProtos.Rpc.IActionLogEntry);
            public catch_pokemon?: (POGOProtos.Rpc.ICatchPokemonLogEntry|null);
            public fort_search?: (POGOProtos.Rpc.IFortSearchLogEntry|null);
            public buddy_pokemon?: (POGOProtos.Rpc.IBuddyPokemonLogEntry|null);
            public raid_rewards?: (POGOProtos.Rpc.IRaidRewardsLogEntry|null);
            public passcode_rewards?: (POGOProtos.Rpc.IPasscodeRewardsLogEntry|null);
            public complete_quest?: (POGOProtos.Rpc.ICompleteQuestLogEntry|null);
            public complete_quest_stamp_card?: (POGOProtos.Rpc.ICompleteQuestStampCardLogEntry|null);
            public complete_quest_pokemon_encounter?: (POGOProtos.Rpc.ICompleteQuestPokemonEncounterLogEntry|null);
            public beluga_transfer?: (POGOProtos.Rpc.IBelugaDailyTransferLogEntry|null);
            public open_gift?: (POGOProtos.Rpc.IOpenGiftLogEntry|null);
            public send_gift?: (POGOProtos.Rpc.ISendGiftLogEntry|null);
            public trading?: (POGOProtos.Rpc.ITradingLogEntry|null);
            public fitness_rewards?: (POGOProtos.Rpc.IFitnessRewardsLogEntry|null);
            public combat?: (POGOProtos.Rpc.ICombatLogEntry|null);
            public purify_pokemon?: (POGOProtos.Rpc.IPurifyPokemonLogEntry|null);
            public invasion_victory?: (POGOProtos.Rpc.IInvasionVictoryLogEntry|null);
            public vs_seeker_set?: (POGOProtos.Rpc.IVsSeekerSetLogEntry|null);
            public vs_seeker_complete_season?: (POGOProtos.Rpc.IVsSeekerCompleteSeasonLogEntry|null);
            public vs_seeker_win_rewards?: (POGOProtos.Rpc.IVsSeekerWinRewardsLogEntry|null);
            public buddy_consumables?: (POGOProtos.Rpc.IBuddyConsumablesLogEntry|null);
            public complete_referral_milestone?: (POGOProtos.Rpc.ICompleteReferralMilestoneLogEntry|null);
            public daily_adventure_incense?: (POGOProtos.Rpc.IDailyAdventureIncenseLogEntry|null);
            public complete_route_play?: (POGOProtos.Rpc.ICompleteRoutePlayLogEntry|null);
            public butterfly_collector_rewards?: (POGOProtos.Rpc.IButterflyCollectorRewardsLogEntry|null);
            public webstore_rewards?: (POGOProtos.Rpc.IWebstoreRewardsLogEntry|null);
            public use_non_combat_move?: (POGOProtos.Rpc.IUseNonCombatMoveLogEntry|null);
            public consume_stickers?: (POGOProtos.Rpc.IConsumeStickersLogEntry|null);
            public loot_station?: (POGOProtos.Rpc.ILootStationLogEntry|null);
            public iris_social_interaction?: (POGOProtos.Rpc.IIrisSocialInteractionLogEntry|null);
            public bread_battle_rewards?: (POGOProtos.Rpc.IBreadBattleRewardsLogEntry|null);
            public bread_battle_upgrade_rewards?: (POGOProtos.Rpc.IBreadBattleUpgradeRewardsLogEntry|null);
            public event_pass_update?: (POGOProtos.Rpc.IEventPassUpdateLogEntry|null);
            public claim_event_pass_rewards?: (POGOProtos.Rpc.IClaimEventPassRewardsLogEntry|null);
            public stamp_collection_rewards?: (POGOProtos.Rpc.IStampCollectionRewardsLogEntry|null);
            public stamp_collection_progress?: (POGOProtos.Rpc.IStampCollectionProgressLogEntry|null);
            public tappable_rewards?: (POGOProtos.Rpc.IProcessTappableLogEntry|null);
            public timestamp_ms: (number|Long);
            public sfida: boolean;
            public Action?: ("catch_pokemon"|"fort_search"|"buddy_pokemon"|"raid_rewards"|"passcode_rewards"|"complete_quest"|"complete_quest_stamp_card"|"complete_quest_pokemon_encounter"|"beluga_transfer"|"open_gift"|"send_gift"|"trading"|"fitness_rewards"|"combat"|"purify_pokemon"|"invasion_victory"|"vs_seeker_set"|"vs_seeker_complete_season"|"vs_seeker_win_rewards"|"buddy_consumables"|"complete_referral_milestone"|"daily_adventure_incense"|"complete_route_play"|"butterfly_collector_rewards"|"webstore_rewards"|"use_non_combat_move"|"consume_stickers"|"loot_station"|"iris_social_interaction"|"bread_battle_rewards"|"bread_battle_upgrade_rewards"|"event_pass_update"|"claim_event_pass_rewards"|"stamp_collection_rewards"|"stamp_collection_progress"|"tappable_rewards");
            public static encode(message: POGOProtos.Rpc.IActionLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActionLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActionLogEntry;
            public static toObject(message: POGOProtos.Rpc.ActionLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IActivateVsSeekerOutProto {
            result?: (POGOProtos.Rpc.ActivateVsSeekerOutProto.Result|null);
            vs_seeker?: (POGOProtos.Rpc.IVsSeekerAttributesProto|null);
        }

        class ActivateVsSeekerOutProto implements IActivateVsSeekerOutProto {
            constructor(properties?: POGOProtos.Rpc.IActivateVsSeekerOutProto);
            public result: POGOProtos.Rpc.ActivateVsSeekerOutProto.Result;
            public vs_seeker?: (POGOProtos.Rpc.IVsSeekerAttributesProto|null);
            public static encode(message: POGOProtos.Rpc.IActivateVsSeekerOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivateVsSeekerOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivateVsSeekerOutProto;
            public static toObject(message: POGOProtos.Rpc.ActivateVsSeekerOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ActivateVsSeekerOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS_ACTIVATED = 1,
                ERROR_NO_PREMIUM_BATTLE_PASS = 2,
                ERROR_VS_SEEKER_NOT_CHARGED = 3,
                ERROR_VS_SEEKER_ALREADY_ACTIVATED = 4,
                ERROR_EXCEEDED_LIMIT = 5,
                ERROR_TEMPORARILY_UNAVAILABLE = 6
            }
        }

        interface IActivateVsSeekerProto {
            reward_track?: (POGOProtos.Rpc.VsSeekerRewardTrack|null);
        }

        class ActivateVsSeekerProto implements IActivateVsSeekerProto {
            constructor(properties?: POGOProtos.Rpc.IActivateVsSeekerProto);
            public reward_track: POGOProtos.Rpc.VsSeekerRewardTrack;
            public static encode(message: POGOProtos.Rpc.IActivateVsSeekerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivateVsSeekerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivateVsSeekerProto;
            public static toObject(message: POGOProtos.Rpc.ActivateVsSeekerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IActivePokemonTrainingProto {
            training_pokemon?: (POGOProtos.Rpc.ITrainingPokemonProto[]|null);
        }

        class ActivePokemonTrainingProto implements IActivePokemonTrainingProto {
            constructor(properties?: POGOProtos.Rpc.IActivePokemonTrainingProto);
            public training_pokemon: POGOProtos.Rpc.ITrainingPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IActivePokemonTrainingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivePokemonTrainingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivePokemonTrainingProto;
            public static toObject(message: POGOProtos.Rpc.ActivePokemonTrainingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IActivityPostcardData {
            sender_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            sender_buddy_data?: (POGOProtos.Rpc.ActivityPostcardData.IBuddyData|null);
            sender_fort_data?: (POGOProtos.Rpc.ActivityPostcardData.IFortData|null);
        }

        class ActivityPostcardData implements IActivityPostcardData {
            constructor(properties?: POGOProtos.Rpc.IActivityPostcardData);
            public sender_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public sender_buddy_data?: (POGOProtos.Rpc.ActivityPostcardData.IBuddyData|null);
            public sender_fort_data?: (POGOProtos.Rpc.ActivityPostcardData.IFortData|null);
            public static encode(message: POGOProtos.Rpc.IActivityPostcardData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivityPostcardData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivityPostcardData;
            public static toObject(message: POGOProtos.Rpc.ActivityPostcardData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ActivityPostcardData {

            interface IBuddyData {
                pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                buddy_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                nickname?: (string|null);
                buddy_candy_awarded?: (number|null);
            }

            class BuddyData implements IBuddyData {
                constructor(properties?: POGOProtos.Rpc.ActivityPostcardData.IBuddyData);
                public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
                public buddy_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public nickname: string;
                public buddy_candy_awarded: number;
                public static encode(message: POGOProtos.Rpc.ActivityPostcardData.IBuddyData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivityPostcardData.BuddyData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivityPostcardData.BuddyData;
                public static toObject(message: POGOProtos.Rpc.ActivityPostcardData.BuddyData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFortData {
                id?: (string|null);
                name?: (string|null);
                description?: (string|null);
                image_url?: (string|null);
                lat_degrees?: (number|null);
                lng_degrees?: (number|null);
            }

            class FortData implements IFortData {
                constructor(properties?: POGOProtos.Rpc.ActivityPostcardData.IFortData);
                public id: string;
                public name: string;
                public description: string;
                public image_url: string;
                public lat_degrees: number;
                public lng_degrees: number;
                public static encode(message: POGOProtos.Rpc.ActivityPostcardData.IFortData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivityPostcardData.FortData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivityPostcardData.FortData;
                public static toObject(message: POGOProtos.Rpc.ActivityPostcardData.FortData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IActivitySharingPreferencesProto {
            hide_raid_status?: (boolean|null);
        }

        class ActivitySharingPreferencesProto implements IActivitySharingPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.IActivitySharingPreferencesProto);
            public hide_raid_status: boolean;
            public static encode(message: POGOProtos.Rpc.IActivitySharingPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ActivitySharingPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ActivitySharingPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.ActivitySharingPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdDetails {
            image_text_creative?: (POGOProtos.Rpc.IImageTextCreativeProto|null);
            encrypted_ad_token?: (Uint8Array|null);
            impression_tracking_tag?: (POGOProtos.Rpc.IImpressionTrackingTag[]|null);
            gam_details?: (POGOProtos.Rpc.IGamDetails|null);
        }

        class AdDetails implements IAdDetails {
            constructor(properties?: POGOProtos.Rpc.IAdDetails);
            public image_text_creative?: (POGOProtos.Rpc.IImageTextCreativeProto|null);
            public encrypted_ad_token: Uint8Array;
            public impression_tracking_tag: POGOProtos.Rpc.IImpressionTrackingTag[];
            public gam_details?: (POGOProtos.Rpc.IGamDetails|null);
            public static encode(message: POGOProtos.Rpc.IAdDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdDetails;
            public static toObject(message: POGOProtos.Rpc.AdDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdFeedbackSettingsProto {
            enabled?: (boolean|null);
            enable_report_ad?: (boolean|null);
            enable_not_interested?: (boolean|null);
            enable_see_more?: (boolean|null);
        }

        class AdFeedbackSettingsProto implements IAdFeedbackSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAdFeedbackSettingsProto);
            public enabled: boolean;
            public enable_report_ad: boolean;
            public enable_not_interested: boolean;
            public enable_see_more: boolean;
            public static encode(message: POGOProtos.Rpc.IAdFeedbackSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdFeedbackSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdFeedbackSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AdFeedbackSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdProto {
            ad_details?: (POGOProtos.Rpc.IAdDetails|null);
            ad_response_status?: (POGOProtos.Rpc.AdResponseStatus|null);
        }

        class AdProto implements IAdProto {
            constructor(properties?: POGOProtos.Rpc.IAdProto);
            public ad_details?: (POGOProtos.Rpc.IAdDetails|null);
            public ad_response_status: POGOProtos.Rpc.AdResponseStatus;
            public static encode(message: POGOProtos.Rpc.IAdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdProto;
            public static toObject(message: POGOProtos.Rpc.AdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdRequestDeviceInfo {
            operating_system?: (POGOProtos.Rpc.AdRequestDeviceInfo.OperatingSystem|null);
            device_model?: (string|null);
            carrier?: (string|null);
            operating_system_version?: (string|null);
            system_memory_size_mb?: (number|null);
            graphics_memory_size_mb?: (number|null);
            camera_permission_granted?: (boolean|null);
        }

        class AdRequestDeviceInfo implements IAdRequestDeviceInfo {
            constructor(properties?: POGOProtos.Rpc.IAdRequestDeviceInfo);
            public operating_system: POGOProtos.Rpc.AdRequestDeviceInfo.OperatingSystem;
            public device_model: string;
            public carrier: string;
            public operating_system_version: string;
            public system_memory_size_mb: number;
            public graphics_memory_size_mb: number;
            public camera_permission_granted: boolean;
            public static encode(message: POGOProtos.Rpc.IAdRequestDeviceInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdRequestDeviceInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdRequestDeviceInfo;
            public static toObject(message: POGOProtos.Rpc.AdRequestDeviceInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AdRequestDeviceInfo {

            enum OperatingSystem {
                PLATFORM_UNKNOWN = 0,
                PLATFORM_ANDROID = 1,
                PLATFORM_IOS = 2
            }
        }

        interface IAdTargetingInfoProto {
            device_info?: (POGOProtos.Rpc.IAdRequestDeviceInfo|null);
            avatar_gender?: (POGOProtos.Rpc.AvatarGender|null);
        }

        class AdTargetingInfoProto implements IAdTargetingInfoProto {
            constructor(properties?: POGOProtos.Rpc.IAdTargetingInfoProto);
            public device_info?: (POGOProtos.Rpc.IAdRequestDeviceInfo|null);
            public avatar_gender: POGOProtos.Rpc.AvatarGender;
            public static encode(message: POGOProtos.Rpc.IAdTargetingInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdTargetingInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdTargetingInfoProto;
            public static toObject(message: POGOProtos.Rpc.AdTargetingInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddFortModifierOutProto {
            result?: (POGOProtos.Rpc.AddFortModifierOutProto.Result|null);
            fort_details_out_proto?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
        }

        class AddFortModifierOutProto implements IAddFortModifierOutProto {
            constructor(properties?: POGOProtos.Rpc.IAddFortModifierOutProto);
            public result: POGOProtos.Rpc.AddFortModifierOutProto.Result;
            public fort_details_out_proto?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
            public static encode(message: POGOProtos.Rpc.IAddFortModifierOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddFortModifierOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddFortModifierOutProto;
            public static toObject(message: POGOProtos.Rpc.AddFortModifierOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AddFortModifierOutProto {

            enum Result {
                NO_RESULT_SET = 0,
                SUCCESS = 1,
                FORT_ALREADY_HAS_MODIFIER = 2,
                TOO_FAR_AWAY = 3,
                NO_ITEM_IN_INVENTORY = 4,
                POI_INACCESSIBLE = 5
            }
        }

        interface IAddFortModifierProto {
            modifier_type?: (POGOProtos.Rpc.Item|null);
            fort_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class AddFortModifierProto implements IAddFortModifierProto {
            constructor(properties?: POGOProtos.Rpc.IAddFortModifierProto);
            public modifier_type: POGOProtos.Rpc.Item;
            public fort_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IAddFortModifierProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddFortModifierProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddFortModifierProto;
            public static toObject(message: POGOProtos.Rpc.AddFortModifierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddFriendQuestProto {
            added_friend_ids?: (string[]|null);
        }

        class AddFriendQuestProto implements IAddFriendQuestProto {
            constructor(properties?: POGOProtos.Rpc.IAddFriendQuestProto);
            public added_friend_ids: string[];
            public static encode(message: POGOProtos.Rpc.IAddFriendQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddFriendQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddFriendQuestProto;
            public static toObject(message: POGOProtos.Rpc.AddFriendQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
            status?: (POGOProtos.Rpc.AddLoginActionOutProto.Status|null);
        }

        class AddLoginActionOutProto implements IAddLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IAddLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public status: POGOProtos.Rpc.AddLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IAddLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.AddLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AddLoginActionOutProto {

            enum Status {
                UNSET = 0,
                AUTH_FAILURE = 1,
                LOGIN_TAKEN = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IAddLoginActionProto {
            identity_provider?: (POGOProtos.Rpc.AuthIdentityProvider|null);
            inner_message?: (Uint8Array|null);
            auth_provider_id?: (string|null);
        }

        class AddLoginActionProto implements IAddLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IAddLoginActionProto);
            public identity_provider: POGOProtos.Rpc.AuthIdentityProvider;
            public inner_message: Uint8Array;
            public auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IAddLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.AddLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddPtcLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
            status?: (POGOProtos.Rpc.AddPtcLoginActionOutProto.Status|null);
        }

        class AddPtcLoginActionOutProto implements IAddPtcLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IAddPtcLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public status: POGOProtos.Rpc.AddPtcLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IAddPtcLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddPtcLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddPtcLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.AddPtcLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AddPtcLoginActionOutProto {

            enum Status {
                UNSET = 0,
                AUTH_FAILURE = 1,
                LOGIN_TAKEN = 2,
                ADULT_LINK_TO_CHILD_ERROR = 3,
                LINKING_NOT_ENABLED = 4,
                LIST_ACCOUNT_LOGIN_ERROR = 5,
                OTHER_ERRORS = 6
            }
        }

        interface IAddPtcLoginActionProto {
            auth_provider_id?: (string|null);
            inner_message?: (Uint8Array|null);
        }

        class AddPtcLoginActionProto implements IAddPtcLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IAddPtcLoginActionProto);
            public auth_provider_id: string;
            public inner_message: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAddPtcLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddPtcLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddPtcLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.AddPtcLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddReferrerOutProto {
            status?: (POGOProtos.Rpc.AddReferrerOutProto.Status|null);
        }

        class AddReferrerOutProto implements IAddReferrerOutProto {
            constructor(properties?: POGOProtos.Rpc.IAddReferrerOutProto);
            public status: POGOProtos.Rpc.AddReferrerOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IAddReferrerOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddReferrerOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddReferrerOutProto;
            public static toObject(message: POGOProtos.Rpc.AddReferrerOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AddReferrerOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2,
                ERROR_INVALID_REFERRAL_CODE = 3,
                ERROR_ALREADY_ADDED = 4,
                ERROR_PASSED_GRACE_PERIOD = 5,
                ERROR_ALREADY_SKIPPED_ENTERING_REFERRAL_CODE = 6
            }
        }

        interface IAddReferrerProto {
            referrer_code?: (string|null);
        }

        class AddReferrerProto implements IAddReferrerProto {
            constructor(properties?: POGOProtos.Rpc.IAddReferrerProto);
            public referrer_code: string;
            public static encode(message: POGOProtos.Rpc.IAddReferrerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddReferrerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddReferrerProto;
            public static toObject(message: POGOProtos.Rpc.AddReferrerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdditiveSceneSettingsProto {
            enabled?: (boolean|null);
        }

        class AdditiveSceneSettingsProto implements IAdditiveSceneSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAdditiveSceneSettingsProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAdditiveSceneSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdditiveSceneSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdditiveSceneSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AdditiveSceneSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddressBookImportSettingsProto {
            is_enabled?: (boolean|null);
            onboarding_screen_level?: (number|null);
            show_opt_out_checkbox?: (boolean|null);
            reprompt_onboarding_for_v1?: (boolean|null);
        }

        class AddressBookImportSettingsProto implements IAddressBookImportSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAddressBookImportSettingsProto);
            public is_enabled: boolean;
            public onboarding_screen_level: number;
            public show_opt_out_checkbox: boolean;
            public reprompt_onboarding_for_v1: boolean;
            public static encode(message: POGOProtos.Rpc.IAddressBookImportSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddressBookImportSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddressBookImportSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AddressBookImportSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddressBookImportTelemetry {
            abi_telemetry_id?: (POGOProtos.Rpc.AddressBookImportTelemetry.AddressBookImportTelemetryId|null);
        }

        class AddressBookImportTelemetry implements IAddressBookImportTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAddressBookImportTelemetry);
            public abi_telemetry_id: POGOProtos.Rpc.AddressBookImportTelemetry.AddressBookImportTelemetryId;
            public static encode(message: POGOProtos.Rpc.IAddressBookImportTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddressBookImportTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddressBookImportTelemetry;
            public static toObject(message: POGOProtos.Rpc.AddressBookImportTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AddressBookImportTelemetry {

            enum AddressBookImportTelemetryId {
                UNDEFINED = 0,
                SEE_PGO_NEW_PLAYER_ONBOARDING_SCREEN = 1,
                CLICK_IMPORT_CONTACTS_BUTTON = 2,
                OPEN_ADDRESS_BOOK_IMPORT_FROM_PGO_ONBOARDING = 3,
                DISMISS_PGO_ONBOARDING = 4
            }
        }

        interface IAddressablePokemonProto {
            catalog_id?: (number|null);
            addressable_pokemon_ids?: (POGOProtos.Rpc.HoloPokemonId[]|null);
        }

        class AddressablePokemonProto implements IAddressablePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IAddressablePokemonProto);
            public catalog_id: number;
            public addressable_pokemon_ids: POGOProtos.Rpc.HoloPokemonId[];
            public static encode(message: POGOProtos.Rpc.IAddressablePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddressablePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddressablePokemonProto;
            public static toObject(message: POGOProtos.Rpc.AddressablePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAddressablesServiceTime {
            key?: (string|null);
            duration_ms?: (number|null);
        }

        class AddressablesServiceTime implements IAddressablesServiceTime {
            constructor(properties?: POGOProtos.Rpc.IAddressablesServiceTime);
            public key: string;
            public duration_ms: number;
            public static encode(message: POGOProtos.Rpc.IAddressablesServiceTime, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AddressablesServiceTime;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AddressablesServiceTime;
            public static toObject(message: POGOProtos.Rpc.AddressablesServiceTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdjustmentParamsProto {
            rotation_degrees?: (number|null);
            crop_shape_value?: (number|null);
            crop_bound_proto?: (POGOProtos.Rpc.IARDKBoundingBoxProto|null);
            filter_type?: (number|null);
            filter_intensity?: (number|null);
            exposure?: (number|null);
            contrast?: (number|null);
            sharpness?: (number|null);
        }

        class AdjustmentParamsProto implements IAdjustmentParamsProto {
            constructor(properties?: POGOProtos.Rpc.IAdjustmentParamsProto);
            public rotation_degrees: number;
            public crop_shape_value: number;
            public crop_bound_proto?: (POGOProtos.Rpc.IARDKBoundingBoxProto|null);
            public filter_type: number;
            public filter_intensity: number;
            public exposure: number;
            public contrast: number;
            public sharpness: number;
            public static encode(message: POGOProtos.Rpc.IAdjustmentParamsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdjustmentParamsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdjustmentParamsProto;
            public static toObject(message: POGOProtos.Rpc.AdjustmentParamsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdvancedPerformanceTelemetry {
            performance_preset_level?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformancePresetLevels|null);
            native_refresh_rate_fps?: (boolean|null);
            special_framerate?: (boolean|null);
            improved_sky?: (boolean|null);
            dynamic_gyms?: (boolean|null);
            normal_map_drawing_distance?: (boolean|null);
            normal_fog_distance?: (boolean|null);
            buildings_on_map?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels|null);
            friends_icons_in_list?: (boolean|null);
            avatars_render_texture_size_high?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels|null);
            avatars_render_texture_size_low?: (boolean|null);
            ar_prompt?: (boolean|null);
            render_level?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels|null);
            texture_quality?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels|null);
            download_image_ram_cache?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels|null);
            map_details?: (boolean|null);
            avatar_details?: (boolean|null);
            render_and_texture?: (POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels|null);
        }

        class AdvancedPerformanceTelemetry implements IAdvancedPerformanceTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAdvancedPerformanceTelemetry);
            public performance_preset_level: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformancePresetLevels;
            public native_refresh_rate_fps: boolean;
            public special_framerate: boolean;
            public improved_sky: boolean;
            public dynamic_gyms: boolean;
            public normal_map_drawing_distance: boolean;
            public normal_fog_distance: boolean;
            public buildings_on_map: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels;
            public friends_icons_in_list: boolean;
            public avatars_render_texture_size_high: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels;
            public avatars_render_texture_size_low: boolean;
            public ar_prompt: boolean;
            public render_level: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels;
            public texture_quality: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels;
            public download_image_ram_cache: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels;
            public map_details: boolean;
            public avatar_details: boolean;
            public render_and_texture: POGOProtos.Rpc.AdvancedPerformanceTelemetry.PerformanceLevels;
            public static encode(message: POGOProtos.Rpc.IAdvancedPerformanceTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdvancedPerformanceTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdvancedPerformanceTelemetry;
            public static toObject(message: POGOProtos.Rpc.AdvancedPerformanceTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AdvancedPerformanceTelemetry {

            enum PerformanceLevels {
                UNSET = 0,
                LOW = 1,
                MEDIUM = 2,
                HIGH = 3
            }

            enum PerformancePresetLevels {
                UNSET_PRESET = 0,
                LOW_PRESET = 1,
                MEDIUM_PRESET = 2,
                HIGH_PRESET = 3,
                MAX_PRESET = 4,
                CUSTOM_PRESET = 5
            }
        }

        interface IAdvancedSettingsProto {
            advanced_settings_version?: (number|null);
            unity_cache_size_max_megabytes?: (number[]|null);
            stored_data_size_max_megabytes?: (number[]|null);
            disk_cache_size_max_megabytes?: (number[]|null);
            image_ram_cache_size_max_megabytes?: (number[]|null);
            download_all_assets_enabled?: (boolean|null);
            http3_enabled?: (boolean|null);
            base_framerate?: (number|null);
            default_unlock_framerate?: (boolean|null);
            real_time_dynamics_enabled?: (boolean|null);
            max_device_memory_for_high_quality_mode_mb?: (number|null);
            max_device_memory_for_standard_quality_mode_mb?: (number|null);
        }

        class AdvancedSettingsProto implements IAdvancedSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAdvancedSettingsProto);
            public advanced_settings_version: number;
            public unity_cache_size_max_megabytes: number[];
            public stored_data_size_max_megabytes: number[];
            public disk_cache_size_max_megabytes: number[];
            public image_ram_cache_size_max_megabytes: number[];
            public download_all_assets_enabled: boolean;
            public http3_enabled: boolean;
            public base_framerate: number;
            public default_unlock_framerate: boolean;
            public real_time_dynamics_enabled: boolean;
            public max_device_memory_for_high_quality_mode_mb: number;
            public max_device_memory_for_standard_quality_mode_mb: number;
            public static encode(message: POGOProtos.Rpc.IAdvancedSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdvancedSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdvancedSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AdvancedSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdventureSyncActivitySummaryProto {
            weekly_walk_distance_km_progress?: (number|null);
            weekly_walk_distance_km_goals?: (number[]|null);
            egg_progress?: (POGOProtos.Rpc.IAdventureSyncEggHatchingProgress|null);
            buddy_stats_proto?: (POGOProtos.Rpc.IAdventureSyncBuddyStatsProto|null);
        }

        class AdventureSyncActivitySummaryProto implements IAdventureSyncActivitySummaryProto {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncActivitySummaryProto);
            public weekly_walk_distance_km_progress: number;
            public weekly_walk_distance_km_goals: number[];
            public egg_progress?: (POGOProtos.Rpc.IAdventureSyncEggHatchingProgress|null);
            public buddy_stats_proto?: (POGOProtos.Rpc.IAdventureSyncBuddyStatsProto|null);
            public static encode(message: POGOProtos.Rpc.IAdventureSyncActivitySummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncActivitySummaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncActivitySummaryProto;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncActivitySummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdventureSyncBuddyStatsProto {
            affection_km_in_progress?: (number|null);
            affection_km_total?: (number|null);
            buddy_shown_heart_types?: (POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType[]|null);
            emotion_level?: (POGOProtos.Rpc.BuddyEmotionLevel|null);
            last_reached_full_ms?: (number|Long|null);
            map_expiration_ms?: (number|Long|null);
            has_gift?: (boolean|null);
        }

        class AdventureSyncBuddyStatsProto implements IAdventureSyncBuddyStatsProto {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncBuddyStatsProto);
            public affection_km_in_progress: number;
            public affection_km_total: number;
            public buddy_shown_heart_types: POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType[];
            public emotion_level: POGOProtos.Rpc.BuddyEmotionLevel;
            public last_reached_full_ms: (number|Long);
            public map_expiration_ms: (number|Long);
            public has_gift: boolean;
            public static encode(message: POGOProtos.Rpc.IAdventureSyncBuddyStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncBuddyStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncBuddyStatsProto;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncBuddyStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdventureSyncEggHatchingProgress {
            status?: (POGOProtos.Rpc.AdventureSyncEggHatchingProgress.Status|null);
            egg_distance_km?: (number|null);
            current_distance_km?: (number|null);
            incubator?: (POGOProtos.Rpc.AdventureSyncEggHatchingProgress.IncubatorType|null);
            original_egg_distance_km?: (number|null);
        }

        class AdventureSyncEggHatchingProgress implements IAdventureSyncEggHatchingProgress {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncEggHatchingProgress);
            public status: POGOProtos.Rpc.AdventureSyncEggHatchingProgress.Status;
            public egg_distance_km: number;
            public current_distance_km: number;
            public incubator: POGOProtos.Rpc.AdventureSyncEggHatchingProgress.IncubatorType;
            public original_egg_distance_km: number;
            public static encode(message: POGOProtos.Rpc.IAdventureSyncEggHatchingProgress, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncEggHatchingProgress;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncEggHatchingProgress;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncEggHatchingProgress, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AdventureSyncEggHatchingProgress {

            enum IncubatorType {
                UNKNOWN = 0,
                UNLIMITED = 901,
                BASIC = 902,
                SUPER = 903
            }

            enum Status {
                UNSET = 0,
                HATCHING = 1,
                NOT_HATCHING = 2,
                HATCHED = 3
            }
        }

        interface IAdventureSyncEggIncubatorsProto {
            eggs_progress?: (POGOProtos.Rpc.IAdventureSyncEggHatchingProgress[]|null);
        }

        class AdventureSyncEggIncubatorsProto implements IAdventureSyncEggIncubatorsProto {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncEggIncubatorsProto);
            public eggs_progress: POGOProtos.Rpc.IAdventureSyncEggHatchingProgress[];
            public static encode(message: POGOProtos.Rpc.IAdventureSyncEggIncubatorsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncEggIncubatorsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncEggIncubatorsProto;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncEggIncubatorsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdventureSyncProgress {
            notification_selector?: (number|null);
            parameters?: (string[]|null);
            serialized_data?: (Uint8Array|null);
        }

        class AdventureSyncProgress implements IAdventureSyncProgress {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncProgress);
            public notification_selector: number;
            public parameters: string[];
            public serialized_data: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAdventureSyncProgress, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncProgress;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncProgress;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncProgress, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdventureSyncProgressRequest {
            widget_types?: (POGOProtos.Rpc.AdventureSyncProgressRequest.WidgetType[]|null);
        }

        class AdventureSyncProgressRequest implements IAdventureSyncProgressRequest {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncProgressRequest);
            public widget_types: POGOProtos.Rpc.AdventureSyncProgressRequest.WidgetType[];
            public static encode(message: POGOProtos.Rpc.IAdventureSyncProgressRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncProgressRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncProgressRequest;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncProgressRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AdventureSyncProgressRequest {

            enum WidgetType {
                UNSET = 0,
                EGG_INCUBATORS = 1,
                BUDDY_STATS = 2,
                ACTIVITY_SUMMARY = 3,
                DAILY_STREAKS = 4
            }
        }

        interface IAdventureSyncProgressResponse {
            egg_incubators_proto?: (POGOProtos.Rpc.IAdventureSyncEggIncubatorsProto|null);
            buddy_stats_proto?: (POGOProtos.Rpc.IAdventureSyncBuddyStatsProto|null);
            activity_summary_proto?: (POGOProtos.Rpc.IAdventureSyncActivitySummaryProto|null);
            daily_streaks_proto?: (POGOProtos.Rpc.IDailyStreaksWidgetProto|null);
        }

        class AdventureSyncProgressResponse implements IAdventureSyncProgressResponse {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncProgressResponse);
            public egg_incubators_proto?: (POGOProtos.Rpc.IAdventureSyncEggIncubatorsProto|null);
            public buddy_stats_proto?: (POGOProtos.Rpc.IAdventureSyncBuddyStatsProto|null);
            public activity_summary_proto?: (POGOProtos.Rpc.IAdventureSyncActivitySummaryProto|null);
            public daily_streaks_proto?: (POGOProtos.Rpc.IDailyStreaksWidgetProto|null);
            public static encode(message: POGOProtos.Rpc.IAdventureSyncProgressResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncProgressResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncProgressResponse;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncProgressResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAdventureSyncSettingsProto {
            fitness_service_enabled?: (boolean|null);
            awareness_service_enabled?: (boolean|null);
            persistent_breadcrumb_service_enabled?: (boolean|null);
            sensor_service_enabled?: (boolean|null);
            persistent_location_service_enabled?: (boolean|null);
            breadcrumb_service_enabled?: (boolean|null);
        }

        class AdventureSyncSettingsProto implements IAdventureSyncSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAdventureSyncSettingsProto);
            public fitness_service_enabled: boolean;
            public awareness_service_enabled: boolean;
            public persistent_breadcrumb_service_enabled: boolean;
            public sensor_service_enabled: boolean;
            public persistent_location_service_enabled: boolean;
            public breadcrumb_service_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAdventureSyncSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AdventureSyncSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AdventureSyncSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AdventureSyncSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAegisEnforcementSettingsProto {
            wayfarer_enforcement_enabled?: (boolean|null);
        }

        class AegisEnforcementSettingsProto implements IAegisEnforcementSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAegisEnforcementSettingsProto);
            public wayfarer_enforcement_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAegisEnforcementSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AegisEnforcementSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AegisEnforcementSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AegisEnforcementSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAgeConfirmationOutProto {
            result?: (POGOProtos.Rpc.AgeConfirmationOutProto.Result|null);
            error_message?: (string|null);
        }

        class AgeConfirmationOutProto implements IAgeConfirmationOutProto {
            constructor(properties?: POGOProtos.Rpc.IAgeConfirmationOutProto);
            public result: POGOProtos.Rpc.AgeConfirmationOutProto.Result;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IAgeConfirmationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AgeConfirmationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AgeConfirmationOutProto;
            public static toObject(message: POGOProtos.Rpc.AgeConfirmationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AgeConfirmationOutProto {

            enum Result {
                UNSET = 0,
                SET_AND_UNBLOCKED = 1,
                SET_AND_BLOCKED = 2,
                ERROR = 3
            }
        }

        interface IAgeConfirmationProto {
            user_date_of_birth?: (string|null);
            is_minor?: (boolean|null);
        }

        class AgeConfirmationProto implements IAgeConfirmationProto {
            constructor(properties?: POGOProtos.Rpc.IAgeConfirmationProto);
            public user_date_of_birth: string;
            public is_minor: boolean;
            public static encode(message: POGOProtos.Rpc.IAgeConfirmationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AgeConfirmationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AgeConfirmationProto;
            public static toObject(message: POGOProtos.Rpc.AgeConfirmationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAgeGateResult {
            method_name?: (string|null);
        }

        class AgeGateResult implements IAgeGateResult {
            constructor(properties?: POGOProtos.Rpc.IAgeGateResult);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IAgeGateResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AgeGateResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AgeGateResult;
            public static toObject(message: POGOProtos.Rpc.AgeGateResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAgeGateStartup {
            method_name?: (string|null);
        }

        class AgeGateStartup implements IAgeGateStartup {
            constructor(properties?: POGOProtos.Rpc.IAgeGateStartup);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IAgeGateStartup, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AgeGateStartup;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AgeGateStartup;
            public static toObject(message: POGOProtos.Rpc.AgeGateStartup, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAgeLevelProto {
        }

        class AgeLevelProto implements IAgeLevelProto {
            constructor(properties?: POGOProtos.Rpc.IAgeLevelProto);
            public static encode(message: POGOProtos.Rpc.IAgeLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AgeLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AgeLevelProto;
            public static toObject(message: POGOProtos.Rpc.AgeLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AgeLevelProto {

            enum AgeLevel {
                UNKNOWN = 0,
                MINOR = 1,
                TEEN = 2,
                ADULT = 3
            }
        }

        interface IAllTypesAndMessagesResponsesProto {
        }

        class AllTypesAndMessagesResponsesProto implements IAllTypesAndMessagesResponsesProto {
            constructor(properties?: POGOProtos.Rpc.IAllTypesAndMessagesResponsesProto);
            public static encode(message: POGOProtos.Rpc.IAllTypesAndMessagesResponsesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto;
            public static toObject(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AllTypesAndMessagesResponsesProto {

            enum AllResquestTypesProto {
                REQUEST_TYPE_UNSET = 0,
                REQUEST_TYPE_METHOD_GET_PLAYER = 2,
                REQUEST_TYPE_METHOD_GET_HOLOHOLO_INVENTORY = 4,
                REQUEST_TYPE_METHOD_DOWNLOAD_SETTINGS = 5,
                REQUEST_TYPE_METHOD_DOWNLOAD_ITEM_TEMPLATES = 6,
                REQUEST_TYPE_METHOD_DOWNLOAD_REMOTE_CONFIG_VERSION = 7,
                REQUEST_TYPE_METHOD_REGISTER_BACKGROUND_DEVICE = 8,
                REQUEST_TYPE_METHOD_GET_PLAYER_DAY = 9,
                REQUEST_TYPE_METHOD_ACKNOWLEDGE_PUNISHMENT = 10,
                REQUEST_TYPE_METHOD_GET_SERVER_TIME = 11,
                REQUEST_TYPE_METHOD_GET_LOCAL_TIME = 12,
                REQUEST_TYPE_METHOD_SET_PLAYER_STATUS = 20,
                REQUEST_TYPE_METHOD_DOWNLOAD_GAME_CONFIG_VERSION = 21,
                REQUEST_TYPE_METHOD_GET_GPS_BOOKMARKS = 22,
                REQUEST_TYPE_METHOD_UPDATE_GPS_BOOKMARKS = 23,
                REQUEST_TYPE_METHOD_FORT_SEARCH = 101,
                REQUEST_TYPE_METHOD_ENCOUNTER = 102,
                REQUEST_TYPE_METHOD_CATCH_POKEMON = 103,
                REQUEST_TYPE_METHOD_FORT_DETAILS = 104,
                REQUEST_TYPE_METHOD_GET_MAP_OBJECTS = 106,
                REQUEST_TYPE_METHOD_FORT_DEPLOY_POKEMON = 110,
                REQUEST_TYPE_METHOD_FORT_RECALL_POKEMON = 111,
                REQUEST_TYPE_METHOD_RELEASE_POKEMON = 112,
                REQUEST_TYPE_METHOD_USE_ITEM_POTION = 113,
                REQUEST_TYPE_METHOD_USE_ITEM_CAPTURE = 114,
                REQUEST_TYPE_METHOD_USE_ITEM_FLEE = 115,
                REQUEST_TYPE_METHOD_USE_ITEM_REVIVE = 116,
                REQUEST_TYPE_METHOD_GET_PLAYER_PROFILE = 121,
                REQUEST_TYPE_METHOD_EVOLVE_POKEMON = 125,
                REQUEST_TYPE_METHOD_GET_HATCHED_EGGS = 126,
                REQUEST_TYPE_METHOD_ENCOUNTER_TUTORIAL_COMPLETE = 127,
                REQUEST_TYPE_METHOD_LEVEL_UP_REWARDS = 128,
                REQUEST_TYPE_METHOD_CHECK_AWARDED_BADGES = 129,
                REQUEST_TYPE_METHOD_RECYCLE_INVENTORY_ITEM = 137,
                REQUEST_TYPE_METHOD_COLLECT_DAILY_BONUS = 138,
                REQUEST_TYPE_METHOD_USE_ITEM_XP_BOOST = 139,
                REQUEST_TYPE_METHOD_USE_ITEM_EGG_INCUBATOR = 140,
                REQUEST_TYPE_METHOD_USE_INCENSE = 141,
                REQUEST_TYPE_METHOD_GET_INCENSE_POKEMON = 142,
                REQUEST_TYPE_METHOD_INCENSE_ENCOUNTER = 143,
                REQUEST_TYPE_METHOD_ADD_FORT_MODIFIER = 144,
                REQUEST_TYPE_METHOD_DISK_ENCOUNTER = 145,
                REQUEST_TYPE_METHOD_UPGRADE_POKEMON = 147,
                REQUEST_TYPE_METHOD_SET_FAVORITE_POKEMON = 148,
                REQUEST_TYPE_METHOD_NICKNAME_POKEMON = 149,
                REQUEST_TYPE_METHOD_EQUIP_BADGE = 150,
                REQUEST_TYPE_METHOD_SET_CONTACT_SETTINGS = 151,
                REQUEST_TYPE_METHOD_SET_BUDDY_POKEMON = 152,
                REQUEST_TYPE_METHOD_GET_BUDDY_WALKED = 153,
                REQUEST_TYPE_METHOD_USE_ITEM_ENCOUNTER = 154,
                REQUEST_TYPE_METHOD_GYM_DEPLOY = 155,
                REQUEST_TYPE_METHOD_GYM_GET_INFO = 156,
                REQUEST_TYPE_METHOD_GYM_START_SESSION = 157,
                REQUEST_TYPE_METHOD_GYM_BATTLE_ATTACK = 158,
                REQUEST_TYPE_METHOD_JOIN_LOBBY = 159,
                REQUEST_TYPE_METHOD_LEAVE_LOBBY = 160,
                REQUEST_TYPE_METHOD_SET_LOBBY_VISIBILITY = 161,
                REQUEST_TYPE_METHOD_SET_LOBBY_POKEMON = 162,
                REQUEST_TYPE_METHOD_GET_RAID_DETAILS = 163,
                REQUEST_TYPE_METHOD_GYM_FEED_POKEMON = 164,
                REQUEST_TYPE_METHOD_START_RAID_BATTLE = 165,
                REQUEST_TYPE_METHOD_ATTACK_RAID = 166,
                REQUEST_TYPE_METHOD_AWARD_POKECOIN = 167,
                REQUEST_TYPE_METHOD_USE_ITEM_STARDUST_BOOST = 168,
                REQUEST_TYPE_METHOD_REASSIGN_PLAYER = 169,
                REQUEST_TYPE_METHOD_REDEEM_POI_PASSCODE = 170,
                REQUEST_TYPE_METHOD_CONVERT_CANDY_TO_XL_CANDY = 171,
                REQUEST_TYPE_METHOD_IS_SKU_AVAILABLE = 172,
                REQUEST_TYPE_METHOD_USE_ITEM_BULK_HEAL = 173,
                REQUEST_TYPE_METHOD_USE_ITEM_BATTLE_BOOST = 174,
                REQUEST_TYPE_METHOD_USE_ITEM_LUCKY_FRIEND_APPLICATOR = 175,
                REQUEST_TYPE_METHOD_USE_ITEM_STAT_INCREASE = 176,
                REQUEST_TYPE_METHOD_GET_ASSET_DIGEST = 300,
                REQUEST_TYPE_METHOD_GET_DOWNLOAD_URLS = 301,
                REQUEST_TYPE_METHOD_GET_ASSET_VERSION = 302,
                REQUEST_TYPE_METHOD_CLAIM_CODENAME = 403,
                REQUEST_TYPE_METHOD_SET_AVATAR = 404,
                REQUEST_TYPE_METHOD_SET_PLAYER_TEAM = 405,
                REQUEST_TYPE_METHOD_MARK_TUTORIAL_COMPLETE = 406,
                REQUEST_TYPE_METHOD_UPDATE_PERFORMANCE_METRICS = 407,
                REQUEST_TYPE_METHOD_SET_NEUTRAL_AVATAR = 408,
                REQUEST_TYPE_METHOD_LIST_AVATAR_STORE_ITEMS = 409,
                REQUEST_TYPE_METHOD_LIST_AVATAR_APPEARANCE_ITEMS = 410,
                REQUEST_TYPE_METHOD_NEUTRAL_AVATAR_BADGE_REWARD = 450,
                REQUEST_TYPE_METHOD_CHECK_CHALLENGE = 600,
                REQUEST_TYPE_METHOD_VERIFY_CHALLENGE = 601,
                REQUEST_TYPE_METHOD_ECHO = 666,
                REQUEST_TYPE_METHOD_SFIDA_REGISTRATION = 800,
                REQUEST_TYPE_METHOD_SFIDA_ACTION_LOG = 801,
                REQUEST_TYPE_METHOD_SFIDA_CERTIFICATION = 802,
                REQUEST_TYPE_METHOD_SFIDA_UPDATE = 803,
                REQUEST_TYPE_METHOD_SFIDA_ACTION = 804,
                REQUEST_TYPE_METHOD_SFIDA_DOWSER = 805,
                REQUEST_TYPE_METHOD_SFIDA_CAPTURE = 806,
                REQUEST_TYPE_METHOD_LIST_AVATAR_CUSTOMIZATIONS = 807,
                REQUEST_TYPE_METHOD_SET_AVATAR_ITEM_AS_VIEWED = 808,
                REQUEST_TYPE_METHOD_GET_INBOX = 809,
                REQUEST_TYPE_METHOD_LIST_GYM_BADGES = 811,
                REQUEST_TYPE_METHOD_GET_GYM_BADGE_DETAILS = 812,
                REQUEST_TYPE_METHOD_USE_ITEM_MOVE_REROLL = 813,
                REQUEST_TYPE_METHOD_USE_ITEM_RARE_CANDY = 814,
                REQUEST_TYPE_METHOD_AWARD_FREE_RAID_TICKET = 815,
                REQUEST_TYPE_METHOD_FETCH_ALL_NEWS = 816,
                REQUEST_TYPE_METHOD_MARK_READ_NEWS_ARTICLE = 817,
                REQUEST_TYPE_METHOD_GET_PLAYER_DISPLAY_INFO = 818,
                REQUEST_TYPE_METHOD_BELUGA_TRANSACTION_START = 819,
                REQUEST_TYPE_METHOD_BELUGA_TRANSACTION_COMPLETE = 820,
                REQUEST_TYPE_METHOD_SFIDA_ASSOCIATE = 822,
                REQUEST_TYPE_METHOD_SFIDA_CHECK_PAIRING = 823,
                REQUEST_TYPE_METHOD_SFIDA_DISASSOCIATE = 824,
                REQUEST_TYPE_METHOD_WAINA_GET_REWARDS = 825,
                REQUEST_TYPE_METHOD_WAINA_SUBMIT_SLEEP_DATA = 826,
                REQUEST_TYPE_METHOD_SATURDAY_TRANSACTION_START = 827,
                REQUEST_TYPE_METHOD_SATURDAY_TRANSACTION_COMPLETE = 828,
                REQUEST_TYPE_METHOD_REIMBURSE_ITEM = 829,
                REQUEST_TYPE_METHOD_LIFT_USER_AGE_CONFIRMATION = 830,
                REQUEST_TYPE_METHOD_GET_NEW_QUESTS = 900,
                REQUEST_TYPE_METHOD_GET_QUEST_DETAILS = 901,
                REQUEST_TYPE_METHOD_COMPLETE_QUEST = 902,
                REQUEST_TYPE_METHOD_REMOVE_QUEST = 903,
                REQUEST_TYPE_METHOD_QUEST_ENCOUNTER = 904,
                REQUEST_TYPE_METHOD_COMPLETE_QUEST_STAMP_CARD = 905,
                REQUEST_TYPE_METHOD_PROGRESS_QUEST = 906,
                REQUEST_TYPE_METHOD_START_QUEST_INCIDENT = 907,
                REQUEST_TYPE_METHOD_READ_QUEST_DIALOG = 908,
                REQUEST_TYPE_METHOD_SEND_GIFT = 950,
                REQUEST_TYPE_METHOD_OPEN_GIFT = 951,
                REQUEST_TYPE_METHOD_GIFT_DETAILS = 952,
                REQUEST_TYPE_METHOD_DELETE_GIFT = 953,
                REQUEST_TYPE_METHOD_SAVE_PLAYER_SNAPSHOT = 954,
                REQUEST_TYPE_METHOD_GET_FRIENDSHIP_MILESTONE_REWARDS = 955,
                REQUEST_TYPE_METHOD_CHECK_SEND_GIFT = 956,
                REQUEST_TYPE_METHOD_SET_FRIEND_NICKNAME = 957,
                REQUEST_TYPE_METHOD_DELETE_GIFT_FROM_INVENTORY = 958,
                REQUEST_TYPE_METHOD_SAVE_SOCIAL_PLAYER_SETTINGS = 959,
                REQUEST_TYPE_METHOD_OPEN_TRADING = 970,
                REQUEST_TYPE_METHOD_UPDATE_TRADING = 971,
                REQUEST_TYPE_METHOD_CONFIRM_TRADING = 972,
                REQUEST_TYPE_METHOD_CANCEL_TRADING = 973,
                REQUEST_TYPE_METHOD_GET_TRADING = 974,
                REQUEST_TYPE_METHOD_GET_FITNESS_REWARDS = 980,
                REQUEST_TYPE_METHOD_GET_COMBAT_PLAYER_PROFILE = 990,
                REQUEST_TYPE_METHOD_GENERATE_COMBAT_CHALLENGE_ID = 991,
                REQUEST_TYPE_METHOD_CREATE_COMBAT_CHALLENGE = 992,
                REQUEST_TYPE_METHOD_OPEN_COMBAT_CHALLENGE = 993,
                REQUEST_TYPE_METHOD_GET_COMBAT_CHALLENGE = 994,
                REQUEST_TYPE_METHOD_ACCEPT_COMBAT_CHALLENGE = 995,
                REQUEST_TYPE_METHOD_DECLINE_COMBAT_CHALLENGE = 996,
                REQUEST_TYPE_METHOD_CANCEL_COMBAT_CHALLENGE = 997,
                REQUEST_TYPE_METHOD_SUBMIT_COMBAT_CHALLENGE_POKEMONS = 998,
                REQUEST_TYPE_METHOD_SAVE_COMBAT_PLAYER_PREFERENCES = 999,
                REQUEST_TYPE_METHOD_OPEN_COMBAT_SESSION = 1000,
                REQUEST_TYPE_METHOD_UPDATE_COMBAT = 1001,
                REQUEST_TYPE_METHOD_QUIT_COMBAT = 1002,
                REQUEST_TYPE_METHOD_GET_COMBAT_RESULTS = 1003,
                REQUEST_TYPE_METHOD_UNLOCK_SPECIAL_MOVE = 1004,
                REQUEST_TYPE_METHOD_GET_NPC_COMBAT_REWARDS = 1005,
                REQUEST_TYPE_METHOD_COMBAT_FRIEND_REQUEST = 1006,
                REQUEST_TYPE_METHOD_OPEN_NPC_COMBAT_SESSION = 1007,
                REQUEST_TYPE_METHOD_START_TUTORIAL_ACTION = 1008,
                REQUEST_TYPE_METHOD_GET_TUTORIAL_EGG_ACTION = 1009,
                REQUEST_TYPE_METHOD_SEND_PROBE = 1020,
                REQUEST_TYPE_METHOD_PROBE_DATA = 1021,
                REQUEST_TYPE_METHOD_COMBAT_DATA = 1022,
                REQUEST_TYPE_METHOD_COMBAT_CHALLENGE_DATA = 1023,
                REQUEST_TYPE_METHOD_CHECK_PHOTOBOMB = 1101,
                REQUEST_TYPE_METHOD_CONFIRM_PHOTOBOMB = 1102,
                REQUEST_TYPE_METHOD_GET_PHOTOBOMB = 1103,
                REQUEST_TYPE_METHOD_ENCOUNTER_PHOTOBOMB = 1104,
                REQUEST_TYPE_METHOD_GET_SIGNED_GMAP_URL_DEPRECATED = 1105,
                REQUEST_TYPE_METHOD_CHANGE_TEAM = 1106,
                REQUEST_TYPE_METHOD_GET_WEB_TOKEN = 1107,
                REQUEST_TYPE_METHOD_COMPLETE_SNAPSHOT_SESSION = 1110,
                REQUEST_TYPE_METHOD_COMPLETE_WILD_SNAPSHOT_SESSION = 1111,
                REQUEST_TYPE_METHOD_START_INCIDENT = 1200,
                REQUEST_TYPE_METHOD_INVASION_COMPLETE_DIALOGUE = 1201,
                REQUEST_TYPE_METHOD_INVASION_OPEN_COMBAT_SESSION = 1202,
                REQUEST_TYPE_METHOD_INVASION_BATTLE_UPDATE = 1203,
                REQUEST_TYPE_METHOD_INVASION_ENCOUNTER = 1204,
                REQUEST_TYPE_METHOD_PURIFY_POKEMON = 1205,
                REQUEST_TYPE_METHOD_GET_ROCKET_BALLOON = 1206,
                REQUEST_TYPE_METHOD_START_ROCKET_BALLOON_INCIDENT = 1207,
                REQUEST_TYPE_METHOD_VS_SEEKER_START_MATCHMAKING = 1300,
                REQUEST_TYPE_METHOD_CANCEL_MATCHMAKING = 1301,
                REQUEST_TYPE_METHOD_GET_MATCHMAKING_STATUS = 1302,
                REQUEST_TYPE_METHOD_COMPLETE_VS_SEEKER_AND_RESTART_CHARGING = 1303,
                REQUEST_TYPE_METHOD_GET_VS_SEEKER_STATUS = 1304,
                REQUEST_TYPE_METHOD_COMPLETE_COMBAT_COMPETITIVE_SEASON_ACTION = 1305,
                REQUEST_TYPE_METHOD_CLAIM_VS_SEEKER_REWARDS = 1306,
                REQUEST_TYPE_METHOD_VS_SEEKER_REWARD_ENCOUNTER = 1307,
                REQUEST_TYPE_METHOD_ACTIVATE_VS_SEEKER = 1308,
                REQUEST_TYPE_METHOD_GET_BUDDY_MAP = 1350,
                REQUEST_TYPE_METHOD_GET_BUDDY_STATS = 1351,
                REQUEST_TYPE_METHOD_FEED_BUDDY = 1352,
                REQUEST_TYPE_METHOD_OPEN_BUDDY_GIFT = 1353,
                REQUEST_TYPE_METHOD_PET_BUDDY = 1354,
                REQUEST_TYPE_METHOD_GET_BUDDY_HISTORY = 1355,
                REQUEST_TYPE_METHOD_UPDATE_ROUTE_DRAFT = 1400,
                REQUEST_TYPE_METHOD_GET_MAP_FORTS = 1401,
                REQUEST_TYPE_METHOD_SUBMIT_ROUTE_DRAFT = 1402,
                REQUEST_TYPE_METHOD_GET_PUBLISHED_ROUTES = 1403,
                REQUEST_TYPE_METHOD_START_ROUTE = 1404,
                REQUEST_TYPE_METHOD_GET_ROUTES = 1405,
                REQUEST_TYPE_METHOD_PROGRESS_ROUTE = 1406,
                REQUEST_TYPE_METHOD_PROCESS_TAPPABLE = 1408,
                REQUEST_TYPE_METHOD_LIST_ROUTE_BADGES = 1409,
                REQUEST_TYPE_METHOD_CANCEL_ROUTE = 1410,
                REQUEST_TYPE_METHOD_LIST_ROUTE_STAMPS = 1411,
                REQUEST_TYPE_METHOD_RATE_ROUTE = 1412,
                REQUEST_TYPE_METHOD_CREATE_ROUTE_DRAFT = 1413,
                REQUEST_TYPE_METHOD_DELETE_ROUTE_DRAFT = 1414,
                REQUEST_TYPE_METHOD_REPORT_ROUTE = 1415,
                REQUEST_TYPE_METHOD_SPAWN_TAPPABLE = 1416,
                REQUEST_TYPE_METHOD_ROUTE_ENCOUNTER = 1417,
                REQUEST_TYPE_METHOD_CAN_REPORT_ROUTE = 1418,
                REQUEST_TYPE_METHOD_ROUTE_UPTATE_SEEN = 1420,
                REQUEST_TYPE_METHOD_RECALL_ROUTE_DRAFT = 1421,
                REQUEST_TYPE_METHOD_ROUTES_NEARBY_NOTIF_SHOWN = 1422,
                REQUEST_TYPE_METHOD_NPC_ROUTE_GIFT = 1423,
                REQUEST_TYPE_METHOD_GET_ROUTE_CREATIONS = 1424,
                REQUEST_TYPE_METHOD_APPEAL_ROUTE = 1425,
                REQUEST_TYPE_METHOD_GET_ROUTE_DRAFT = 1426,
                REQUEST_TYPE_METHOD_FAVORITE_ROUTE = 1427,
                REQUEST_TYPE_METHOD_CREATE_ROUTE_SHORTCODE = 1428,
                REQUEST_TYPE_METHOD_GET_ROUTE_BY_SHORTCODE = 1429,
                REQUEST_TYPE_METHOD_CREATE_BUDDY_MUTLIPLAYER_SESSION = 1456,
                REQUEST_TYPE_METHOD_JOIN_BUDDY_MULTIPLAYER_SESSION = 1457,
                REQUEST_TYPE_METHOD_LEAVE_BUDDY_MULTIPLAYER_SESSION = 1458,
                REQUEST_TYPE_METHOD_MEGA_EVOLVE_POKEMON = 1502,
                REQUEST_TYPE_METHOD_REMOTE_GIFT_PING = 1503,
                REQUEST_TYPE_METHOD_SEND_RAID_INVITATION = 1504,
                REQUEST_TYPE_METHOD_SEND_BREAD_BATTLE_INVITATION = 1505,
                REQUEST_TYPE_METHOD_GET_DAILY_ENCOUNTER = 1601,
                REQUEST_TYPE_METHOD_DAILY_ENCOUNTER = 1602,
                REQUEST_TYPE_METHOD_OPEN_SPONSORED_GIFT = 1650,
                REQUEST_TYPE_METHOD_SPONSORED_GIFT_REPORT_INTERACTION = 1651,
                REQUEST_TYPE_METHOD_SAVE_PLAYER_PREFERENCES = 1652,
                REQUEST_TYPE_METHOD_PROFANITY_CHECK = 1653,
                REQUEST_TYPE_METHOD_GET_TIMED_GROUP_CHALLENGE = 1700,
                REQUEST_TYPE_METHOD_GET_NINTENDO_ACCOUNT = 1710,
                REQUEST_TYPE_METHOD_UNLINK_NINTENDO_ACCOUNT = 1711,
                REQUEST_TYPE_METHOD_GET_NINTENDO_OAUTH2_URL = 1712,
                REQUEST_TYPE_METHOD_TRANSFER_TO_POKEMON_HOME = 1713,
                REQUEST_TYPE_METHOD_REPORT_AD_FEEDBACK = 1716,
                REQUEST_TYPE_METHOD_CREATE_POKEMON_TAG = 1717,
                REQUEST_TYPE_METHOD_DELETE_POKEMON_TAG = 1718,
                REQUEST_TYPE_METHOD_EDIT_POKEMON_TAG = 1719,
                REQUEST_TYPE_METHOD_SET_POKEMON_TAGS_FOR_POKEMON = 1720,
                REQUEST_TYPE_METHOD_GET_POKEMON_TAGS = 1721,
                REQUEST_TYPE_METHOD_CHANGE_POKEMON_FORM = 1722,
                REQUEST_TYPE_METHOD_CHOOSE_EVENT_VARIANT = 1723,
                REQUEST_TYPE_METHOD_BUTTERFLY_COLLECTOR_REWARD_ENCOUNTER = 1724,
                REQUEST_TYPE_METHOD_GET_ADDITIONAL_POKEMON_DETAILS = 1725,
                REQUEST_TYPE_METHOD_CREATE_ROUTE_PIN = 1726,
                REQUEST_TYPE_METHOD_LIKE_ROUTE_PIN = 1727,
                REQUEST_TYPE_METHOD_VIEW_ROUTE_PIN = 1728,
                REQUEST_TYPE_METHOD_GET_REFERRAL_CODE = 1800,
                REQUEST_TYPE_METHOD_ADD_REFERRER = 1801,
                REQUEST_TYPE_METHOD_SEND_FRIEND_INVITE_VIA_REFERRAL_CODE = 1802,
                REQUEST_TYPE_METHOD_GET_MILESTONES = 1803,
                REQUEST_TYPE_METHOD_MARK_MILESTONES_AS_VIEWED = 1804,
                REQUEST_TYPE_METHOD_GET_MILESTONES_PREVIEW = 1805,
                REQUEST_TYPE_METHOD_COMPLETE_MILESTONE = 1806,
                REQUEST_TYPE_METHOD_GET_GEOFENCED_AD = 1820,
                REQUEST_TYPE_METHOD_POWER_UP_POKESTOP_ENCOUNTER = 1900,
                REQUEST_TYPE_METHOD_GET_PLAYER_STAMP_COLLECTIONS = 1901,
                REQUEST_TYPE_METHOD_SAVE_STAMP = 1902,
                REQUEST_TYPE_METHOD_CLAIM_STAMP_COLLECTION_REWARD = 1904,
                REQUEST_TYPE_METHOD_CHANGE_STAMP_COLLECTION_PLAYER_DATA = 1905,
                REQUEST_TYPE_METHOD_CHECK_STAMP_GIFT_ABILITY = 1906,
                REQUEST_TYPE_METHOD_DELETE_POSTCARDS = 1909,
                REQUEST_TYPE_METHOD_CREATE_POSTCARD = 1910,
                REQUEST_TYPE_METHOD_UPDATE_POSTCARD = 1911,
                REQUEST_TYPE_METHOD_DELETE_POSTCARD = 1912,
                REQUEST_TYPE_METHOD_GET_MEMENTO_LIST = 1913,
                REQUEST_TYPE_METHOD_UPLOAD_RAID_CLIENT_LOG = 1914,
                REQUEST_TYPE_METHOD_SKIP_ENTER_REFERRAL_CODE = 1915,
                REQUEST_TYPE_METHOD_UPLOAD_COMBAT_CLIENT_LOG = 1916,
                REQUEST_TYPE_METHOD_COMBAT_SYNC_SERVER_OFFSET = 1917,
                REQUEST_TYPE_METHOD_CHECK_GIFTING_ELIGIBILITY = 2000,
                REQUEST_TYPE_METHOD_REDEEM_TICKET_GIFT_FOR_FRIEND = 2001,
                REQUEST_TYPE_METHOD_GET_INCENSE_RECAP = 2002,
                REQUEST_TYPE_METHOD_ACKNOWLEDGE_INCENSE_RECAP = 2003,
                REQUEST_TYPE_METHOD_BOOT_RAID = 2004,
                REQUEST_TYPE_METHOD_GET_POKESTOP_ENCOUNTER = 2005,
                REQUEST_TYPE_METHOD_ENCOUNTER_POKESTOP_ENCOUNTER = 2006,
                REQUEST_TYPE_METHOD_POLL_PLAYER_SPAWNABLE_POKEMON = 2007,
                REQUEST_TYPE_METHOD_GET_QUEST_UI = 2008,
                REQUEST_TYPE_METHOD_GET_ELIGIBLE_COMBAT_LEAGUES = 2009,
                REQUEST_TYPE_METHOD_SEND_FRIEND_REQUEST_VIA_PLAYER_IDS = 2010,
                REQUEST_TYPE_METHOD_GET_RAID_LOBBY_COUNTER = 2011,
                REQUEST_TYPE_METHOD_USE_NON_COMBAT_MOVE = 2014,
                REQUEST_TYPE_METHOD_CHECK_POKEMON_SIZE_CONTEST_ELIGIBILITY = 2100,
                REQUEST_TYPE_METHOD_UPDATE_POKEMON_SIZE_CONTEST_ENTRY = 2101,
                REQUEST_TYPE_METHOD_TRANSFER_POKEMON_SIZE_CONTEST_ENTRY = 2102,
                REQUEST_TYPE_METHOD_REMOVE_POKEMON_SIZE_CONTEST_ENTRY = 2103,
                REQUEST_TYPE_METHOD_GET_POKEMON_SIZE_CONTEST_ENTRY = 2104,
                REQUEST_TYPE_METHOD_GET_CONTEST_DATA = 2105,
                REQUEST_TYPE_METHOD_GET_CONTESTS_UNCLAIMED_REWARDS = 2106,
                REQUEST_TYPE_METHOD_CLAIM_CONTESTS_REWARDS = 2107,
                REQUEST_TYPE_METHOD_GET_ENTERED_CONTEST = 2108,
                REQUEST_TYPE_METHOD_GET_POKEMON_SIZE_CONTEST_FRIEND_ENTRY = 2109,
                REQUEST_TYPE_METHOD_CHECK_CONTEST_ELIGIBILITY = 2150,
                REQUEST_TYPE_METHOD_UPDATE_CONTEST_ENTRY = 2151,
                REQUEST_TYPE_METHOD_TRANSFER_CONTEST_ENTRY = 2152,
                REQUEST_TYPE_METHOD_GET_CONTEST_FRIEND_ENTRY = 2153,
                REQUEST_TYPE_METHOD_GET_CONTEST_ENTRY = 2154,
                REQUEST_TYPE_METHOD_CREATE_PARTY = 2300,
                REQUEST_TYPE_METHOD_JOIN_PARTY = 2301,
                REQUEST_TYPE_METHOD_START_PARTY = 2302,
                REQUEST_TYPE_METHOD_LEAVE_PARTY = 2303,
                REQUEST_TYPE_METHOD_GET_PARTY = 2304,
                REQUEST_TYPE_METHOD_UPDATE_PARTY_LOCATION = 2305,
                REQUEST_TYPE_METHOD_SEND_PARTY_DARK_LAUNCH_LOG = 2306,
                REQUEST_TYPE_METHOD_START_PARTY_QUEST = 2308,
                REQUEST_TYPE_METHOD_COMPLETE_PARTY_QUEST = 2309,
                REQUEST_TYPE_METHOD_GET_BONUS_ATTRACTED_POKEMON = 2350,
                REQUEST_TYPE_METHOD_GET_BONUSES = 2352,
                REQUEST_TYPE_METHOD_BADGE_REWARD_ENCOUNTER = 2360,
                REQUEST_TYPE_METHOD_NPC_UPDATE_STATE = 2400,
                REQUEST_TYPE_METHOD_NPC_SEND_GIFT = 2401,
                REQUEST_TYPE_METHOD_NPC_OPEN_GIFT = 2402,
                REQUEST_TYPE_METHOD_JOIN_BREAD_LOBBY = 2450,
                REQUEST_TYPE_METHOD_PREPARE_BREAD_LOBBY = 2453,
                REQUEST_TYPE_METHOD_LEAVE_BREAD_LOBBY = 2455,
                REQUEST_TYPE_METHOD_START_BREAD_BATTLE = 2456,
                REQUEST_TYPE_METHOD_GET_BREAD_LOBBY_DETAILS = 2457,
                REQUEST_TYPE_METHOD_START_MP_WALK_QUEST = 2458,
                REQUEST_TYPE_METHOD_ENHANCE_BREAD_MOVE = 2459,
                REQUEST_TYPE_METHOD_STATION_POKEMON = 2460,
                REQUEST_TYPE_METHOD_LOOT_STATION = 2461,
                REQUEST_TYPE_METHOD_GET_STATION_DETAILS = 2462,
                REQUEST_TYPE_METHOD_MARK_SAVE_FOR_LATER = 2463,
                REQUEST_TYPE_METHOD_USE_SAVE_FOR_LATER = 2464,
                REQUEST_TYPE_METHOD_REMOVE_SAVE_FOR_LATER = 2465,
                REQUEST_TYPE_METHOD_GET_SAVE_FOR_LATER_ENTRIES = 2466,
                REQUEST_TYPE_METHOD_GET_MP_SUMMARY = 2467,
                REQUEST_TYPE_METHOD_REPLENISH_MP = 2468,
                REQUEST_TYPE_METHOD_REPORT_STATION = 2470,
                REQUEST_TYPE_METHOD_DEBUG_RESET_DAILY_MP = 2471,
                REQUEST_TYPE_METHOD_RELEASE_STATIONED_POKEMON = 2472,
                REQUEST_TYPE_METHOD_COMPLETE_BREAD_BATTLE = 2473,
                REQUEST_TYPE_METHOD_ENCOUNTER_STATION_SPAWN = 2475,
                REQUEST_TYPE_METHOD_GET_NUM_STATION_ASSISTS = 2476,
                REQUEST_TYPE_METHOD_PT_TWO = 2501,
                REQUEST_TYPE_METHOD_PT_THREE = 2502,
                REQUEST_TYPE_METHOD_GET_VPS_EVENTS = 3000,
                REQUEST_TYPE_METHOD_UPDATE_VPS_EVENTS = 3001,
                REQUEST_TYPE_METHOD_ADD_PTC_LOGIN_ACTION = 3002,
                REQUEST_TYPE_METHOD_CLAIM_PTC_LINKING_REWARD = 3003,
                REQUEST_TYPE_METHOD_CAN_CLAIM_PTC_REWARD_ACTION = 3004,
                REQUEST_TYPE_METHOD_CONTRIBUTE_PARTY_ITEMS = 3005,
                REQUEST_TYPE_METHOD_CONSUME_PARTY_ITEMS = 3006,
                REQUEST_TYPE_METHOD_REMOVE_PTC_LOGIN = 3007,
                REQUEST_TYPE_METHOD_SEND_PARTY_PLAY_INVITE = 3008,
                REQUEST_TYPE_METHOD_CONSUME_STICKERS = 3009,
                REQUEST_TYPE_METHOD_COMPLETE_RAID_BATTLE = 3010,
                REQUEST_TYPE_METHOD_SYNC_BATTLE_INVENTORY = 3011,
                REQUEST_TYPE_METHOD_PREVIEW_CONTRIBUTE_PARTY_ITEMS = 3015,
                REQUEST_TYPE_METHOD_KICK_FROM_PARTY = 3016,
                REQUEST_TYPE_METHOD_FUSE_POKEMON = 3017,
                REQUEST_TYPE_METHOD_UNFUSE_POKEMON = 3018,
                REQUEST_TYPE_METHOD_GET_IRIS_SOCIAL_SCENE = 3019,
                REQUEST_TYPE_METHOD_UPDATE_IRIS_SOCIAL_SCENE = 3020,
                REQUEST_TYPE_METHOD_GET_CHANGE_POKEMON_FORM_PREVIEW = 3021,
                REQUEST_TYPE_METHOD_GET_FUSE_POKEMON_PREVIEW = 3022,
                REQUEST_TYPE_METHOD_GET_UNFUSE_POKEMON_PREVIEW = 3023,
                REQUEST_TYPE_METHOD_PROCESS_PLAYER_INBOX = 3024,
                REQUEST_TYPE_METHOD_GET_SURVEY_ELIGIBILITY = 3025,
                REQUEST_TYPE_METHOD_UPDATE_SURVEY_ELIGIBILITY = 3026,
                REQUEST_TYPE_METHOD_SMART_GLASSES_SYNC_SETTINGS = 3027,
                REQUEST_TYPE_METHOD_COMPLETE_VISIT_PAGE_QUEST = 3030,
                REQUEST_TYPE_METHOD_GET_EVENT_RSVPS = 3031,
                REQUEST_TYPE_METHOD_CREATE_EVENT_RSVP = 3032,
                REQUEST_TYPE_METHOD_CANCEL_EVENT_RSVP = 3033,
                REQUEST_TYPE_METHOD_CLAIM_EVENT_PASS_REWARDS = 3034,
                REQUEST_TYPE_METHOD_CLAIM_ALL_EVENT_PASS_REWARDS = 3035,
                REQUEST_TYPE_METHOD_GET_EVENT_RSVP_COUNT = 3036,
                REQUEST_TYPE_METHOD_SEND_RSVP_INVITATION = 3039,
                REQUEST_TYPE_METHOD_UPDATE_EVENT_RSVP_SELECTION = 3040,
                REQUEST_TYPE_METHOD_GET_STATION_INFO = 3051,
                REQUEST_TYPE_METHOD_AGE_CONFIRMATION = 3052,
                REQUEST_TYPE_METHOD_CHANGE_STAT_INCREASE_GOAL = 3053,
                REQUEST_TYPE_PLATFORM_REGISTER_PUSH_NOTIFICATION = 5000,
                REQUEST_TYPE_PLATFORM_UNREGISTER_PUSH_NOTIFICATION = 5001,
                REQUEST_TYPE_PLATFORM_UPDATE_NOTIFICATION_STATUS = 5002,
                REQUEST_TYPE_PLATFORM_OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 5003,
                REQUEST_TYPE_PLATFORM_DOWNLOAD_GAME_MASTER_TEMPLATES = 5004,
                REQUEST_TYPE_PLATFORM_GET_INVENTORY = 5005,
                REQUEST_TYPE_PLATFORM_REDEEM_PASSCODE = 5006,
                REQUEST_TYPE_PLATFORM_PING = 5007,
                REQUEST_TYPE_PLATFORM_ADD_LOGIN_ACTION = 5008,
                REQUEST_TYPE_PLATFORM_REMOVE_LOGIN_ACTION = 5009,
                REQUEST_TYPE_PLATFORM_LIST_LOGIN_ACTION = 5010,
                REQUEST_TYPE_PLATFORM_ADD_NEW_POI = 5011,
                REQUEST_TYPE_PLATFORM_PROXY_SOCIAL_ACTION = 5012,
                REQUEST_TYPE_PLATFORM_DEPRECATED_CLIENT_TELEMETRY = 5013,
                REQUEST_TYPE_PLATFORM_GET_AVAILABLE_SUBMISSIONS = 5014,
                REQUEST_TYPE_PLATFORM_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 5015,
                REQUEST_TYPE_PLATFORM_REPLACE_LOGIN_ACTION = 5016,
                REQUEST_TYPE_PLATFORM_PROXY_SOCIAL_SIDE_CHANNEL_ACTION = 5017,
                REQUEST_TYPE_PLATFORM_COLLECT_CLIENT_TELEMETRY = 5018,
                REQUEST_TYPE_PLATFORM_PURCHASE_SKU = 5019,
                REQUEST_TYPE_PLATFORM_GET_AVAILABLE_SKUS_AND_BALANCES = 5020,
                REQUEST_TYPE_PLATFORM_REDEEM_GOOGLE_RECEIPT = 5021,
                REQUEST_TYPE_PLATFORM_REDEEM_APPLE_RECEIPT = 5022,
                REQUEST_TYPE_PLATFORM_REDEEM_DESKTOP_RECEIPT = 5023,
                REQUEST_TYPE_PLATFORM_UPDATE_FITNESS_METRICS = 5024,
                REQUEST_TYPE_PLATFORM_GET_FITNESS_REPORT = 5025,
                REQUEST_TYPE_PLATFORM_GET_CLIENT_TELEMETRY_SETTINGS = 5026,
                REQUEST_TYPE_PLATFORM_PING_ASYNC = 5027,
                REQUEST_TYPE_PLATFORM_REGISTER_BACKGROUND_SERVICE = 5028,
                REQUEST_TYPE_PLATFORM_GET_CLIENT_BGMODE_SETTINGS = 5029,
                REQUEST_TYPE_PLATFORM_PING_DOWNSTREAM = 5030,
                REQUEST_TYPE_PLATFORM_SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 5032,
                REQUEST_TYPE_PLATFORM_REQUEST_GEOFENCE_UPDATES = 5033,
                REQUEST_TYPE_PLATFORM_UPDATE_PLAYER_LOCATION = 5034,
                REQUEST_TYPE_PLATFORM_GENERATE_GMAP_SIGNED_URL = 5035,
                REQUEST_TYPE_PLATFORM_GET_GMAP_SETTINGS = 5036,
                REQUEST_TYPE_PLATFORM_REDEEM_SAMSUNG_RECEIPT = 5037,
                REQUEST_TYPE_PLATFORM_ADD_NEW_ROUTE = 5038,
                REQUEST_TYPE_PLATFORM_GET_OUTSTANDING_WARNINGS = 5039,
                REQUEST_TYPE_PLATFORM_ACKNOWLEDGE_WARNINGS = 5040,
                REQUEST_TYPE_PLATFORM_SUBMIT_POI_IMAGE = 5041,
                REQUEST_TYPE_PLATFORM_SUBMIT_POI_TEXT_METADATA_UPDATE = 5042,
                REQUEST_TYPE_PLATFORM_SUBMIT_POI_LOCATION_UPDATE = 5043,
                REQUEST_TYPE_PLATFORM_SUBMIT_POI_TAKEDOWN_REQUEST = 5044,
                REQUEST_TYPE_PLATFORM_GET_WEB_TOKEN_ACTION = 5045,
                REQUEST_TYPE_PLATFORM_GET_ADVENTURE_SYNC_SETTINGS = 5046,
                REQUEST_TYPE_PLATFORM_UPDATE_ADVENTURE_SYNC_SETTINGS = 5047,
                REQUEST_TYPE_PLATFORM_SET_BIRTHDAY = 5048,
                REQUEST_TYPE_PLATFORM_FETCH_NEWSFEED_ACTION = 5049,
                REQUEST_TYPE_PLATFORM_MARK_NEWSFEED_READ_ACTION = 5050,
                REQUEST_TYPE_SOCIAL_ACTION_SEARCH_PLAYER = 10000,
                REQUEST_TYPE_SOCIAL_ACTION_SEND_FRIEND_INVITE = 10002,
                REQUEST_TYPE_SOCIAL_ACTION_CANCEL_FRIEND_INVITE = 10003,
                REQUEST_TYPE_SOCIAL_ACTION_ACCEPT_FRIEND_INVITE = 10004,
                REQUEST_TYPE_SOCIAL_ACTION_DECLINE_FRIEND_INVITE = 10005,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_FRIENDS = 10006,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_OUTGOING_FRIEND_INVITES = 10007,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_INCOMING_FRIEND_INVITES = 10008,
                REQUEST_TYPE_SOCIAL_ACTION_REMOVE_FRIEND = 10009,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_FRIEND_STATUS = 10010,
                REQUEST_TYPE_SOCIAL_ACTION_SEND_FACEBOOK_FRIEND_INVITE = 10011,
                REQUEST_TYPE_SOCIAL_ACTION_IS_MY_FRIEND = 10012,
                REQUEST_TYPE_SOCIAL_ACTION_CREATE_INVITE_CODE = 10013,
                REQUEST_TYPE_SOCIAL_ACTION_GET_FACEBOOK_FRIEND_LIST = 10014,
                REQUEST_TYPE_SOCIAL_ACTION_UPDATE_FACEBOOK_STATUS = 10015,
                REQUEST_TYPE_SOCIAL_ACTION_SAVE_PLAYER_SETTINGS = 10016,
                REQUEST_TYPE_SOCIAL_ACTION_GET_PLAYER_SETTINGS = 10017,
                REQUEST_TYPE_SOCIAL_ACTION_GET_NIANTIC_FRIEND_LIST_DELETED = 10018,
                REQUEST_TYPE_SOCIAL_ACTION_GET_NIANTIC_FRIEND_DETAILS_DELETED = 10019,
                REQUEST_TYPE_SOCIAL_ACTION_SEND_NIANTIC_FRIEND_INVITE_DELETED = 10020,
                REQUEST_TYPE_SOCIAL_ACTION_SET_ACCOUNT_SETTINGS = 10021,
                REQUEST_TYPE_SOCIAL_ACTION_GET_ACCOUNT_SETTINGS = 10022,
                REQUEST_TYPE_SOCIAL_ACTION_ADD_FAVORITE_FRIEND = 10023,
                REQUEST_TYPE_SOCIAL_ACTION_REMOVE_FAVORITE_FRIEND = 10024,
                REQUEST_TYPE_SOCIAL_ACTION_BLOCK_ACCOUNT = 10025,
                REQUEST_TYPE_SOCIAL_ACTION_UNBLOCK_ACCOUNT = 10026,
                REQUEST_TYPE_SOCIAL_ACTION_GET_OUTGING_BLOCKS = 10027,
                REQUEST_TYPE_SOCIAL_ACTION_IS_ACCOUNT_BLOCKED = 10028,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_FRIEND_ACTIVITIES = 10029,
                REQUEST_TYPE_SOCIAL_ACTION_REGISTER_PUSH_NOTIFICATION = 10101,
                REQUEST_TYPE_SOCIAL_ACTION_UNREGISTER_PUSH_NOTIFICATION = 10102,
                REQUEST_TYPE_SOCIAL_ACTION_UPDATE_NOTIFICATION = 10103,
                REQUEST_TYPE_SOCIAL_ACTION_OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 10104,
                REQUEST_TYPE_SOCIAL_ACTION_GET_INBOX = 10105,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_OPT_OUT_NOTIFICATION_CATEGORIES = 10106,
                REQUEST_TYPE_SOCIAL_ACTION_GET_SIGNED_URL = 10201,
                REQUEST_TYPE_SOCIAL_ACTION_SUBMIT_IMAGE = 10202,
                REQUEST_TYPE_SOCIAL_ACTION_GET_PHOTOS = 10203,
                REQUEST_TYPE_SOCIAL_ACTION_DELETE_PHOTO = 10204,
                REQUEST_TYPE_SOCIAL_ACTION_FLAG_PHOTO = 10205,
                REQUEST_TYPE_SOCIAL_ACTION_UPDATE_PROFILE_V2 = 20001,
                REQUEST_TYPE_SOCIAL_ACTION_UPDATE_FRIENDSHIP_V2 = 20002,
                REQUEST_TYPE_SOCIAL_ACTION_GET_PROFILE_V2 = 20003,
                REQUEST_TYPE_SOCIAL_ACTION_INVITE_GAME_V2 = 20004,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_2 = 20005,
                REQUEST_TYPE_SOCIAL_ACTION_LIST_FRIENDS_V2 = 20006,
                REQUEST_TYPE_SOCIAL_ACTION_GET_FRIEND_DETAILS_V2 = 20007,
                REQUEST_TYPE_SOCIAL_ACTION_GET_CLIENT_FEATURE_FLAGS_V2 = 20008,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_1 = 20009,
                REQUEST_TYPE_SOCIAL_ACTION_GET_INCOMING_GAME_INVITES_V2 = 20010,
                REQUEST_TYPE_SOCIAL_ACTION_UPDATE_INCOMING_GAME_INVITE_V2 = 20011,
                REQUEST_TYPE_SOCIAL_ACTION_DISMISS_OUTGOING_GAME_INVITES_V2 = 20012,
                REQUEST_TYPE_SOCIAL_ACTION_SYNC_CONTACT_LIST_V2 = 20013,
                REQUEST_TYPE_SOCIAL_ACTION_SEND_CONTACT_LIST_FRIEND_INVITE_V2 = 20014,
                REQUEST_TYPE_SOCIAL_ACTION_REFER_CONTACT_LIST_FRIEND_V2 = 20015,
                REQUEST_TYPE_SOCIAL_ACTION_GET_CONTACT_LIST_INFO_V2 = 20016,
                REQUEST_TYPE_SOCIAL_ACTION_DISMISS_CONTACT_LIST_UPDATE_V2 = 20017,
                REQUEST_TYPE_SOCIAL_ACTION_NOTIFY_CONTACT_LIST_FRIENDS_V2 = 20018,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_6 = 20019,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_7 = 20020,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_3 = 20400,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_4 = 20401,
                REQUEST_TYPE_SOCIAL_ACTION_RESERVED_ACTION_5 = 20402,
                REQUEST_TYPE_SOCIAL_ACTION_GET_FRIEND_RECOMMENDATION = 20500,
                REQUEST_TYPE_GAME_ANTICHEAT_ACTION_GET_OUTSTANDING_WARNINGS = 200000,
                REQUEST_TYPE_GAME_ANTICHEAT_ACTION_ACKNOWLEDGE_WARNINGS = 200001,
                REQUEST_TYPE_GAME_BACKGROUND_MODE_ACTION_REGISTER_BACKGROUND_SERVICE = 230000,
                REQUEST_TYPE_GAME_BACKGROUND_MODE_ACTION_GET_CLIENT_BGMODE_SETTINGS = 230001,
                REQUEST_TYPE_GAME_BACKGROUND_MODE_ACTION_GET_ADVENTURE_SYNC_PROGRESS = 230002,
                REQUEST_TYPE_GAME_IAP_ACTION_PURCHASE_SKU = 310000,
                REQUEST_TYPE_GAME_IAP_ACTION_GET_AVAILABLE_SKUS_AND_BALANCES = 310001,
                REQUEST_TYPE_GAME_IAP_ACTION_SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 310002,
                REQUEST_TYPE_GAME_IAP_ACTION_PURCHASE_WEB_SKU = 310003,
                REQUEST_TYPE_GAME_IAP_ACTION_REDEEM_GOOGLE_RECEIPT = 310100,
                REQUEST_TYPE_GAME_IAP_ACTION_REDEEM_APPLE_RECEIPT = 310101,
                REQUEST_TYPE_GAME_IAP_ACTION_REDEEM_DESKTOP_RECEIPT = 310102,
                REQUEST_TYPE_GAME_IAP_ACTION_REDEEM_SAMSUNG_RECEIPT = 310103,
                REQUEST_TYPE_GAME_IAP_ACTION_GET_AVAILABLE_SUBSCRIPTIONS = 310200,
                REQUEST_TYPE_GAME_IAP_ACTION_GET_ACTIVE_SUBSCRIPTIONS = 310201,
                REQUEST_TYPE_GAME_IAP_ACTION_GET_REWARD_TIERS = 310300,
                REQUEST_TYPE_GAME_IAP_ACTION_CLAIM_REWARDED_SPEND_TIER = 310301,
                REQUEST_TYPE_GAME_IAP_ACTION_REDEEM_XSOLLA_RECEIPT = 311100,
                REQUEST_TYPE_GAME_IAP_ACTION_GET_WEBSTORE_USER = 311101,
                REQUEST_TYPE_GAME_IAP_ACTION_REFUND_IAP_RECEIPT = 311102,
                REQUEST_TYPE_GAME_IAP_ACTION_GET_AVAILABLE_SKUS_ANONYMOUS = 311103,
                REQUEST_TYPE_GAME_IAP_ACTION_REDEEM_WEBSTORE_RECEIPT = 311104,
                REQUEST_TYPE_GAME_LOCATION_AWARENESS_ACTION_REQUEST_GEOFENCE_UPDATES = 360000,
                REQUEST_TYPE_GAME_LOCATION_AWARENESS_ACTION_UPDATE_PLAYER_LOCATION = 360001,
                REQUEST_TYPE_GAME_LOCATION_AWARENESS_ACTION_BULK_UPDATE_PLAYER_LOCATION = 360002,
                REQUEST_TYPE_GAME_LOCATION_AWARENESS_ACTION_UPDATE_BREADCRUMB_HISTORY = 361000,
                REQUEST_TYPE_GAME_LOCATION_AWARENESS_ACTION_REFRESH_PROXIMITY_TOKENS = 362000,
                REQUEST_TYPE_GAME_LOCATION_AWARENESS_ACTION_REPORT_PROXIMITY_CONTACTS = 362001,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_ADD_LOGIN_ACTION = 600000,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_REMOVE_LOGIN_ACTION = 600001,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_LIST_LOGIN_ACTION = 600002,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_REPLACE_LOGIN_ACTION = 600003,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_SET_BIRTHDAY_ACTION = 600004,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_GAR_PROXY_ACTION = 600005,
                REQUEST_TYPE_GAME_ACCOUNT_REGISTRY_ACTION_LINK_TO_ACCOUNT_LOGIN_ACTION = 600006,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_ADD_NEW_POI = 620000,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_AVAILABLE_SUBMISSIONS = 620001,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 620002,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_PLAYER_SUBMISSION_VALIDATION_SETTINGS = 620003,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_ADD_NEW_POI = 620004,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 620005,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_NEW_PRIVATE_POI = 620006,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_NEW_PRIVATE_POI = 620007,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_IMAGE = 620100,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_TEXT_METADATA_UPDATE = 620101,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_LOCATION_UPDATE = 620102,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_TAKEDOWN_REQUEST = 620103,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_SPONSOR_POI_REPORT = 620104,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_SPONSOR_POI_LOCATION_UPDATE = 620105,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_CATEGORY_VOTE = 620106,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_IMAGE = 620107,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_TEXT_METADATA_UPDATE = 620108,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_LOCATION_UPDATE = 620109,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_TAKEDOWN_REQUEST = 620110,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_ADD_NEW_ROUTE = 620200,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GENERATE_GMAP_SIGNED_URL = 620300,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_GMAP_SETTINGS = 620301,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_POI_AR_VIDEO_METADATA = 620400,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_GRAPESHOT_FILE_UPLOAD_URL = 620401,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_ASYNC_FILE_UPLOAD_COMPLETE = 620402,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_AR_MAPPING_SETTINGS = 620403,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_POI_AR_VIDEO_METADATA = 620404,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_GET_GRAPESHOT_FILE_UPLOAD_URL = 620405,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_ASYNC_FILE_UPLOAD_COMPLETE = 620406,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_MAPPING_REQUEST = 620407,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_D2D_SUBMIT_MAPPING_REQUEST = 620408,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_IMAGES_FOR_POI = 620500,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_SUBMIT_PLAYER_IMAGE_VOTE_FOR_POI = 620501,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_IMAGE_GALLERY_SETTINGS = 620502,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_MAP_DATA = 620600,
                REQUEST_TYPE_TITAN_PLAYER_SUBMISSION_ACTION_GET_POIS_IN_RADIUS = 620601,
                REQUEST_TYPE_GAME_FITNESS_ACTION_UPDATE_FITNESS_METRICS = 640000,
                REQUEST_TYPE_GAME_FITNESS_ACTION_GET_FITNESS_REPORT = 640001,
                REQUEST_TYPE_GAME_FITNESS_ACTION_GET_ADVENTURE_SYNC_SETTINGS = 640002,
                REQUEST_TYPE_GAME_FITNESS_ACTION_UPDATE_ADVENTURE_SYNC_SETTINGS = 640003,
                REQUEST_TYPE_GAME_FITNESS_ACTION_UPDATE_ADVENTURE_SYNC_FITNESS = 640004,
                REQUEST_TYPE_GAME_FITNESS_ACTION_GET_ADVENTURE_SYNC_FITNESS_REPORT = 640005
            }

            interface IAllMessagesProto {
                get_player_proto_2?: (POGOProtos.Rpc.IGetPlayerProto|null);
                get_holoholo_inventory_proto_4?: (POGOProtos.Rpc.IGetHoloholoInventoryProto|null);
                download_settings_action_proto_5?: (POGOProtos.Rpc.IDownloadSettingsActionProto|null);
                getgame_master_client_templates_proto_6?: (POGOProtos.Rpc.IGetGameMasterClientTemplatesProto|null);
                get_remote_config_versions_proto_7?: (POGOProtos.Rpc.IGetRemoteConfigVersionsProto|null);
                register_background_device_action_proto_8?: (POGOProtos.Rpc.IRegisterBackgroundDeviceActionProto|null);
                get_player_day_proto_9?: (POGOProtos.Rpc.IGetPlayerDayProto|null);
                acknowledge_punishment_proto_10?: (POGOProtos.Rpc.IAcknowledgePunishmentProto|null);
                get_server_time_proto_11?: (POGOProtos.Rpc.IGetServerTimeProto|null);
                get_local_time_proto_12?: (POGOProtos.Rpc.IGetLocalTimeProto|null);
                set_playerstatus_proto_20?: (POGOProtos.Rpc.ISetPlayerStatusProto|null);
                getgame_config_versions_proto_21?: (POGOProtos.Rpc.IGetGameConfigVersionsProto|null);
                get_playergps_bookmarks_proto_22?: (POGOProtos.Rpc.IGetPlayerGpsBookmarksProto|null);
                update_player_gps_bookmarks_proto_23?: (POGOProtos.Rpc.IUpdatePlayerGpsBookmarksProto|null);
                fort_search_proto_101?: (POGOProtos.Rpc.IFortSearchProto|null);
                encounter_proto_102?: (POGOProtos.Rpc.IEncounterProto|null);
                catch_pokemon_proto_103?: (POGOProtos.Rpc.ICatchPokemonProto|null);
                fort_details_proto_104?: (POGOProtos.Rpc.IFortDetailsProto|null);
                get_map_objects_proto_106?: (POGOProtos.Rpc.IGetMapObjectsProto|null);
                fort_deploy_proto_110?: (POGOProtos.Rpc.IFortDeployProto|null);
                fort_recall_proto_111?: (POGOProtos.Rpc.IFortRecallProto|null);
                release_pokemon_proto_112?: (POGOProtos.Rpc.IReleasePokemonProto|null);
                use_item_potion_proto_113?: (POGOProtos.Rpc.IUseItemPotionProto|null);
                use_item_capture_proto_114?: (POGOProtos.Rpc.IUseItemCaptureProto|null);
                use_item_revive_proto_116?: (POGOProtos.Rpc.IUseItemReviveProto|null);
                playerprofileproto_121?: (POGOProtos.Rpc.IPlayerProfileProto|null);
                evolve_pokemon_proto_125?: (POGOProtos.Rpc.IEvolvePokemonProto|null);
                get_hatched_eggs_proto_126?: (POGOProtos.Rpc.IGetHatchedEggsProto|null);
                encounter_tutorial_complete_proto_127?: (POGOProtos.Rpc.IEncounterTutorialCompleteProto|null);
                level_up_rewards_proto_128?: (POGOProtos.Rpc.ILevelUpRewardsProto|null);
                check_awarded_badges_proto_129?: (POGOProtos.Rpc.ICheckAwardedBadgesProto|null);
                recycle_item_proto_137?: (POGOProtos.Rpc.IRecycleItemProto|null);
                collect_daily_bonus_proto_138?: (POGOProtos.Rpc.ICollectDailyBonusProto|null);
                use_item_xp_boost_proto_139?: (POGOProtos.Rpc.IUseItemXpBoostProto|null);
                use_item_egg_incubator_proto_140?: (POGOProtos.Rpc.IUseItemEggIncubatorProto|null);
                use_incense_action_proto_141?: (POGOProtos.Rpc.IUseIncenseActionProto|null);
                get_incense_pokemon_proto_142?: (POGOProtos.Rpc.IGetIncensePokemonProto|null);
                incense_encounter_proto_143?: (POGOProtos.Rpc.IIncenseEncounterProto|null);
                add_fort_modifier_proto_144?: (POGOProtos.Rpc.IAddFortModifierProto|null);
                disk_encounter_proto_145?: (POGOProtos.Rpc.IDiskEncounterProto|null);
                upgrade_pokemon_proto_147?: (POGOProtos.Rpc.IUpgradePokemonProto|null);
                set_favorite_pokemon_proto_148?: (POGOProtos.Rpc.ISetFavoritePokemonProto|null);
                nickname_pokemon_proto_149?: (POGOProtos.Rpc.INicknamePokemonProto|null);
                set_contactsettings_proto_151?: (POGOProtos.Rpc.ISetContactSettingsProto|null);
                set_buddy_pokemon_proto_152?: (POGOProtos.Rpc.ISetBuddyPokemonProto|null);
                get_buddy_walked_proto_153?: (POGOProtos.Rpc.IGetBuddyWalkedProto|null);
                use_item_encounter_proto_154?: (POGOProtos.Rpc.IUseItemEncounterProto|null);
                gym_deploy_proto_155?: (POGOProtos.Rpc.IGymDeployProto|null);
                gymget_info_proto_156?: (POGOProtos.Rpc.IGymGetInfoProto|null);
                gym_start_session_proto_157?: (POGOProtos.Rpc.IGymStartSessionProto|null);
                gym_battle_attack_proto_158?: (POGOProtos.Rpc.IGymBattleAttackProto|null);
                join_lobby_proto_159?: (POGOProtos.Rpc.IJoinLobbyProto|null);
                leavelobby_proto_160?: (POGOProtos.Rpc.ILeaveLobbyProto|null);
                set_lobby_visibility_proto_161?: (POGOProtos.Rpc.ISetLobbyVisibilityProto|null);
                set_lobby_pokemon_proto_162?: (POGOProtos.Rpc.ISetLobbyPokemonProto|null);
                get_raid_details_proto_163?: (POGOProtos.Rpc.IGetRaidDetailsProto|null);
                gym_feed_pokemon_proto_164?: (POGOProtos.Rpc.IGymFeedPokemonProto|null);
                start_raid_battle_proto_165?: (POGOProtos.Rpc.IStartRaidBattleProto|null);
                attack_raid_battle_proto_166?: (POGOProtos.Rpc.IAttackRaidBattleProto|null);
                use_item_stardust_boost_proto_168?: (POGOProtos.Rpc.IUseItemStardustBoostProto|null);
                reassign_player_proto_169?: (POGOProtos.Rpc.IReassignPlayerProto|null);
                convertcandy_to_xlcandy_proto_171?: (POGOProtos.Rpc.IConvertCandyToXlCandyProto|null);
                is_sku_available_proto_172?: (POGOProtos.Rpc.IIsSkuAvailableProto|null);
                use_item_bulk_heal_proto_173?: (POGOProtos.Rpc.IUseItemBulkHealProto|null);
                use_item_battle_boost_proto_174?: (POGOProtos.Rpc.IUseItemBattleBoostProto|null);
                use_item_lucky_friend_applicator_proto_175?: (POGOProtos.Rpc.IUseItemLuckyFriendApplicatorProto|null);
                use_item_stat_increase_proto_176?: (POGOProtos.Rpc.IUseItemStatIncreaseProto|null);
                asset_digest_request_proto_300?: (POGOProtos.Rpc.IAssetDigestRequestProto|null);
                download_url_request_proto_301?: (POGOProtos.Rpc.IDownloadUrlRequestProto|null);
                asset_version_proto_302?: (POGOProtos.Rpc.IAssetVersionProto|null);
                claimcodename_request_proto_403?: (POGOProtos.Rpc.IClaimCodenameRequestProto|null);
                set_avatar_proto_404?: (POGOProtos.Rpc.ISetAvatarProto|null);
                set_player_team_proto_405?: (POGOProtos.Rpc.ISetPlayerTeamProto|null);
                mark_tutorial_complete_proto_406?: (POGOProtos.Rpc.IMarkTutorialCompleteProto|null);
                set_neutral_avatar_proto_408?: (POGOProtos.Rpc.ISetNeutralAvatarProto|null);
                list_avatar_store_items_proto_409?: (POGOProtos.Rpc.IListAvatarStoreItemsProto|null);
                list_avatar_appearance_items_proto_410?: (POGOProtos.Rpc.IListAvatarAppearanceItemsProto|null);
                neutral_avatar_badge_reward_proto_450?: (POGOProtos.Rpc.INeutralAvatarBadgeRewardProto|null);
                checkchallenge_proto_600?: (POGOProtos.Rpc.ICheckChallengeProto|null);
                verify_challenge_proto_601?: (POGOProtos.Rpc.IVerifyChallengeProto|null);
                echo_proto_666?: (POGOProtos.Rpc.IEchoProto|null);
                register_sfidarequest_800?: (POGOProtos.Rpc.IRegisterSfidaRequest|null);
                sfida_certification_request_802?: (POGOProtos.Rpc.ISfidaCertificationRequest|null);
                sfida_update_request_803?: (POGOProtos.Rpc.ISfidaUpdateRequest|null);
                sfida_dowser_request_805?: (POGOProtos.Rpc.ISfidaDowserRequest|null);
                sfida_capture_request_806?: (POGOProtos.Rpc.ISfidaCaptureRequest|null);
                list_avatar_customizations_proto_807?: (POGOProtos.Rpc.IListAvatarCustomizationsProto|null);
                set_avatar_item_as_viewed_proto_808?: (POGOProtos.Rpc.ISetAvatarItemAsViewedProto|null);
                get_inbox_proto_809?: (POGOProtos.Rpc.IGetInboxProto|null);
                list_gym_badges_proto_811?: (POGOProtos.Rpc.IListGymBadgesProto|null);
                getgym_badge_details_proto_812?: (POGOProtos.Rpc.IGetGymBadgeDetailsProto|null);
                use_item_move_reroll_proto_813?: (POGOProtos.Rpc.IUseItemMoveRerollProto|null);
                use_item_rare_candy_proto_814?: (POGOProtos.Rpc.IUseItemRareCandyProto|null);
                award_free_raid_ticket_proto_815?: (POGOProtos.Rpc.IAwardFreeRaidTicketProto|null);
                fetch_all_news_proto_816?: (POGOProtos.Rpc.IFetchAllNewsProto|null);
                mark_read_news_article_proto_817?: (POGOProtos.Rpc.IMarkReadNewsArticleProto|null);
                internal_get_player_settings_proto_818?: (POGOProtos.Rpc.IInternalGetPlayerSettingsProto|null);
                beluga_transaction_start_proto_819?: (POGOProtos.Rpc.IBelugaTransactionStartProto|null);
                beluga_transaction_complete_proto_820?: (POGOProtos.Rpc.IBelugaTransactionCompleteProto|null);
                sfida_associate_request_822?: (POGOProtos.Rpc.ISfidaAssociateRequest|null);
                sfida_check_pairing_request_823?: (POGOProtos.Rpc.ISfidaCheckPairingRequest|null);
                sfida_disassociate_request_824?: (POGOProtos.Rpc.ISfidaDisassociateRequest|null);
                waina_get_rewards_request_825?: (POGOProtos.Rpc.IWainaGetRewardsRequest|null);
                waina_submit_sleep_data_request_826?: (POGOProtos.Rpc.IWainaSubmitSleepDataRequest|null);
                saturdaystart_proto_827?: (POGOProtos.Rpc.ISaturdayStartProto|null);
                saturday_complete_proto_828?: (POGOProtos.Rpc.ISaturdayCompleteProto|null);
                lift_user_age_gate_confirmation_proto_830?: (POGOProtos.Rpc.ILiftUserAgeGateConfirmationProto|null);
                get_new_quests_proto_900?: (POGOProtos.Rpc.IGetNewQuestsProto|null);
                get_quest_details_proto_901?: (POGOProtos.Rpc.IGetQuestDetailsProto|null);
                complete_quest_proto_902?: (POGOProtos.Rpc.ICompleteQuestProto|null);
                remove_quest_proto_903?: (POGOProtos.Rpc.IRemoveQuestProto|null);
                quest_encounter_proto_904?: (POGOProtos.Rpc.IQuestEncounterProto|null);
                complete_quest_stampcard_proto_905?: (POGOProtos.Rpc.ICompleteQuestStampCardProto|null);
                progress_questproto_906?: (POGOProtos.Rpc.IProgressQuestProto|null);
                start_quest_incident_proto_907?: (POGOProtos.Rpc.IStartQuestIncidentProto|null);
                read_quest_dialog_proto_908?: (POGOProtos.Rpc.IReadQuestDialogProto|null);
                send_gift_proto_950?: (POGOProtos.Rpc.ISendGiftProto|null);
                open_gift_proto_951?: (POGOProtos.Rpc.IOpenGiftProto|null);
                getgift_box_details_proto_952?: (POGOProtos.Rpc.IGetGiftBoxDetailsProto|null);
                delete_gift_proto_953?: (POGOProtos.Rpc.IDeleteGiftProto|null);
                save_playersnapshot_proto_954?: (POGOProtos.Rpc.ISavePlayerSnapshotProto|null);
                get_friendship_rewards_proto_955?: (POGOProtos.Rpc.IGetFriendshipRewardsProto|null);
                check_send_gift_proto_956?: (POGOProtos.Rpc.ICheckSendGiftProto|null);
                set_friend_nickname_proto_957?: (POGOProtos.Rpc.ISetFriendNicknameProto|null);
                delete_gift_from_inventory_proto_958?: (POGOProtos.Rpc.IDeleteGiftFromInventoryProto|null);
                savesocial_playersettings_proto_959?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsProto|null);
                open_trading_proto_970?: (POGOProtos.Rpc.IOpenTradingProto|null);
                update_trading_proto_971?: (POGOProtos.Rpc.IUpdateTradingProto|null);
                confirm_trading_proto_972?: (POGOProtos.Rpc.IConfirmTradingProto|null);
                cancel_trading_proto_973?: (POGOProtos.Rpc.ICancelTradingProto|null);
                get_trading_proto_974?: (POGOProtos.Rpc.IGetTradingProto|null);
                get_fitness_rewards_proto_980?: (POGOProtos.Rpc.IGetFitnessRewardsProto|null);
                get_combat_player_profile_proto_990?: (POGOProtos.Rpc.IGetCombatPlayerProfileProto|null);
                generate_combat_challenge_id_proto_991?: (POGOProtos.Rpc.IGenerateCombatChallengeIdProto|null);
                createcombatchallenge_proto_992?: (POGOProtos.Rpc.ICreateCombatChallengeProto|null);
                open_combat_challenge_proto_993?: (POGOProtos.Rpc.IOpenCombatChallengeProto|null);
                get_combat_challenge_proto_994?: (POGOProtos.Rpc.IGetCombatChallengeProto|null);
                accept_combat_challenge_proto_995?: (POGOProtos.Rpc.IAcceptCombatChallengeProto|null);
                decline_combat_challenge_proto_996?: (POGOProtos.Rpc.IDeclineCombatChallengeProto|null);
                cancelcombatchallenge_proto_997?: (POGOProtos.Rpc.ICancelCombatChallengeProto|null);
                submit_combat_challenge_pokemons_proto_998?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsProto|null);
                save_combat_player_preferences_proto_999?: (POGOProtos.Rpc.ISaveCombatPlayerPreferencesProto|null);
                open_combat_session_proto_1000?: (POGOProtos.Rpc.IOpenCombatSessionProto|null);
                update_combat_proto_1001?: (POGOProtos.Rpc.IUpdateCombatProto|null);
                quit_combat_proto_1002?: (POGOProtos.Rpc.IQuitCombatProto|null);
                get_combat_results_proto_1003?: (POGOProtos.Rpc.IGetCombatResultsProto|null);
                unlock_pokemon_move_proto_1004?: (POGOProtos.Rpc.IUnlockPokemonMoveProto|null);
                get_npc_combat_rewards_proto_1005?: (POGOProtos.Rpc.IGetNpcCombatRewardsProto|null);
                combat_friend_request_proto_1006?: (POGOProtos.Rpc.ICombatFriendRequestProto|null);
                open_npc_combat_session_proto_1007?: (POGOProtos.Rpc.IOpenNpcCombatSessionProto|null);
                send_probe_proto_1020?: (POGOProtos.Rpc.ISendProbeProto|null);
                check_photobomb_proto_1101?: (POGOProtos.Rpc.ICheckPhotobombProto|null);
                confirm_photobomb_proto_1102?: (POGOProtos.Rpc.IConfirmPhotobombProto|null);
                get_photobomb_proto_1103?: (POGOProtos.Rpc.IGetPhotobombProto|null);
                encounter_photobomb_proto_1104?: (POGOProtos.Rpc.IEncounterPhotobombProto|null);
                getgmap_settings_proto_1105?: (POGOProtos.Rpc.IGetGmapSettingsProto|null);
                change_team_proto_1106?: (POGOProtos.Rpc.IChangeTeamProto|null);
                get_web_token_proto_1107?: (POGOProtos.Rpc.IGetWebTokenProto|null);
                complete_snapshot_session_proto_1110?: (POGOProtos.Rpc.ICompleteSnapshotSessionProto|null);
                complete_wild_snapshot_session_proto_1111?: (POGOProtos.Rpc.ICompleteWildSnapshotSessionProto|null);
                start_incident_proto_1200?: (POGOProtos.Rpc.IStartIncidentProto|null);
                complete_invasion_dialogue_proto_1201?: (POGOProtos.Rpc.ICompleteInvasionDialogueProto|null);
                open_invasion_combat_session_proto_1202?: (POGOProtos.Rpc.IOpenInvasionCombatSessionProto|null);
                update_invasion_battle_proto_1203?: (POGOProtos.Rpc.IUpdateInvasionBattleProto|null);
                invasion_encounter_proto_1204?: (POGOProtos.Rpc.IInvasionEncounterProto|null);
                purifypokemonproto_1205?: (POGOProtos.Rpc.IPurifyPokemonProto|null);
                get_rocket_balloon_proto_1206?: (POGOProtos.Rpc.IGetRocketBalloonProto|null);
                start_rocket_balloon_incident_proto_1207?: (POGOProtos.Rpc.IStartRocketBalloonIncidentProto|null);
                vs_seeker_start_matchmaking_proto_1300?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingProto|null);
                cancel_matchmaking_proto_1301?: (POGOProtos.Rpc.ICancelMatchmakingProto|null);
                get_matchmaking_status_proto_1302?: (POGOProtos.Rpc.IGetMatchmakingStatusProto|null);
                complete_vs_seeker_and_restartcharging_proto_1303?: (POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingProto|null);
                get_vs_seeker_status_proto_1304?: (POGOProtos.Rpc.IGetVsSeekerStatusProto|null);
                completecompetitive_season_proto_1305?: (POGOProtos.Rpc.ICompleteCompetitiveSeasonProto|null);
                claim_vs_seeker_rewards_proto_1306?: (POGOProtos.Rpc.IClaimVsSeekerRewardsProto|null);
                vs_seeker_reward_encounter_proto_1307?: (POGOProtos.Rpc.IVsSeekerRewardEncounterProto|null);
                activate_vs_seeker_proto_1308?: (POGOProtos.Rpc.IActivateVsSeekerProto|null);
                buddy_map_proto_1350?: (POGOProtos.Rpc.IBuddyMapProto|null);
                buddy_stats_proto_1351?: (POGOProtos.Rpc.IBuddyStatsProto|null);
                buddy_feeding_proto_1352?: (POGOProtos.Rpc.IBuddyFeedingProto|null);
                open_buddy_gift_proto_1353?: (POGOProtos.Rpc.IOpenBuddyGiftProto|null);
                buddy_petting_proto_1354?: (POGOProtos.Rpc.IBuddyPettingProto|null);
                get_buddy_history_proto_1355?: (POGOProtos.Rpc.IGetBuddyHistoryProto|null);
                update_route_draft_proto_1400?: (POGOProtos.Rpc.IUpdateRouteDraftProto|null);
                get_map_forts_proto_1401?: (POGOProtos.Rpc.IGetMapFortsProto|null);
                submit_route_draft_proto_1402?: (POGOProtos.Rpc.ISubmitRouteDraftProto|null);
                get_published_routes_proto_1403?: (POGOProtos.Rpc.IGetPublishedRoutesProto|null);
                start_route_proto_1404?: (POGOProtos.Rpc.IStartRouteProto|null);
                get_routes_proto_1405?: (POGOProtos.Rpc.IGetRoutesProto|null);
                progress_routeproto_1406?: (POGOProtos.Rpc.IProgressRouteProto|null);
                process_tappableproto_1408?: (POGOProtos.Rpc.IProcessTappableProto|null);
                list_route_badges_proto_1409?: (POGOProtos.Rpc.IListRouteBadgesProto|null);
                cancel_route_proto_1410?: (POGOProtos.Rpc.ICancelRouteProto|null);
                list_route_stamps_proto_1411?: (POGOProtos.Rpc.IListRouteStampsProto|null);
                rateroute_proto_1412?: (POGOProtos.Rpc.IRateRouteProto|null);
                create_route_draft_proto_1413?: (POGOProtos.Rpc.ICreateRouteDraftProto|null);
                delete_routedraft_proto_1414?: (POGOProtos.Rpc.IDeleteRouteDraftProto|null);
                reportroute_proto_1415?: (POGOProtos.Rpc.IReportRouteProto|null);
                process_tappableproto_1416?: (POGOProtos.Rpc.IProcessTappableProto|null);
                attracted_pokemon_encounter_proto_1417?: (POGOProtos.Rpc.IAttractedPokemonEncounterProto|null);
                can_report_route_proto_1418?: (POGOProtos.Rpc.ICanReportRouteProto|null);
                route_update_seen_proto_1420?: (POGOProtos.Rpc.IRouteUpdateSeenProto|null);
                recallroute_draft_proto_1421?: (POGOProtos.Rpc.IRecallRouteDraftProto|null);
                route_nearby_notif_shown_proto_1422?: (POGOProtos.Rpc.IRouteNearbyNotifShownProto|null);
                npc_route_gift_proto_1423?: (POGOProtos.Rpc.INpcRouteGiftProto|null);
                get_route_creations_proto_1424?: (POGOProtos.Rpc.IGetRouteCreationsProto|null);
                appeal_route_proto_1425?: (POGOProtos.Rpc.IAppealRouteProto|null);
                get_route_draft_proto_1426?: (POGOProtos.Rpc.IGetRouteDraftProto|null);
                favorite_route_proto_1427?: (POGOProtos.Rpc.IFavoriteRouteProto|null);
                create_route_shortcode_proto_1428?: (POGOProtos.Rpc.ICreateRouteShortcodeProto|null);
                get_route_by_short_code_proto_1429?: (POGOProtos.Rpc.IGetRouteByShortCodeProto|null);
                create_buddy_multiplayer_session_proto_1456?: (POGOProtos.Rpc.ICreateBuddyMultiplayerSessionProto|null);
                join_buddy_multiplayer_session_proto_1457?: (POGOProtos.Rpc.IJoinBuddyMultiplayerSessionProto|null);
                leave_buddy_multiplayer_session_proto_1458?: (POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionProto|null);
                mega_evolve_pokemon_proto_1502?: (POGOProtos.Rpc.IMegaEvolvePokemonProto|null);
                remote_gift_pingrequest_proto_1503?: (POGOProtos.Rpc.IRemoteGiftPingRequestProto|null);
                send_raid_invitation_proto_1504?: (POGOProtos.Rpc.ISendRaidInvitationProto|null);
                send_bread_battle_invitation_proto_1505?: (POGOProtos.Rpc.ISendBreadBattleInvitationProto|null);
                get_daily_encounter_proto_1601?: (POGOProtos.Rpc.IGetDailyEncounterProto|null);
                daily_encounter_proto_1602?: (POGOProtos.Rpc.IDailyEncounterProto|null);
                open_sponsored_gift_proto_1650?: (POGOProtos.Rpc.IOpenSponsoredGiftProto|null);
                report_ad_interaction_proto_1651?: (POGOProtos.Rpc.IReportAdInteractionProto|null);
                save_player_preferences_proto_1652?: (POGOProtos.Rpc.ISavePlayerPreferencesProto|null);
                profanity_checkproto_1653?: (POGOProtos.Rpc.IProfanityCheckProto|null);
                get_timedgroup_challenge_proto_1700?: (POGOProtos.Rpc.IGetTimedGroupChallengeProto|null);
                get_nintendo_account_proto_1710?: (POGOProtos.Rpc.IGetNintendoAccountProto|null);
                unlink_nintendo_account_proto_1711?: (POGOProtos.Rpc.IUnlinkNintendoAccountProto|null);
                get_nintendo_o_auth2_url_proto_1712?: (POGOProtos.Rpc.IGetNintendoOAuth2UrlProto|null);
                transfer_pokemonto_pokemon_home_proto_1713?: (POGOProtos.Rpc.ITransferPokemonToPokemonHomeProto|null);
                report_ad_feedbackrequest_1716?: (POGOProtos.Rpc.IReportAdFeedbackRequest|null);
                create_pokemon_tag_proto_1717?: (POGOProtos.Rpc.ICreatePokemonTagProto|null);
                delete_pokemon_tag_proto_1718?: (POGOProtos.Rpc.IDeletePokemonTagProto|null);
                edit_pokemon_tag_proto_1719?: (POGOProtos.Rpc.IEditPokemonTagProto|null);
                set_pokemon_tags_for_pokemon_proto_1720?: (POGOProtos.Rpc.ISetPokemonTagsForPokemonProto|null);
                get_pokemon_tags_proto_1721?: (POGOProtos.Rpc.IGetPokemonTagsProto|null);
                change_pokemon_form_proto_1722?: (POGOProtos.Rpc.IChangePokemonFormProto|null);
                choose_global_ticketed_event_variant_proto_1723?: (POGOProtos.Rpc.IChooseGlobalTicketedEventVariantProto|null);
                butterfly_collector_reward_encounter_proto_request_1724?: (POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoRequest|null);
                get_additional_pokemon_details_proto_1725?: (POGOProtos.Rpc.IGetAdditionalPokemonDetailsProto|null);
                create_route_pin_proto_1726?: (POGOProtos.Rpc.ICreateRoutePinProto|null);
                like_route_pin_proto_1727?: (POGOProtos.Rpc.ILikeRoutePinProto|null);
                view_route_pin_proto_1728?: (POGOProtos.Rpc.IViewRoutePinProto|null);
                get_referral_code_proto_1800?: (POGOProtos.Rpc.IGetReferralCodeProto|null);
                add_referrer_proto_1801?: (POGOProtos.Rpc.IAddReferrerProto|null);
                send_friend_invite_via_referral_code_proto_1802?: (POGOProtos.Rpc.ISendFriendInviteViaReferralCodeProto|null);
                get_milestones_proto_1803?: (POGOProtos.Rpc.IGetMilestonesProto|null);
                markmilestone_as_viewed_proto_1804?: (POGOProtos.Rpc.IMarkMilestoneAsViewedProto|null);
                get_milestones_preview_proto_1805?: (POGOProtos.Rpc.IGetMilestonesPreviewProto|null);
                complete_milestone_proto_1806?: (POGOProtos.Rpc.ICompleteMilestoneProto|null);
                getgeofenced_ad_proto_1820?: (POGOProtos.Rpc.IGetGeofencedAdProto|null);
                power_uppokestop_encounterproto_1900?: (POGOProtos.Rpc.IPowerUpPokestopEncounterProto|null);
                get_player_stamp_collections_proto_1901?: (POGOProtos.Rpc.IGetPlayerStampCollectionsProto|null);
                savestamp_proto_1902?: (POGOProtos.Rpc.ISaveStampProto|null);
                claim_stampcollection_reward_proto_1904?: (POGOProtos.Rpc.IClaimStampCollectionRewardProto|null);
                change_stampcollection_player_data_proto_1905?: (POGOProtos.Rpc.IChangeStampCollectionPlayerDataProto|null);
                check_stamp_giftability_proto_1906?: (POGOProtos.Rpc.ICheckStampGiftabilityProto|null);
                delete_postcards_proto_1909?: (POGOProtos.Rpc.IDeletePostcardsProto|null);
                create_postcard_proto_1910?: (POGOProtos.Rpc.ICreatePostcardProto|null);
                update_postcard_proto_1911?: (POGOProtos.Rpc.IUpdatePostcardProto|null);
                delete_postcard_proto_1912?: (POGOProtos.Rpc.IDeletePostcardProto|null);
                get_memento_list_proto_1913?: (POGOProtos.Rpc.IGetMementoListProto|null);
                upload_raid_client_log_proto_1914?: (POGOProtos.Rpc.IUploadRaidClientLogProto|null);
                skip_enter_referral_code_proto_1915?: (POGOProtos.Rpc.ISkipEnterReferralCodeProto|null);
                upload_combat_client_log_proto_1916?: (POGOProtos.Rpc.IUploadCombatClientLogProto|null);
                combat_sync_server_offset_proto_1917?: (POGOProtos.Rpc.ICombatSyncServerOffsetProto|null);
                check_gifting_eligibility_proto_2000?: (POGOProtos.Rpc.ICheckGiftingEligibilityProto|null);
                redeem_ticket_gift_for_friend_proto_2001?: (POGOProtos.Rpc.IRedeemTicketGiftForFriendProto|null);
                get_incense_recap_proto_2002?: (POGOProtos.Rpc.IGetIncenseRecapProto|null);
                acknowledge_view_latest_incense_recap_proto_2003?: (POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapProto|null);
                boot_raid_proto_2004?: (POGOProtos.Rpc.IBootRaidProto|null);
                get_pokestop_encounter_proto_2005?: (POGOProtos.Rpc.IGetPokestopEncounterProto|null);
                encounter_pokestopencounter_proto_2006?: (POGOProtos.Rpc.IEncounterPokestopEncounterProto|null);
                player_spawnablepokemonproto_2007?: (POGOProtos.Rpc.IPlayerSpawnablePokemonProto|null);
                get_quest_ui_proto_2008?: (POGOProtos.Rpc.IGetQuestUiProto|null);
                get_eligible_combat_leagues_proto_2009?: (POGOProtos.Rpc.IGetEligibleCombatLeaguesProto|null);
                send_friend_request_via_player_id_proto_2010?: (POGOProtos.Rpc.ISendFriendRequestViaPlayerIdProto|null);
                get_raid_lobby_counter_proto_2011?: (POGOProtos.Rpc.IGetRaidLobbyCounterProto|null);
                use_non_combat_move_request_proto_2014?: (POGOProtos.Rpc.IUseNonCombatMoveRequestProto|null);
                check_pokemon_size_leaderboard_eligibility_proto_2100?: (POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityProto|null);
                update_pokemon_size_leaderboard_entry_proto_2101?: (POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryProto|null);
                transfer_pokemon_size_leaderboard_entry_proto_2102?: (POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryProto|null);
                remove_pokemon_size_leaderboard_entry_proto_2103?: (POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryProto|null);
                get_pokemon_size_leaderboard_entry_proto_2104?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryProto|null);
                get_contest_data_proto_2105?: (POGOProtos.Rpc.IGetContestDataProto|null);
                get_contests_unclaimed_rewards_proto_2106?: (POGOProtos.Rpc.IGetContestsUnclaimedRewardsProto|null);
                claimcontests_rewards_proto_2107?: (POGOProtos.Rpc.IClaimContestsRewardsProto|null);
                get_entered_contest_proto_2108?: (POGOProtos.Rpc.IGetEnteredContestProto|null);
                get_pokemon_size_leaderboard_friend_entry_proto_2109?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryProto|null);
                checkcontest_eligibility_proto_2150?: (POGOProtos.Rpc.ICheckContestEligibilityProto|null);
                update_contest_entry_proto_2151?: (POGOProtos.Rpc.IUpdateContestEntryProto|null);
                transfer_contest_entry_proto_2152?: (POGOProtos.Rpc.ITransferContestEntryProto|null);
                get_contest_friend_entry_proto_2153?: (POGOProtos.Rpc.IGetContestFriendEntryProto|null);
                get_contest_entry_proto_2154?: (POGOProtos.Rpc.IGetContestEntryProto|null);
                create_party_proto_2300?: (POGOProtos.Rpc.ICreatePartyProto|null);
                join_party_proto_2301?: (POGOProtos.Rpc.IJoinPartyProto|null);
                start_party_proto_2302?: (POGOProtos.Rpc.IStartPartyProto|null);
                leave_party_proto_2303?: (POGOProtos.Rpc.ILeavePartyProto|null);
                get_party_proto_2304?: (POGOProtos.Rpc.IGetPartyProto|null);
                party_update_locationproto_2305?: (POGOProtos.Rpc.IPartyUpdateLocationProto|null);
                party_send_dark_launch_logproto_2306?: (POGOProtos.Rpc.IPartySendDarkLaunchLogProto|null);
                start_party_quest_proto_2308?: (POGOProtos.Rpc.IStartPartyQuestProto|null);
                complete_party_quest_proto_2309?: (POGOProtos.Rpc.ICompletePartyQuestProto|null);
                get_bonus_attracted_pokemon_proto_2350?: (POGOProtos.Rpc.IGetBonusAttractedPokemonProto|null);
                get_bonuses_proto_2352?: (POGOProtos.Rpc.IGetBonusesProto|null);
                badge_reward_encounter_request_proto_2360?: (POGOProtos.Rpc.IBadgeRewardEncounterRequestProto|null);
                npc_update_state_proto_2400?: (POGOProtos.Rpc.INpcUpdateStateProto|null);
                npc_send_gift_proto_2401?: (POGOProtos.Rpc.INpcSendGiftProto|null);
                npc_open_gift_proto_2402?: (POGOProtos.Rpc.INpcOpenGiftProto|null);
                join_bread_lobby_proto_2450?: (POGOProtos.Rpc.IJoinBreadLobbyProto|null);
                prepare_bread_lobbyproto_2453?: (POGOProtos.Rpc.IPrepareBreadLobbyProto|null);
                leave_breadlobby_proto_2455?: (POGOProtos.Rpc.ILeaveBreadLobbyProto|null);
                start_bread_battle_proto_2456?: (POGOProtos.Rpc.IStartBreadBattleProto|null);
                get_bread_lobby_details_proto_2457?: (POGOProtos.Rpc.IGetBreadLobbyDetailsProto|null);
                start_mp_walk_quest_proto_2458?: (POGOProtos.Rpc.IStartMpWalkQuestProto|null);
                enhance_bread_move_proto_2459?: (POGOProtos.Rpc.IEnhanceBreadMoveProto|null);
                station_pokemon_proto_2460?: (POGOProtos.Rpc.IStationPokemonProto|null);
                loot_station_proto_2461?: (POGOProtos.Rpc.ILootStationProto|null);
                get_stationed_pokemon_details_proto_2462?: (POGOProtos.Rpc.IGetStationedPokemonDetailsProto|null);
                mark_save_for_later_proto_2463?: (POGOProtos.Rpc.IMarkSaveForLaterProto|null);
                use_save_for_later_proto_2464?: (POGOProtos.Rpc.IUseSaveForLaterProto|null);
                remove_save_for_later_proto_2465?: (POGOProtos.Rpc.IRemoveSaveForLaterProto|null);
                get_save_for_later_entries_proto_2466?: (POGOProtos.Rpc.IGetSaveForLaterEntriesProto|null);
                get_mp_summary_proto_2467?: (POGOProtos.Rpc.IGetMpSummaryProto|null);
                use_item_mp_replenish_proto_2468?: (POGOProtos.Rpc.IUseItemMpReplenishProto|null);
                report_station_proto_2470?: (POGOProtos.Rpc.IReportStationProto|null);
                debug_resetdaily_mp_progress_proto_2471?: (POGOProtos.Rpc.IDebugResetDailyMpProgressProto|null);
                release_stationed_pokemon_proto_2472?: (POGOProtos.Rpc.IReleaseStationedPokemonProto|null);
                complete_bread_battle_proto_2473?: (POGOProtos.Rpc.ICompleteBreadBattleProto|null);
                encounter_station_spawn_proto_2475?: (POGOProtos.Rpc.IEncounterStationSpawnProto|null);
                get_num_station_assists_proto_2476?: (POGOProtos.Rpc.IGetNumStationAssistsProto|null);
                get_vps_event_proto_3000?: (POGOProtos.Rpc.IGetVpsEventProto|null);
                update_vps_event_proto_3001?: (POGOProtos.Rpc.IUpdateVpsEventProto|null);
                add_ptc_loginaction_proto_3002?: (POGOProtos.Rpc.IAddPtcLoginActionProto|null);
                claim_ptc_linking_reward_proto_3003?: (POGOProtos.Rpc.IClaimPtcLinkingRewardProto|null);
                canclaim_ptc_reward_action_proto_3004?: (POGOProtos.Rpc.ICanClaimPtcRewardActionProto|null);
                contribute_party_item_proto_3005?: (POGOProtos.Rpc.IContributePartyItemProto|null);
                consume_party_items_proto_3006?: (POGOProtos.Rpc.IConsumePartyItemsProto|null);
                remove_ptc_login_action_proto_3007?: (POGOProtos.Rpc.IRemovePtcLoginActionProto|null);
                send_party_invitation_proto_3008?: (POGOProtos.Rpc.ISendPartyInvitationProto|null);
                consume_stickers_proto_3009?: (POGOProtos.Rpc.IConsumeStickersProto|null);
                complete_raid_battle_proto_3010?: (POGOProtos.Rpc.ICompleteRaidBattleProto|null);
                sync_battle_inventory_proto_3011?: (POGOProtos.Rpc.ISyncBattleInventoryProto|null);
                preview_contributeparty_itemproto_3015?: (POGOProtos.Rpc.IPreviewContributePartyItemProto|null);
                kick_other_player_from_party_proto_3016?: (POGOProtos.Rpc.IKickOtherPlayerFromPartyProto|null);
                fuse_pokemon_request_proto_3017?: (POGOProtos.Rpc.IFusePokemonRequestProto|null);
                unfuse_pokemon_request_proto_3018?: (POGOProtos.Rpc.IUnfusePokemonRequestProto|null);
                get_iris_social_scene_proto_3019?: (POGOProtos.Rpc.IGetIrisSocialSceneProto|null);
                update_iris_social_scene_proto_3020?: (POGOProtos.Rpc.IUpdateIrisSocialSceneProto|null);
                get_change_pokemon_form_preview_request_proto_3021?: (POGOProtos.Rpc.IGetChangePokemonFormPreviewRequestProto|null);
                get_unfuse_pokemon_preview_request_proto_3023?: (POGOProtos.Rpc.IGetUnfusePokemonPreviewRequestProto|null);
                processplayer_inboxproto_3024?: (POGOProtos.Rpc.IProcessPlayerInboxProto|null);
                get_survey_eligibility_proto_3025?: (POGOProtos.Rpc.IGetSurveyEligibilityProto|null);
                update_survey_eligibility_proto_3026?: (POGOProtos.Rpc.IUpdateSurveyEligibilityProto|null);
                smart_glassessyncsettings_request_proto_3027?: (POGOProtos.Rpc.ISmartGlassesSyncSettingsRequestProto|null);
                complete_visit_page_quest_proto_3030?: (POGOProtos.Rpc.ICompleteVisitPageQuestProto|null);
                get_event_rsvps_proto_3031?: (POGOProtos.Rpc.IGetEventRsvpsProto|null);
                create_event_rsvp_proto_3032?: (POGOProtos.Rpc.ICreateEventRsvpProto|null);
                cancel_event_rsvp_proto_3033?: (POGOProtos.Rpc.ICancelEventRsvpProto|null);
                claim_event_pass_rewards_request_proto_3034?: (POGOProtos.Rpc.IClaimEventPassRewardsRequestProto|null);
                get_event_rsvp_count_proto_3036?: (POGOProtos.Rpc.IGetEventRsvpCountProto|null);
                send_event_rsvp_invitation_proto_3039?: (POGOProtos.Rpc.ISendEventRsvpInvitationProto|null);
                update_event_rsvp_selection_proto_3040?: (POGOProtos.Rpc.IUpdateEventRsvpSelectionProto|null);
                get_station_info_proto_3051?: (POGOProtos.Rpc.IGetStationInfoProto|null);
                age_confirmation_proto_3052?: (POGOProtos.Rpc.IAgeConfirmationProto|null);
                change_stat_increase_goal_proto_3053?: (POGOProtos.Rpc.IChangeStatIncreaseGoalProto|null);
                push_notification_registryproto_5000?: (POGOProtos.Rpc.IPushNotificationRegistryProto|null);
                update_notification_proto_5002?: (POGOProtos.Rpc.IUpdateNotificationProto|null);
                download_gm_templates_request_proto_5004?: (POGOProtos.Rpc.IDownloadGmTemplatesRequestProto|null);
                get_inventory_proto_5005?: (POGOProtos.Rpc.IGetInventoryProto|null);
                redeem_passcoderequest_proto_5006?: (POGOProtos.Rpc.IRedeemPasscodeRequestProto|null);
                ping_requestproto_5007?: (POGOProtos.Rpc.IPingRequestProto|null);
                add_loginaction_proto_5008?: (POGOProtos.Rpc.IAddLoginActionProto|null);
                remove_login_action_proto_5009?: (POGOProtos.Rpc.IRemoveLoginActionProto|null);
                submit_new_poi_proto_5011?: (POGOProtos.Rpc.ISubmitNewPoiProto|null);
                proxy_requestproto_5012?: (POGOProtos.Rpc.IProxyRequestProto|null);
                get_available_submissions_proto_5014?: (POGOProtos.Rpc.IGetAvailableSubmissionsProto|null);
                replace_login_action_proto_5015?: (POGOProtos.Rpc.IReplaceLoginActionProto|null);
                client_telemetry_batch_proto_5018?: (POGOProtos.Rpc.IClientTelemetryBatchProto|null);
                iap_purchase_sku_proto_5019?: (POGOProtos.Rpc.IIapPurchaseSkuProto|null);
                iap_get_available_skus_and_balances_proto_5020?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesProto|null);
                iap_redeem_google_receipt_proto_5021?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptProto|null);
                iap_redeem_apple_receipt_proto_5022?: (POGOProtos.Rpc.IIapRedeemAppleReceiptProto|null);
                iap_redeem_desktop_receipt_proto_5023?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptProto|null);
                fitness_update_proto_5024?: (POGOProtos.Rpc.IFitnessUpdateProto|null);
                get_fitness_report_proto_5025?: (POGOProtos.Rpc.IGetFitnessReportProto|null);
                client_telemetry_settings_request_proto_5026?: (POGOProtos.Rpc.IClientTelemetrySettingsRequestProto|null);
                auth_register_background_deviceaction_proto_5028?: (POGOProtos.Rpc.IAuthRegisterBackgroundDeviceActionProto|null);
                internal_setin_game_currency_exchange_rate_proto_5032?: (POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateProto|null);
                geofence_update_proto_5033?: (POGOProtos.Rpc.IGeofenceUpdateProto|null);
                location_ping_proto_5034?: (POGOProtos.Rpc.ILocationPingProto|null);
                generategmap_signed_url_proto_5035?: (POGOProtos.Rpc.IGenerateGmapSignedUrlProto|null);
                getgmap_settings_proto_5036?: (POGOProtos.Rpc.IGetGmapSettingsProto|null);
                iap_redeem_samsung_receipt_proto_5037?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptProto|null);
                get_outstanding_warnings_request_proto_5039?: (POGOProtos.Rpc.IGetOutstandingWarningsRequestProto|null);
                acknowledge_warnings_request_proto_5040?: (POGOProtos.Rpc.IAcknowledgeWarningsRequestProto|null);
                titan_submit_poi_image_proto_5041?: (POGOProtos.Rpc.ITitanSubmitPoiImageProto|null);
                titan_submit_poitext_metadata_update_proto_5042?: (POGOProtos.Rpc.ITitanSubmitPoiTextMetadataUpdateProto|null);
                titan_submit_poi_location_update_proto_5043?: (POGOProtos.Rpc.ITitanSubmitPoiLocationUpdateProto|null);
                titan_submit_poitakedown_request_proto_5044?: (POGOProtos.Rpc.ITitanSubmitPoiTakedownRequestProto|null);
                get_web_token_proto_5045?: (POGOProtos.Rpc.IGetWebTokenProto|null);
                get_adventure_sync_settings_request_proto_5046?: (POGOProtos.Rpc.IGetAdventureSyncSettingsRequestProto|null);
                update_adventure_sync_settings_request_proto_5047?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsRequestProto|null);
                set_birthday_request_proto_5048?: (POGOProtos.Rpc.ISetBirthdayRequestProto|null);
                platform_fetch_newsfeed_request_5049?: (POGOProtos.Rpc.IPlatformFetchNewsfeedRequest|null);
                platform_mark_newsfeed_read_request_5050?: (POGOProtos.Rpc.IPlatformMarkNewsfeedReadRequest|null);
                internal_search_player_proto_10000?: (POGOProtos.Rpc.IInternalSearchPlayerProto|null);
                internal_send_friendinvite_proto_10002?: (POGOProtos.Rpc.IInternalSendFriendInviteProto|null);
                internal_cancel_friendinvite_proto_10003?: (POGOProtos.Rpc.IInternalCancelFriendInviteProto|null);
                internal_accept_friendinvite_proto_10004?: (POGOProtos.Rpc.IInternalAcceptFriendInviteProto|null);
                internal_decline_friendinvite_proto_10005?: (POGOProtos.Rpc.IInternalDeclineFriendInviteProto|null);
                internal_get_friends_list_proto_10006?: (POGOProtos.Rpc.IInternalGetFriendsListProto|null);
                internal_get_outgoing_friendinvites_proto_10007?: (POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesProto|null);
                internal_getincoming_friendinvites_proto_10008?: (POGOProtos.Rpc.IInternalGetIncomingFriendInvitesProto|null);
                internal_remove_friend_proto_10009?: (POGOProtos.Rpc.IInternalRemoveFriendProto|null);
                internal_get_friend_details_proto_10010?: (POGOProtos.Rpc.IInternalGetFriendDetailsProto|null);
                internalinvite_facebook_friend_proto_10011?: (POGOProtos.Rpc.IInternalInviteFacebookFriendProto|null);
                internalis_my_friend_proto_10012?: (POGOProtos.Rpc.IInternalIsMyFriendProto|null);
                internal_get_friend_code_proto_10013?: (POGOProtos.Rpc.IInternalGetFriendCodeProto|null);
                internal_get_facebook_friend_list_proto_10014?: (POGOProtos.Rpc.IInternalGetFacebookFriendListProto|null);
                internal_update_facebook_status_proto_10015?: (POGOProtos.Rpc.IInternalUpdateFacebookStatusProto|null);
                savesocial_playersettings_proto_10016?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsProto|null);
                internal_get_player_settings_proto_10017?: (POGOProtos.Rpc.IInternalGetPlayerSettingsProto|null);
                internal_set_account_settings_proto_10021?: (POGOProtos.Rpc.IInternalSetAccountSettingsProto|null);
                internal_get_account_settings_proto_10022?: (POGOProtos.Rpc.IInternalGetAccountSettingsProto|null);
                internal_add_favorite_friend_request_10023?: (POGOProtos.Rpc.IInternalAddFavoriteFriendRequest|null);
                internal_remove_favorite_friend_request_10024?: (POGOProtos.Rpc.IInternalRemoveFavoriteFriendRequest|null);
                internal_block_account_proto_10025?: (POGOProtos.Rpc.IInternalBlockAccountProto|null);
                internal_unblock_account_proto_10026?: (POGOProtos.Rpc.IInternalUnblockAccountProto|null);
                internal_get_outgoing_blocks_proto_10027?: (POGOProtos.Rpc.IInternalGetOutgoingBlocksProto|null);
                internalis_account_blocked_proto_10028?: (POGOProtos.Rpc.IInternalIsAccountBlockedProto|null);
                list_friend_activities_request_proto_10029?: (POGOProtos.Rpc.IListFriendActivitiesRequestProto|null);
                internal_push_notification_registry_proto_10101?: (POGOProtos.Rpc.IInternalPushNotificationRegistryProto|null);
                internal_update_notification_proto_10103?: (POGOProtos.Rpc.IInternalUpdateNotificationProto|null);
                get_inbox_proto_10105?: (POGOProtos.Rpc.IGetInboxProto|null);
                internal_list_opt_out_notification_categories_request_proto_10106?: (POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesRequestProto|null);
                internal_get_signed_url_proto_10201?: (POGOProtos.Rpc.IInternalGetSignedUrlProto|null);
                internal_submitimage_proto_10202?: (POGOProtos.Rpc.IInternalSubmitImageProto|null);
                internal_get_photos_proto_10203?: (POGOProtos.Rpc.IInternalGetPhotosProto|null);
                internal_update_profile_request_20001?: (POGOProtos.Rpc.IInternalUpdateProfileRequest|null);
                internal_update_friendship_request_20002?: (POGOProtos.Rpc.IInternalUpdateFriendshipRequest|null);
                internal_get_profile_request_20003?: (POGOProtos.Rpc.IInternalGetProfileRequest|null);
                internalinvite_game_request_20004?: (POGOProtos.Rpc.IInternalInviteGameRequest|null);
                internal_list_friends_request_20006?: (POGOProtos.Rpc.IInternalListFriendsRequest|null);
                internal_get_friend_details_proto_20007?: (POGOProtos.Rpc.IInternalGetFriendDetailsProto|null);
                internal_get_client_feature_flags_request_20008?: (POGOProtos.Rpc.IInternalGetClientFeatureFlagsRequest|null);
                internal_getincoming_gameinvites_request_20010?: (POGOProtos.Rpc.IInternalGetIncomingGameInvitesRequest|null);
                internal_updateincoming_gameinvite_request_20011?: (POGOProtos.Rpc.IInternalUpdateIncomingGameInviteRequest|null);
                internal_dismiss_outgoing_gameinvites_request_20012?: (POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesRequest|null);
                internal_sync_contact_list_request_20013?: (POGOProtos.Rpc.IInternalSyncContactListRequest|null);
                internal_send_contact_list_friendinvite_request_20014?: (POGOProtos.Rpc.IInternalSendContactListFriendInviteRequest|null);
                internal_refer_contact_list_friend_request_20015?: (POGOProtos.Rpc.IInternalReferContactListFriendRequest|null);
                internal_get_contact_listinfo_request_20016?: (POGOProtos.Rpc.IInternalGetContactListInfoRequest|null);
                internal_dismiss_contact_list_update_request_20017?: (POGOProtos.Rpc.IInternalDismissContactListUpdateRequest|null);
                internal_notify_contact_list_friends_request_20018?: (POGOProtos.Rpc.IInternalNotifyContactListFriendsRequest|null);
                internal_get_friend_recommendation_request_20500?: (POGOProtos.Rpc.IInternalGetFriendRecommendationRequest|null);
                get_outstanding_warnings_request_proto_200000?: (POGOProtos.Rpc.IGetOutstandingWarningsRequestProto|null);
                acknowledge_warnings_request_proto_200001?: (POGOProtos.Rpc.IAcknowledgeWarningsRequestProto|null);
                register_background_device_action_proto_230000?: (POGOProtos.Rpc.IRegisterBackgroundDeviceActionProto|null);
                get_adventure_sync_progress_proto_230002?: (POGOProtos.Rpc.IGetAdventureSyncProgressProto|null);
                iap_purchase_sku_proto_310000?: (POGOProtos.Rpc.IIapPurchaseSkuProto|null);
                iap_get_available_skus_and_balances_proto_310001?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesProto|null);
                iap_setin_game_currency_exchange_rate_proto_310002?: (POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateProto|null);
                iap_redeem_google_receipt_proto_310100?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptProto|null);
                iap_redeem_apple_receipt_proto_310101?: (POGOProtos.Rpc.IIapRedeemAppleReceiptProto|null);
                iap_redeem_desktop_receipt_proto_310102?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptProto|null);
                iap_redeem_samsung_receipt_proto_310103?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptProto|null);
                iap_get_available_subscriptions_request_proto_310200?: (POGOProtos.Rpc.IIapGetAvailableSubscriptionsRequestProto|null);
                iap_get_active_subscriptions_request_proto_310201?: (POGOProtos.Rpc.IIapGetActiveSubscriptionsRequestProto|null);
                get_reward_tiers_request_proto_310300?: (POGOProtos.Rpc.IGetRewardTiersRequestProto|null);
                iap_redeem_xsolla_receipt_request_proto_311100?: (POGOProtos.Rpc.IIapRedeemXsollaReceiptRequestProto|null);
                iap_get_user_request_proto_311101?: (POGOProtos.Rpc.IIapGetUserRequestProto|null);
                geofence_update_proto_360000?: (POGOProtos.Rpc.IGeofenceUpdateProto|null);
                location_ping_proto_360001?: (POGOProtos.Rpc.ILocationPingProto|null);
                update_bulk_player_location_request_proto_360002?: (POGOProtos.Rpc.IUpdateBulkPlayerLocationRequestProto|null);
                update_breadcrumb_history_request_proto_361000?: (POGOProtos.Rpc.IUpdateBreadcrumbHistoryRequestProto|null);
                refresh_proximity_tokensrequest_proto_362000?: (POGOProtos.Rpc.IRefreshProximityTokensRequestProto|null);
                report_proximity_contactsrequest_proto_362001?: (POGOProtos.Rpc.IReportProximityContactsRequestProto|null);
                internal_add_login_action_proto_600000?: (POGOProtos.Rpc.IInternalAddLoginActionProto|null);
                internal_remove_login_action_proto_600001?: (POGOProtos.Rpc.IInternalRemoveLoginActionProto|null);
                internal_replace_login_action_proto_600003?: (POGOProtos.Rpc.IInternalReplaceLoginActionProto|null);
                internal_set_birthday_request_proto_600004?: (POGOProtos.Rpc.IInternalSetBirthdayRequestProto|null);
                internal_gar_proxy_request_proto_600005?: (POGOProtos.Rpc.IInternalGarProxyRequestProto|null);
                internal_link_to_account_login_request_proto_600006?: (POGOProtos.Rpc.IInternalLinkToAccountLoginRequestProto|null);
                titan_submit_new_poi_proto_620000?: (POGOProtos.Rpc.ITitanSubmitNewPoiProto|null);
                titan_get_available_submissions_proto_620001?: (POGOProtos.Rpc.ITitanGetAvailableSubmissionsProto|null);
                titan_get_player_submission_validation_settings_proto_620003?: (POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsProto|null);
                titan_submit_poi_image_proto_620100?: (POGOProtos.Rpc.ITitanSubmitPoiImageProto|null);
                titan_submit_poitext_metadata_update_proto_620101?: (POGOProtos.Rpc.ITitanSubmitPoiTextMetadataUpdateProto|null);
                titan_submit_poi_location_update_proto_620102?: (POGOProtos.Rpc.ITitanSubmitPoiLocationUpdateProto|null);
                titan_submit_poitakedown_request_proto_620103?: (POGOProtos.Rpc.ITitanSubmitPoiTakedownRequestProto|null);
                titan_submit_sponsor_poi_report_proto_620104?: (POGOProtos.Rpc.ITitanSubmitSponsorPoiReportProto|null);
                titan_submit_sponsor_poi_location_update_proto_620105?: (POGOProtos.Rpc.ITitanSubmitSponsorPoiLocationUpdateProto|null);
                titan_submit_poi_category_vote_record_proto_620106?: (POGOProtos.Rpc.ITitanSubmitPoiCategoryVoteRecordProto|null);
                titan_generate_gmap_signed_url_proto_620300?: (POGOProtos.Rpc.ITitanGenerateGmapSignedUrlProto|null);
                titan_get_gmap_settings_proto_620301?: (POGOProtos.Rpc.ITitanGetGmapSettingsProto|null);
                titan_poi_video_submission_metadata_proto_620400?: (POGOProtos.Rpc.ITitanPoiVideoSubmissionMetadataProto|null);
                titan_get_grapeshot_upload_url_proto_620401?: (POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlProto|null);
                titan_async_file_upload_complete_proto_620402?: (POGOProtos.Rpc.ITitanAsyncFileUploadCompleteProto|null);
                titan_get_a_r_mapping_settings_proto_620403?: (POGOProtos.Rpc.ITitanGetARMappingSettingsProto|null);
                titan_get_images_for_poi_proto_620500?: (POGOProtos.Rpc.ITitanGetImagesForPoiProto|null);
                titan_submit_player_image_vote_for_poi_proto_620501?: (POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiProto|null);
                titan_get_image_gallery_settings_proto_620502?: (POGOProtos.Rpc.ITitanGetImageGallerySettingsProto|null);
                get_maptiles_settings_request_620600?: (POGOProtos.Rpc.IGetMaptilesSettingsRequest|null);
                titan_get_pois_in_radius_proto_620601?: (POGOProtos.Rpc.ITitanGetPoisInRadiusProto|null);
                fitness_update_proto_640000?: (POGOProtos.Rpc.IFitnessUpdateProto|null);
                get_fitness_report_proto_640001?: (POGOProtos.Rpc.IGetFitnessReportProto|null);
                get_adventure_sync_settings_request_proto_640002?: (POGOProtos.Rpc.IGetAdventureSyncSettingsRequestProto|null);
                update_adventure_sync_settings_request_proto_640003?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsRequestProto|null);
                update_adventure_sync_fitness_request_proto_640004?: (POGOProtos.Rpc.IUpdateAdventureSyncFitnessRequestProto|null);
                get_adventure_sync_fitness_report_request_proto_640005?: (POGOProtos.Rpc.IGetAdventureSyncFitnessReportRequestProto|null);
            }

            class AllMessagesProto implements IAllMessagesProto {
                constructor(properties?: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IAllMessagesProto);
                public get_player_proto_2?: (POGOProtos.Rpc.IGetPlayerProto|null);
                public get_holoholo_inventory_proto_4?: (POGOProtos.Rpc.IGetHoloholoInventoryProto|null);
                public download_settings_action_proto_5?: (POGOProtos.Rpc.IDownloadSettingsActionProto|null);
                public getgame_master_client_templates_proto_6?: (POGOProtos.Rpc.IGetGameMasterClientTemplatesProto|null);
                public get_remote_config_versions_proto_7?: (POGOProtos.Rpc.IGetRemoteConfigVersionsProto|null);
                public register_background_device_action_proto_8?: (POGOProtos.Rpc.IRegisterBackgroundDeviceActionProto|null);
                public get_player_day_proto_9?: (POGOProtos.Rpc.IGetPlayerDayProto|null);
                public acknowledge_punishment_proto_10?: (POGOProtos.Rpc.IAcknowledgePunishmentProto|null);
                public get_server_time_proto_11?: (POGOProtos.Rpc.IGetServerTimeProto|null);
                public get_local_time_proto_12?: (POGOProtos.Rpc.IGetLocalTimeProto|null);
                public set_playerstatus_proto_20?: (POGOProtos.Rpc.ISetPlayerStatusProto|null);
                public getgame_config_versions_proto_21?: (POGOProtos.Rpc.IGetGameConfigVersionsProto|null);
                public get_playergps_bookmarks_proto_22?: (POGOProtos.Rpc.IGetPlayerGpsBookmarksProto|null);
                public update_player_gps_bookmarks_proto_23?: (POGOProtos.Rpc.IUpdatePlayerGpsBookmarksProto|null);
                public fort_search_proto_101?: (POGOProtos.Rpc.IFortSearchProto|null);
                public encounter_proto_102?: (POGOProtos.Rpc.IEncounterProto|null);
                public catch_pokemon_proto_103?: (POGOProtos.Rpc.ICatchPokemonProto|null);
                public fort_details_proto_104?: (POGOProtos.Rpc.IFortDetailsProto|null);
                public get_map_objects_proto_106?: (POGOProtos.Rpc.IGetMapObjectsProto|null);
                public fort_deploy_proto_110?: (POGOProtos.Rpc.IFortDeployProto|null);
                public fort_recall_proto_111?: (POGOProtos.Rpc.IFortRecallProto|null);
                public release_pokemon_proto_112?: (POGOProtos.Rpc.IReleasePokemonProto|null);
                public use_item_potion_proto_113?: (POGOProtos.Rpc.IUseItemPotionProto|null);
                public use_item_capture_proto_114?: (POGOProtos.Rpc.IUseItemCaptureProto|null);
                public use_item_revive_proto_116?: (POGOProtos.Rpc.IUseItemReviveProto|null);
                public playerprofileproto_121?: (POGOProtos.Rpc.IPlayerProfileProto|null);
                public evolve_pokemon_proto_125?: (POGOProtos.Rpc.IEvolvePokemonProto|null);
                public get_hatched_eggs_proto_126?: (POGOProtos.Rpc.IGetHatchedEggsProto|null);
                public encounter_tutorial_complete_proto_127?: (POGOProtos.Rpc.IEncounterTutorialCompleteProto|null);
                public level_up_rewards_proto_128?: (POGOProtos.Rpc.ILevelUpRewardsProto|null);
                public check_awarded_badges_proto_129?: (POGOProtos.Rpc.ICheckAwardedBadgesProto|null);
                public recycle_item_proto_137?: (POGOProtos.Rpc.IRecycleItemProto|null);
                public collect_daily_bonus_proto_138?: (POGOProtos.Rpc.ICollectDailyBonusProto|null);
                public use_item_xp_boost_proto_139?: (POGOProtos.Rpc.IUseItemXpBoostProto|null);
                public use_item_egg_incubator_proto_140?: (POGOProtos.Rpc.IUseItemEggIncubatorProto|null);
                public use_incense_action_proto_141?: (POGOProtos.Rpc.IUseIncenseActionProto|null);
                public get_incense_pokemon_proto_142?: (POGOProtos.Rpc.IGetIncensePokemonProto|null);
                public incense_encounter_proto_143?: (POGOProtos.Rpc.IIncenseEncounterProto|null);
                public add_fort_modifier_proto_144?: (POGOProtos.Rpc.IAddFortModifierProto|null);
                public disk_encounter_proto_145?: (POGOProtos.Rpc.IDiskEncounterProto|null);
                public upgrade_pokemon_proto_147?: (POGOProtos.Rpc.IUpgradePokemonProto|null);
                public set_favorite_pokemon_proto_148?: (POGOProtos.Rpc.ISetFavoritePokemonProto|null);
                public nickname_pokemon_proto_149?: (POGOProtos.Rpc.INicknamePokemonProto|null);
                public set_contactsettings_proto_151?: (POGOProtos.Rpc.ISetContactSettingsProto|null);
                public set_buddy_pokemon_proto_152?: (POGOProtos.Rpc.ISetBuddyPokemonProto|null);
                public get_buddy_walked_proto_153?: (POGOProtos.Rpc.IGetBuddyWalkedProto|null);
                public use_item_encounter_proto_154?: (POGOProtos.Rpc.IUseItemEncounterProto|null);
                public gym_deploy_proto_155?: (POGOProtos.Rpc.IGymDeployProto|null);
                public gymget_info_proto_156?: (POGOProtos.Rpc.IGymGetInfoProto|null);
                public gym_start_session_proto_157?: (POGOProtos.Rpc.IGymStartSessionProto|null);
                public gym_battle_attack_proto_158?: (POGOProtos.Rpc.IGymBattleAttackProto|null);
                public join_lobby_proto_159?: (POGOProtos.Rpc.IJoinLobbyProto|null);
                public leavelobby_proto_160?: (POGOProtos.Rpc.ILeaveLobbyProto|null);
                public set_lobby_visibility_proto_161?: (POGOProtos.Rpc.ISetLobbyVisibilityProto|null);
                public set_lobby_pokemon_proto_162?: (POGOProtos.Rpc.ISetLobbyPokemonProto|null);
                public get_raid_details_proto_163?: (POGOProtos.Rpc.IGetRaidDetailsProto|null);
                public gym_feed_pokemon_proto_164?: (POGOProtos.Rpc.IGymFeedPokemonProto|null);
                public start_raid_battle_proto_165?: (POGOProtos.Rpc.IStartRaidBattleProto|null);
                public attack_raid_battle_proto_166?: (POGOProtos.Rpc.IAttackRaidBattleProto|null);
                public use_item_stardust_boost_proto_168?: (POGOProtos.Rpc.IUseItemStardustBoostProto|null);
                public reassign_player_proto_169?: (POGOProtos.Rpc.IReassignPlayerProto|null);
                public convertcandy_to_xlcandy_proto_171?: (POGOProtos.Rpc.IConvertCandyToXlCandyProto|null);
                public is_sku_available_proto_172?: (POGOProtos.Rpc.IIsSkuAvailableProto|null);
                public use_item_bulk_heal_proto_173?: (POGOProtos.Rpc.IUseItemBulkHealProto|null);
                public use_item_battle_boost_proto_174?: (POGOProtos.Rpc.IUseItemBattleBoostProto|null);
                public use_item_lucky_friend_applicator_proto_175?: (POGOProtos.Rpc.IUseItemLuckyFriendApplicatorProto|null);
                public use_item_stat_increase_proto_176?: (POGOProtos.Rpc.IUseItemStatIncreaseProto|null);
                public asset_digest_request_proto_300?: (POGOProtos.Rpc.IAssetDigestRequestProto|null);
                public download_url_request_proto_301?: (POGOProtos.Rpc.IDownloadUrlRequestProto|null);
                public asset_version_proto_302?: (POGOProtos.Rpc.IAssetVersionProto|null);
                public claimcodename_request_proto_403?: (POGOProtos.Rpc.IClaimCodenameRequestProto|null);
                public set_avatar_proto_404?: (POGOProtos.Rpc.ISetAvatarProto|null);
                public set_player_team_proto_405?: (POGOProtos.Rpc.ISetPlayerTeamProto|null);
                public mark_tutorial_complete_proto_406?: (POGOProtos.Rpc.IMarkTutorialCompleteProto|null);
                public set_neutral_avatar_proto_408?: (POGOProtos.Rpc.ISetNeutralAvatarProto|null);
                public list_avatar_store_items_proto_409?: (POGOProtos.Rpc.IListAvatarStoreItemsProto|null);
                public list_avatar_appearance_items_proto_410?: (POGOProtos.Rpc.IListAvatarAppearanceItemsProto|null);
                public neutral_avatar_badge_reward_proto_450?: (POGOProtos.Rpc.INeutralAvatarBadgeRewardProto|null);
                public checkchallenge_proto_600?: (POGOProtos.Rpc.ICheckChallengeProto|null);
                public verify_challenge_proto_601?: (POGOProtos.Rpc.IVerifyChallengeProto|null);
                public echo_proto_666?: (POGOProtos.Rpc.IEchoProto|null);
                public register_sfidarequest_800?: (POGOProtos.Rpc.IRegisterSfidaRequest|null);
                public sfida_certification_request_802?: (POGOProtos.Rpc.ISfidaCertificationRequest|null);
                public sfida_update_request_803?: (POGOProtos.Rpc.ISfidaUpdateRequest|null);
                public sfida_dowser_request_805?: (POGOProtos.Rpc.ISfidaDowserRequest|null);
                public sfida_capture_request_806?: (POGOProtos.Rpc.ISfidaCaptureRequest|null);
                public list_avatar_customizations_proto_807?: (POGOProtos.Rpc.IListAvatarCustomizationsProto|null);
                public set_avatar_item_as_viewed_proto_808?: (POGOProtos.Rpc.ISetAvatarItemAsViewedProto|null);
                public get_inbox_proto_809?: (POGOProtos.Rpc.IGetInboxProto|null);
                public list_gym_badges_proto_811?: (POGOProtos.Rpc.IListGymBadgesProto|null);
                public getgym_badge_details_proto_812?: (POGOProtos.Rpc.IGetGymBadgeDetailsProto|null);
                public use_item_move_reroll_proto_813?: (POGOProtos.Rpc.IUseItemMoveRerollProto|null);
                public use_item_rare_candy_proto_814?: (POGOProtos.Rpc.IUseItemRareCandyProto|null);
                public award_free_raid_ticket_proto_815?: (POGOProtos.Rpc.IAwardFreeRaidTicketProto|null);
                public fetch_all_news_proto_816?: (POGOProtos.Rpc.IFetchAllNewsProto|null);
                public mark_read_news_article_proto_817?: (POGOProtos.Rpc.IMarkReadNewsArticleProto|null);
                public internal_get_player_settings_proto_818?: (POGOProtos.Rpc.IInternalGetPlayerSettingsProto|null);
                public beluga_transaction_start_proto_819?: (POGOProtos.Rpc.IBelugaTransactionStartProto|null);
                public beluga_transaction_complete_proto_820?: (POGOProtos.Rpc.IBelugaTransactionCompleteProto|null);
                public sfida_associate_request_822?: (POGOProtos.Rpc.ISfidaAssociateRequest|null);
                public sfida_check_pairing_request_823?: (POGOProtos.Rpc.ISfidaCheckPairingRequest|null);
                public sfida_disassociate_request_824?: (POGOProtos.Rpc.ISfidaDisassociateRequest|null);
                public waina_get_rewards_request_825?: (POGOProtos.Rpc.IWainaGetRewardsRequest|null);
                public waina_submit_sleep_data_request_826?: (POGOProtos.Rpc.IWainaSubmitSleepDataRequest|null);
                public saturdaystart_proto_827?: (POGOProtos.Rpc.ISaturdayStartProto|null);
                public saturday_complete_proto_828?: (POGOProtos.Rpc.ISaturdayCompleteProto|null);
                public lift_user_age_gate_confirmation_proto_830?: (POGOProtos.Rpc.ILiftUserAgeGateConfirmationProto|null);
                public get_new_quests_proto_900?: (POGOProtos.Rpc.IGetNewQuestsProto|null);
                public get_quest_details_proto_901?: (POGOProtos.Rpc.IGetQuestDetailsProto|null);
                public complete_quest_proto_902?: (POGOProtos.Rpc.ICompleteQuestProto|null);
                public remove_quest_proto_903?: (POGOProtos.Rpc.IRemoveQuestProto|null);
                public quest_encounter_proto_904?: (POGOProtos.Rpc.IQuestEncounterProto|null);
                public complete_quest_stampcard_proto_905?: (POGOProtos.Rpc.ICompleteQuestStampCardProto|null);
                public progress_questproto_906?: (POGOProtos.Rpc.IProgressQuestProto|null);
                public start_quest_incident_proto_907?: (POGOProtos.Rpc.IStartQuestIncidentProto|null);
                public read_quest_dialog_proto_908?: (POGOProtos.Rpc.IReadQuestDialogProto|null);
                public send_gift_proto_950?: (POGOProtos.Rpc.ISendGiftProto|null);
                public open_gift_proto_951?: (POGOProtos.Rpc.IOpenGiftProto|null);
                public getgift_box_details_proto_952?: (POGOProtos.Rpc.IGetGiftBoxDetailsProto|null);
                public delete_gift_proto_953?: (POGOProtos.Rpc.IDeleteGiftProto|null);
                public save_playersnapshot_proto_954?: (POGOProtos.Rpc.ISavePlayerSnapshotProto|null);
                public get_friendship_rewards_proto_955?: (POGOProtos.Rpc.IGetFriendshipRewardsProto|null);
                public check_send_gift_proto_956?: (POGOProtos.Rpc.ICheckSendGiftProto|null);
                public set_friend_nickname_proto_957?: (POGOProtos.Rpc.ISetFriendNicknameProto|null);
                public delete_gift_from_inventory_proto_958?: (POGOProtos.Rpc.IDeleteGiftFromInventoryProto|null);
                public savesocial_playersettings_proto_959?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsProto|null);
                public open_trading_proto_970?: (POGOProtos.Rpc.IOpenTradingProto|null);
                public update_trading_proto_971?: (POGOProtos.Rpc.IUpdateTradingProto|null);
                public confirm_trading_proto_972?: (POGOProtos.Rpc.IConfirmTradingProto|null);
                public cancel_trading_proto_973?: (POGOProtos.Rpc.ICancelTradingProto|null);
                public get_trading_proto_974?: (POGOProtos.Rpc.IGetTradingProto|null);
                public get_fitness_rewards_proto_980?: (POGOProtos.Rpc.IGetFitnessRewardsProto|null);
                public get_combat_player_profile_proto_990?: (POGOProtos.Rpc.IGetCombatPlayerProfileProto|null);
                public generate_combat_challenge_id_proto_991?: (POGOProtos.Rpc.IGenerateCombatChallengeIdProto|null);
                public createcombatchallenge_proto_992?: (POGOProtos.Rpc.ICreateCombatChallengeProto|null);
                public open_combat_challenge_proto_993?: (POGOProtos.Rpc.IOpenCombatChallengeProto|null);
                public get_combat_challenge_proto_994?: (POGOProtos.Rpc.IGetCombatChallengeProto|null);
                public accept_combat_challenge_proto_995?: (POGOProtos.Rpc.IAcceptCombatChallengeProto|null);
                public decline_combat_challenge_proto_996?: (POGOProtos.Rpc.IDeclineCombatChallengeProto|null);
                public cancelcombatchallenge_proto_997?: (POGOProtos.Rpc.ICancelCombatChallengeProto|null);
                public submit_combat_challenge_pokemons_proto_998?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsProto|null);
                public save_combat_player_preferences_proto_999?: (POGOProtos.Rpc.ISaveCombatPlayerPreferencesProto|null);
                public open_combat_session_proto_1000?: (POGOProtos.Rpc.IOpenCombatSessionProto|null);
                public update_combat_proto_1001?: (POGOProtos.Rpc.IUpdateCombatProto|null);
                public quit_combat_proto_1002?: (POGOProtos.Rpc.IQuitCombatProto|null);
                public get_combat_results_proto_1003?: (POGOProtos.Rpc.IGetCombatResultsProto|null);
                public unlock_pokemon_move_proto_1004?: (POGOProtos.Rpc.IUnlockPokemonMoveProto|null);
                public get_npc_combat_rewards_proto_1005?: (POGOProtos.Rpc.IGetNpcCombatRewardsProto|null);
                public combat_friend_request_proto_1006?: (POGOProtos.Rpc.ICombatFriendRequestProto|null);
                public open_npc_combat_session_proto_1007?: (POGOProtos.Rpc.IOpenNpcCombatSessionProto|null);
                public send_probe_proto_1020?: (POGOProtos.Rpc.ISendProbeProto|null);
                public check_photobomb_proto_1101?: (POGOProtos.Rpc.ICheckPhotobombProto|null);
                public confirm_photobomb_proto_1102?: (POGOProtos.Rpc.IConfirmPhotobombProto|null);
                public get_photobomb_proto_1103?: (POGOProtos.Rpc.IGetPhotobombProto|null);
                public encounter_photobomb_proto_1104?: (POGOProtos.Rpc.IEncounterPhotobombProto|null);
                public getgmap_settings_proto_1105?: (POGOProtos.Rpc.IGetGmapSettingsProto|null);
                public change_team_proto_1106?: (POGOProtos.Rpc.IChangeTeamProto|null);
                public get_web_token_proto_1107?: (POGOProtos.Rpc.IGetWebTokenProto|null);
                public complete_snapshot_session_proto_1110?: (POGOProtos.Rpc.ICompleteSnapshotSessionProto|null);
                public complete_wild_snapshot_session_proto_1111?: (POGOProtos.Rpc.ICompleteWildSnapshotSessionProto|null);
                public start_incident_proto_1200?: (POGOProtos.Rpc.IStartIncidentProto|null);
                public complete_invasion_dialogue_proto_1201?: (POGOProtos.Rpc.ICompleteInvasionDialogueProto|null);
                public open_invasion_combat_session_proto_1202?: (POGOProtos.Rpc.IOpenInvasionCombatSessionProto|null);
                public update_invasion_battle_proto_1203?: (POGOProtos.Rpc.IUpdateInvasionBattleProto|null);
                public invasion_encounter_proto_1204?: (POGOProtos.Rpc.IInvasionEncounterProto|null);
                public purifypokemonproto_1205?: (POGOProtos.Rpc.IPurifyPokemonProto|null);
                public get_rocket_balloon_proto_1206?: (POGOProtos.Rpc.IGetRocketBalloonProto|null);
                public start_rocket_balloon_incident_proto_1207?: (POGOProtos.Rpc.IStartRocketBalloonIncidentProto|null);
                public vs_seeker_start_matchmaking_proto_1300?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingProto|null);
                public cancel_matchmaking_proto_1301?: (POGOProtos.Rpc.ICancelMatchmakingProto|null);
                public get_matchmaking_status_proto_1302?: (POGOProtos.Rpc.IGetMatchmakingStatusProto|null);
                public complete_vs_seeker_and_restartcharging_proto_1303?: (POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingProto|null);
                public get_vs_seeker_status_proto_1304?: (POGOProtos.Rpc.IGetVsSeekerStatusProto|null);
                public completecompetitive_season_proto_1305?: (POGOProtos.Rpc.ICompleteCompetitiveSeasonProto|null);
                public claim_vs_seeker_rewards_proto_1306?: (POGOProtos.Rpc.IClaimVsSeekerRewardsProto|null);
                public vs_seeker_reward_encounter_proto_1307?: (POGOProtos.Rpc.IVsSeekerRewardEncounterProto|null);
                public activate_vs_seeker_proto_1308?: (POGOProtos.Rpc.IActivateVsSeekerProto|null);
                public buddy_map_proto_1350?: (POGOProtos.Rpc.IBuddyMapProto|null);
                public buddy_stats_proto_1351?: (POGOProtos.Rpc.IBuddyStatsProto|null);
                public buddy_feeding_proto_1352?: (POGOProtos.Rpc.IBuddyFeedingProto|null);
                public open_buddy_gift_proto_1353?: (POGOProtos.Rpc.IOpenBuddyGiftProto|null);
                public buddy_petting_proto_1354?: (POGOProtos.Rpc.IBuddyPettingProto|null);
                public get_buddy_history_proto_1355?: (POGOProtos.Rpc.IGetBuddyHistoryProto|null);
                public update_route_draft_proto_1400?: (POGOProtos.Rpc.IUpdateRouteDraftProto|null);
                public get_map_forts_proto_1401?: (POGOProtos.Rpc.IGetMapFortsProto|null);
                public submit_route_draft_proto_1402?: (POGOProtos.Rpc.ISubmitRouteDraftProto|null);
                public get_published_routes_proto_1403?: (POGOProtos.Rpc.IGetPublishedRoutesProto|null);
                public start_route_proto_1404?: (POGOProtos.Rpc.IStartRouteProto|null);
                public get_routes_proto_1405?: (POGOProtos.Rpc.IGetRoutesProto|null);
                public progress_routeproto_1406?: (POGOProtos.Rpc.IProgressRouteProto|null);
                public process_tappableproto_1408?: (POGOProtos.Rpc.IProcessTappableProto|null);
                public list_route_badges_proto_1409?: (POGOProtos.Rpc.IListRouteBadgesProto|null);
                public cancel_route_proto_1410?: (POGOProtos.Rpc.ICancelRouteProto|null);
                public list_route_stamps_proto_1411?: (POGOProtos.Rpc.IListRouteStampsProto|null);
                public rateroute_proto_1412?: (POGOProtos.Rpc.IRateRouteProto|null);
                public create_route_draft_proto_1413?: (POGOProtos.Rpc.ICreateRouteDraftProto|null);
                public delete_routedraft_proto_1414?: (POGOProtos.Rpc.IDeleteRouteDraftProto|null);
                public reportroute_proto_1415?: (POGOProtos.Rpc.IReportRouteProto|null);
                public process_tappableproto_1416?: (POGOProtos.Rpc.IProcessTappableProto|null);
                public attracted_pokemon_encounter_proto_1417?: (POGOProtos.Rpc.IAttractedPokemonEncounterProto|null);
                public can_report_route_proto_1418?: (POGOProtos.Rpc.ICanReportRouteProto|null);
                public route_update_seen_proto_1420?: (POGOProtos.Rpc.IRouteUpdateSeenProto|null);
                public recallroute_draft_proto_1421?: (POGOProtos.Rpc.IRecallRouteDraftProto|null);
                public route_nearby_notif_shown_proto_1422?: (POGOProtos.Rpc.IRouteNearbyNotifShownProto|null);
                public npc_route_gift_proto_1423?: (POGOProtos.Rpc.INpcRouteGiftProto|null);
                public get_route_creations_proto_1424?: (POGOProtos.Rpc.IGetRouteCreationsProto|null);
                public appeal_route_proto_1425?: (POGOProtos.Rpc.IAppealRouteProto|null);
                public get_route_draft_proto_1426?: (POGOProtos.Rpc.IGetRouteDraftProto|null);
                public favorite_route_proto_1427?: (POGOProtos.Rpc.IFavoriteRouteProto|null);
                public create_route_shortcode_proto_1428?: (POGOProtos.Rpc.ICreateRouteShortcodeProto|null);
                public get_route_by_short_code_proto_1429?: (POGOProtos.Rpc.IGetRouteByShortCodeProto|null);
                public create_buddy_multiplayer_session_proto_1456?: (POGOProtos.Rpc.ICreateBuddyMultiplayerSessionProto|null);
                public join_buddy_multiplayer_session_proto_1457?: (POGOProtos.Rpc.IJoinBuddyMultiplayerSessionProto|null);
                public leave_buddy_multiplayer_session_proto_1458?: (POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionProto|null);
                public mega_evolve_pokemon_proto_1502?: (POGOProtos.Rpc.IMegaEvolvePokemonProto|null);
                public remote_gift_pingrequest_proto_1503?: (POGOProtos.Rpc.IRemoteGiftPingRequestProto|null);
                public send_raid_invitation_proto_1504?: (POGOProtos.Rpc.ISendRaidInvitationProto|null);
                public send_bread_battle_invitation_proto_1505?: (POGOProtos.Rpc.ISendBreadBattleInvitationProto|null);
                public get_daily_encounter_proto_1601?: (POGOProtos.Rpc.IGetDailyEncounterProto|null);
                public daily_encounter_proto_1602?: (POGOProtos.Rpc.IDailyEncounterProto|null);
                public open_sponsored_gift_proto_1650?: (POGOProtos.Rpc.IOpenSponsoredGiftProto|null);
                public report_ad_interaction_proto_1651?: (POGOProtos.Rpc.IReportAdInteractionProto|null);
                public save_player_preferences_proto_1652?: (POGOProtos.Rpc.ISavePlayerPreferencesProto|null);
                public profanity_checkproto_1653?: (POGOProtos.Rpc.IProfanityCheckProto|null);
                public get_timedgroup_challenge_proto_1700?: (POGOProtos.Rpc.IGetTimedGroupChallengeProto|null);
                public get_nintendo_account_proto_1710?: (POGOProtos.Rpc.IGetNintendoAccountProto|null);
                public unlink_nintendo_account_proto_1711?: (POGOProtos.Rpc.IUnlinkNintendoAccountProto|null);
                public get_nintendo_o_auth2_url_proto_1712?: (POGOProtos.Rpc.IGetNintendoOAuth2UrlProto|null);
                public transfer_pokemonto_pokemon_home_proto_1713?: (POGOProtos.Rpc.ITransferPokemonToPokemonHomeProto|null);
                public report_ad_feedbackrequest_1716?: (POGOProtos.Rpc.IReportAdFeedbackRequest|null);
                public create_pokemon_tag_proto_1717?: (POGOProtos.Rpc.ICreatePokemonTagProto|null);
                public delete_pokemon_tag_proto_1718?: (POGOProtos.Rpc.IDeletePokemonTagProto|null);
                public edit_pokemon_tag_proto_1719?: (POGOProtos.Rpc.IEditPokemonTagProto|null);
                public set_pokemon_tags_for_pokemon_proto_1720?: (POGOProtos.Rpc.ISetPokemonTagsForPokemonProto|null);
                public get_pokemon_tags_proto_1721?: (POGOProtos.Rpc.IGetPokemonTagsProto|null);
                public change_pokemon_form_proto_1722?: (POGOProtos.Rpc.IChangePokemonFormProto|null);
                public choose_global_ticketed_event_variant_proto_1723?: (POGOProtos.Rpc.IChooseGlobalTicketedEventVariantProto|null);
                public butterfly_collector_reward_encounter_proto_request_1724?: (POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoRequest|null);
                public get_additional_pokemon_details_proto_1725?: (POGOProtos.Rpc.IGetAdditionalPokemonDetailsProto|null);
                public create_route_pin_proto_1726?: (POGOProtos.Rpc.ICreateRoutePinProto|null);
                public like_route_pin_proto_1727?: (POGOProtos.Rpc.ILikeRoutePinProto|null);
                public view_route_pin_proto_1728?: (POGOProtos.Rpc.IViewRoutePinProto|null);
                public get_referral_code_proto_1800?: (POGOProtos.Rpc.IGetReferralCodeProto|null);
                public add_referrer_proto_1801?: (POGOProtos.Rpc.IAddReferrerProto|null);
                public send_friend_invite_via_referral_code_proto_1802?: (POGOProtos.Rpc.ISendFriendInviteViaReferralCodeProto|null);
                public get_milestones_proto_1803?: (POGOProtos.Rpc.IGetMilestonesProto|null);
                public markmilestone_as_viewed_proto_1804?: (POGOProtos.Rpc.IMarkMilestoneAsViewedProto|null);
                public get_milestones_preview_proto_1805?: (POGOProtos.Rpc.IGetMilestonesPreviewProto|null);
                public complete_milestone_proto_1806?: (POGOProtos.Rpc.ICompleteMilestoneProto|null);
                public getgeofenced_ad_proto_1820?: (POGOProtos.Rpc.IGetGeofencedAdProto|null);
                public power_uppokestop_encounterproto_1900?: (POGOProtos.Rpc.IPowerUpPokestopEncounterProto|null);
                public get_player_stamp_collections_proto_1901?: (POGOProtos.Rpc.IGetPlayerStampCollectionsProto|null);
                public savestamp_proto_1902?: (POGOProtos.Rpc.ISaveStampProto|null);
                public claim_stampcollection_reward_proto_1904?: (POGOProtos.Rpc.IClaimStampCollectionRewardProto|null);
                public change_stampcollection_player_data_proto_1905?: (POGOProtos.Rpc.IChangeStampCollectionPlayerDataProto|null);
                public check_stamp_giftability_proto_1906?: (POGOProtos.Rpc.ICheckStampGiftabilityProto|null);
                public delete_postcards_proto_1909?: (POGOProtos.Rpc.IDeletePostcardsProto|null);
                public create_postcard_proto_1910?: (POGOProtos.Rpc.ICreatePostcardProto|null);
                public update_postcard_proto_1911?: (POGOProtos.Rpc.IUpdatePostcardProto|null);
                public delete_postcard_proto_1912?: (POGOProtos.Rpc.IDeletePostcardProto|null);
                public get_memento_list_proto_1913?: (POGOProtos.Rpc.IGetMementoListProto|null);
                public upload_raid_client_log_proto_1914?: (POGOProtos.Rpc.IUploadRaidClientLogProto|null);
                public skip_enter_referral_code_proto_1915?: (POGOProtos.Rpc.ISkipEnterReferralCodeProto|null);
                public upload_combat_client_log_proto_1916?: (POGOProtos.Rpc.IUploadCombatClientLogProto|null);
                public combat_sync_server_offset_proto_1917?: (POGOProtos.Rpc.ICombatSyncServerOffsetProto|null);
                public check_gifting_eligibility_proto_2000?: (POGOProtos.Rpc.ICheckGiftingEligibilityProto|null);
                public redeem_ticket_gift_for_friend_proto_2001?: (POGOProtos.Rpc.IRedeemTicketGiftForFriendProto|null);
                public get_incense_recap_proto_2002?: (POGOProtos.Rpc.IGetIncenseRecapProto|null);
                public acknowledge_view_latest_incense_recap_proto_2003?: (POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapProto|null);
                public boot_raid_proto_2004?: (POGOProtos.Rpc.IBootRaidProto|null);
                public get_pokestop_encounter_proto_2005?: (POGOProtos.Rpc.IGetPokestopEncounterProto|null);
                public encounter_pokestopencounter_proto_2006?: (POGOProtos.Rpc.IEncounterPokestopEncounterProto|null);
                public player_spawnablepokemonproto_2007?: (POGOProtos.Rpc.IPlayerSpawnablePokemonProto|null);
                public get_quest_ui_proto_2008?: (POGOProtos.Rpc.IGetQuestUiProto|null);
                public get_eligible_combat_leagues_proto_2009?: (POGOProtos.Rpc.IGetEligibleCombatLeaguesProto|null);
                public send_friend_request_via_player_id_proto_2010?: (POGOProtos.Rpc.ISendFriendRequestViaPlayerIdProto|null);
                public get_raid_lobby_counter_proto_2011?: (POGOProtos.Rpc.IGetRaidLobbyCounterProto|null);
                public use_non_combat_move_request_proto_2014?: (POGOProtos.Rpc.IUseNonCombatMoveRequestProto|null);
                public check_pokemon_size_leaderboard_eligibility_proto_2100?: (POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityProto|null);
                public update_pokemon_size_leaderboard_entry_proto_2101?: (POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryProto|null);
                public transfer_pokemon_size_leaderboard_entry_proto_2102?: (POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryProto|null);
                public remove_pokemon_size_leaderboard_entry_proto_2103?: (POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryProto|null);
                public get_pokemon_size_leaderboard_entry_proto_2104?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryProto|null);
                public get_contest_data_proto_2105?: (POGOProtos.Rpc.IGetContestDataProto|null);
                public get_contests_unclaimed_rewards_proto_2106?: (POGOProtos.Rpc.IGetContestsUnclaimedRewardsProto|null);
                public claimcontests_rewards_proto_2107?: (POGOProtos.Rpc.IClaimContestsRewardsProto|null);
                public get_entered_contest_proto_2108?: (POGOProtos.Rpc.IGetEnteredContestProto|null);
                public get_pokemon_size_leaderboard_friend_entry_proto_2109?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryProto|null);
                public checkcontest_eligibility_proto_2150?: (POGOProtos.Rpc.ICheckContestEligibilityProto|null);
                public update_contest_entry_proto_2151?: (POGOProtos.Rpc.IUpdateContestEntryProto|null);
                public transfer_contest_entry_proto_2152?: (POGOProtos.Rpc.ITransferContestEntryProto|null);
                public get_contest_friend_entry_proto_2153?: (POGOProtos.Rpc.IGetContestFriendEntryProto|null);
                public get_contest_entry_proto_2154?: (POGOProtos.Rpc.IGetContestEntryProto|null);
                public create_party_proto_2300?: (POGOProtos.Rpc.ICreatePartyProto|null);
                public join_party_proto_2301?: (POGOProtos.Rpc.IJoinPartyProto|null);
                public start_party_proto_2302?: (POGOProtos.Rpc.IStartPartyProto|null);
                public leave_party_proto_2303?: (POGOProtos.Rpc.ILeavePartyProto|null);
                public get_party_proto_2304?: (POGOProtos.Rpc.IGetPartyProto|null);
                public party_update_locationproto_2305?: (POGOProtos.Rpc.IPartyUpdateLocationProto|null);
                public party_send_dark_launch_logproto_2306?: (POGOProtos.Rpc.IPartySendDarkLaunchLogProto|null);
                public start_party_quest_proto_2308?: (POGOProtos.Rpc.IStartPartyQuestProto|null);
                public complete_party_quest_proto_2309?: (POGOProtos.Rpc.ICompletePartyQuestProto|null);
                public get_bonus_attracted_pokemon_proto_2350?: (POGOProtos.Rpc.IGetBonusAttractedPokemonProto|null);
                public get_bonuses_proto_2352?: (POGOProtos.Rpc.IGetBonusesProto|null);
                public badge_reward_encounter_request_proto_2360?: (POGOProtos.Rpc.IBadgeRewardEncounterRequestProto|null);
                public npc_update_state_proto_2400?: (POGOProtos.Rpc.INpcUpdateStateProto|null);
                public npc_send_gift_proto_2401?: (POGOProtos.Rpc.INpcSendGiftProto|null);
                public npc_open_gift_proto_2402?: (POGOProtos.Rpc.INpcOpenGiftProto|null);
                public join_bread_lobby_proto_2450?: (POGOProtos.Rpc.IJoinBreadLobbyProto|null);
                public prepare_bread_lobbyproto_2453?: (POGOProtos.Rpc.IPrepareBreadLobbyProto|null);
                public leave_breadlobby_proto_2455?: (POGOProtos.Rpc.ILeaveBreadLobbyProto|null);
                public start_bread_battle_proto_2456?: (POGOProtos.Rpc.IStartBreadBattleProto|null);
                public get_bread_lobby_details_proto_2457?: (POGOProtos.Rpc.IGetBreadLobbyDetailsProto|null);
                public start_mp_walk_quest_proto_2458?: (POGOProtos.Rpc.IStartMpWalkQuestProto|null);
                public enhance_bread_move_proto_2459?: (POGOProtos.Rpc.IEnhanceBreadMoveProto|null);
                public station_pokemon_proto_2460?: (POGOProtos.Rpc.IStationPokemonProto|null);
                public loot_station_proto_2461?: (POGOProtos.Rpc.ILootStationProto|null);
                public get_stationed_pokemon_details_proto_2462?: (POGOProtos.Rpc.IGetStationedPokemonDetailsProto|null);
                public mark_save_for_later_proto_2463?: (POGOProtos.Rpc.IMarkSaveForLaterProto|null);
                public use_save_for_later_proto_2464?: (POGOProtos.Rpc.IUseSaveForLaterProto|null);
                public remove_save_for_later_proto_2465?: (POGOProtos.Rpc.IRemoveSaveForLaterProto|null);
                public get_save_for_later_entries_proto_2466?: (POGOProtos.Rpc.IGetSaveForLaterEntriesProto|null);
                public get_mp_summary_proto_2467?: (POGOProtos.Rpc.IGetMpSummaryProto|null);
                public use_item_mp_replenish_proto_2468?: (POGOProtos.Rpc.IUseItemMpReplenishProto|null);
                public report_station_proto_2470?: (POGOProtos.Rpc.IReportStationProto|null);
                public debug_resetdaily_mp_progress_proto_2471?: (POGOProtos.Rpc.IDebugResetDailyMpProgressProto|null);
                public release_stationed_pokemon_proto_2472?: (POGOProtos.Rpc.IReleaseStationedPokemonProto|null);
                public complete_bread_battle_proto_2473?: (POGOProtos.Rpc.ICompleteBreadBattleProto|null);
                public encounter_station_spawn_proto_2475?: (POGOProtos.Rpc.IEncounterStationSpawnProto|null);
                public get_num_station_assists_proto_2476?: (POGOProtos.Rpc.IGetNumStationAssistsProto|null);
                public get_vps_event_proto_3000?: (POGOProtos.Rpc.IGetVpsEventProto|null);
                public update_vps_event_proto_3001?: (POGOProtos.Rpc.IUpdateVpsEventProto|null);
                public add_ptc_loginaction_proto_3002?: (POGOProtos.Rpc.IAddPtcLoginActionProto|null);
                public claim_ptc_linking_reward_proto_3003?: (POGOProtos.Rpc.IClaimPtcLinkingRewardProto|null);
                public canclaim_ptc_reward_action_proto_3004?: (POGOProtos.Rpc.ICanClaimPtcRewardActionProto|null);
                public contribute_party_item_proto_3005?: (POGOProtos.Rpc.IContributePartyItemProto|null);
                public consume_party_items_proto_3006?: (POGOProtos.Rpc.IConsumePartyItemsProto|null);
                public remove_ptc_login_action_proto_3007?: (POGOProtos.Rpc.IRemovePtcLoginActionProto|null);
                public send_party_invitation_proto_3008?: (POGOProtos.Rpc.ISendPartyInvitationProto|null);
                public consume_stickers_proto_3009?: (POGOProtos.Rpc.IConsumeStickersProto|null);
                public complete_raid_battle_proto_3010?: (POGOProtos.Rpc.ICompleteRaidBattleProto|null);
                public sync_battle_inventory_proto_3011?: (POGOProtos.Rpc.ISyncBattleInventoryProto|null);
                public preview_contributeparty_itemproto_3015?: (POGOProtos.Rpc.IPreviewContributePartyItemProto|null);
                public kick_other_player_from_party_proto_3016?: (POGOProtos.Rpc.IKickOtherPlayerFromPartyProto|null);
                public fuse_pokemon_request_proto_3017?: (POGOProtos.Rpc.IFusePokemonRequestProto|null);
                public unfuse_pokemon_request_proto_3018?: (POGOProtos.Rpc.IUnfusePokemonRequestProto|null);
                public get_iris_social_scene_proto_3019?: (POGOProtos.Rpc.IGetIrisSocialSceneProto|null);
                public update_iris_social_scene_proto_3020?: (POGOProtos.Rpc.IUpdateIrisSocialSceneProto|null);
                public get_change_pokemon_form_preview_request_proto_3021?: (POGOProtos.Rpc.IGetChangePokemonFormPreviewRequestProto|null);
                public get_unfuse_pokemon_preview_request_proto_3023?: (POGOProtos.Rpc.IGetUnfusePokemonPreviewRequestProto|null);
                public processplayer_inboxproto_3024?: (POGOProtos.Rpc.IProcessPlayerInboxProto|null);
                public get_survey_eligibility_proto_3025?: (POGOProtos.Rpc.IGetSurveyEligibilityProto|null);
                public update_survey_eligibility_proto_3026?: (POGOProtos.Rpc.IUpdateSurveyEligibilityProto|null);
                public smart_glassessyncsettings_request_proto_3027?: (POGOProtos.Rpc.ISmartGlassesSyncSettingsRequestProto|null);
                public complete_visit_page_quest_proto_3030?: (POGOProtos.Rpc.ICompleteVisitPageQuestProto|null);
                public get_event_rsvps_proto_3031?: (POGOProtos.Rpc.IGetEventRsvpsProto|null);
                public create_event_rsvp_proto_3032?: (POGOProtos.Rpc.ICreateEventRsvpProto|null);
                public cancel_event_rsvp_proto_3033?: (POGOProtos.Rpc.ICancelEventRsvpProto|null);
                public claim_event_pass_rewards_request_proto_3034?: (POGOProtos.Rpc.IClaimEventPassRewardsRequestProto|null);
                public get_event_rsvp_count_proto_3036?: (POGOProtos.Rpc.IGetEventRsvpCountProto|null);
                public send_event_rsvp_invitation_proto_3039?: (POGOProtos.Rpc.ISendEventRsvpInvitationProto|null);
                public update_event_rsvp_selection_proto_3040?: (POGOProtos.Rpc.IUpdateEventRsvpSelectionProto|null);
                public get_station_info_proto_3051?: (POGOProtos.Rpc.IGetStationInfoProto|null);
                public age_confirmation_proto_3052?: (POGOProtos.Rpc.IAgeConfirmationProto|null);
                public change_stat_increase_goal_proto_3053?: (POGOProtos.Rpc.IChangeStatIncreaseGoalProto|null);
                public push_notification_registryproto_5000?: (POGOProtos.Rpc.IPushNotificationRegistryProto|null);
                public update_notification_proto_5002?: (POGOProtos.Rpc.IUpdateNotificationProto|null);
                public download_gm_templates_request_proto_5004?: (POGOProtos.Rpc.IDownloadGmTemplatesRequestProto|null);
                public get_inventory_proto_5005?: (POGOProtos.Rpc.IGetInventoryProto|null);
                public redeem_passcoderequest_proto_5006?: (POGOProtos.Rpc.IRedeemPasscodeRequestProto|null);
                public ping_requestproto_5007?: (POGOProtos.Rpc.IPingRequestProto|null);
                public add_loginaction_proto_5008?: (POGOProtos.Rpc.IAddLoginActionProto|null);
                public remove_login_action_proto_5009?: (POGOProtos.Rpc.IRemoveLoginActionProto|null);
                public submit_new_poi_proto_5011?: (POGOProtos.Rpc.ISubmitNewPoiProto|null);
                public proxy_requestproto_5012?: (POGOProtos.Rpc.IProxyRequestProto|null);
                public get_available_submissions_proto_5014?: (POGOProtos.Rpc.IGetAvailableSubmissionsProto|null);
                public replace_login_action_proto_5015?: (POGOProtos.Rpc.IReplaceLoginActionProto|null);
                public client_telemetry_batch_proto_5018?: (POGOProtos.Rpc.IClientTelemetryBatchProto|null);
                public iap_purchase_sku_proto_5019?: (POGOProtos.Rpc.IIapPurchaseSkuProto|null);
                public iap_get_available_skus_and_balances_proto_5020?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesProto|null);
                public iap_redeem_google_receipt_proto_5021?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptProto|null);
                public iap_redeem_apple_receipt_proto_5022?: (POGOProtos.Rpc.IIapRedeemAppleReceiptProto|null);
                public iap_redeem_desktop_receipt_proto_5023?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptProto|null);
                public fitness_update_proto_5024?: (POGOProtos.Rpc.IFitnessUpdateProto|null);
                public get_fitness_report_proto_5025?: (POGOProtos.Rpc.IGetFitnessReportProto|null);
                public client_telemetry_settings_request_proto_5026?: (POGOProtos.Rpc.IClientTelemetrySettingsRequestProto|null);
                public auth_register_background_deviceaction_proto_5028?: (POGOProtos.Rpc.IAuthRegisterBackgroundDeviceActionProto|null);
                public internal_setin_game_currency_exchange_rate_proto_5032?: (POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateProto|null);
                public geofence_update_proto_5033?: (POGOProtos.Rpc.IGeofenceUpdateProto|null);
                public location_ping_proto_5034?: (POGOProtos.Rpc.ILocationPingProto|null);
                public generategmap_signed_url_proto_5035?: (POGOProtos.Rpc.IGenerateGmapSignedUrlProto|null);
                public getgmap_settings_proto_5036?: (POGOProtos.Rpc.IGetGmapSettingsProto|null);
                public iap_redeem_samsung_receipt_proto_5037?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptProto|null);
                public get_outstanding_warnings_request_proto_5039?: (POGOProtos.Rpc.IGetOutstandingWarningsRequestProto|null);
                public acknowledge_warnings_request_proto_5040?: (POGOProtos.Rpc.IAcknowledgeWarningsRequestProto|null);
                public titan_submit_poi_image_proto_5041?: (POGOProtos.Rpc.ITitanSubmitPoiImageProto|null);
                public titan_submit_poitext_metadata_update_proto_5042?: (POGOProtos.Rpc.ITitanSubmitPoiTextMetadataUpdateProto|null);
                public titan_submit_poi_location_update_proto_5043?: (POGOProtos.Rpc.ITitanSubmitPoiLocationUpdateProto|null);
                public titan_submit_poitakedown_request_proto_5044?: (POGOProtos.Rpc.ITitanSubmitPoiTakedownRequestProto|null);
                public get_web_token_proto_5045?: (POGOProtos.Rpc.IGetWebTokenProto|null);
                public get_adventure_sync_settings_request_proto_5046?: (POGOProtos.Rpc.IGetAdventureSyncSettingsRequestProto|null);
                public update_adventure_sync_settings_request_proto_5047?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsRequestProto|null);
                public set_birthday_request_proto_5048?: (POGOProtos.Rpc.ISetBirthdayRequestProto|null);
                public platform_fetch_newsfeed_request_5049?: (POGOProtos.Rpc.IPlatformFetchNewsfeedRequest|null);
                public platform_mark_newsfeed_read_request_5050?: (POGOProtos.Rpc.IPlatformMarkNewsfeedReadRequest|null);
                public internal_search_player_proto_10000?: (POGOProtos.Rpc.IInternalSearchPlayerProto|null);
                public internal_send_friendinvite_proto_10002?: (POGOProtos.Rpc.IInternalSendFriendInviteProto|null);
                public internal_cancel_friendinvite_proto_10003?: (POGOProtos.Rpc.IInternalCancelFriendInviteProto|null);
                public internal_accept_friendinvite_proto_10004?: (POGOProtos.Rpc.IInternalAcceptFriendInviteProto|null);
                public internal_decline_friendinvite_proto_10005?: (POGOProtos.Rpc.IInternalDeclineFriendInviteProto|null);
                public internal_get_friends_list_proto_10006?: (POGOProtos.Rpc.IInternalGetFriendsListProto|null);
                public internal_get_outgoing_friendinvites_proto_10007?: (POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesProto|null);
                public internal_getincoming_friendinvites_proto_10008?: (POGOProtos.Rpc.IInternalGetIncomingFriendInvitesProto|null);
                public internal_remove_friend_proto_10009?: (POGOProtos.Rpc.IInternalRemoveFriendProto|null);
                public internal_get_friend_details_proto_10010?: (POGOProtos.Rpc.IInternalGetFriendDetailsProto|null);
                public internalinvite_facebook_friend_proto_10011?: (POGOProtos.Rpc.IInternalInviteFacebookFriendProto|null);
                public internalis_my_friend_proto_10012?: (POGOProtos.Rpc.IInternalIsMyFriendProto|null);
                public internal_get_friend_code_proto_10013?: (POGOProtos.Rpc.IInternalGetFriendCodeProto|null);
                public internal_get_facebook_friend_list_proto_10014?: (POGOProtos.Rpc.IInternalGetFacebookFriendListProto|null);
                public internal_update_facebook_status_proto_10015?: (POGOProtos.Rpc.IInternalUpdateFacebookStatusProto|null);
                public savesocial_playersettings_proto_10016?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsProto|null);
                public internal_get_player_settings_proto_10017?: (POGOProtos.Rpc.IInternalGetPlayerSettingsProto|null);
                public internal_set_account_settings_proto_10021?: (POGOProtos.Rpc.IInternalSetAccountSettingsProto|null);
                public internal_get_account_settings_proto_10022?: (POGOProtos.Rpc.IInternalGetAccountSettingsProto|null);
                public internal_add_favorite_friend_request_10023?: (POGOProtos.Rpc.IInternalAddFavoriteFriendRequest|null);
                public internal_remove_favorite_friend_request_10024?: (POGOProtos.Rpc.IInternalRemoveFavoriteFriendRequest|null);
                public internal_block_account_proto_10025?: (POGOProtos.Rpc.IInternalBlockAccountProto|null);
                public internal_unblock_account_proto_10026?: (POGOProtos.Rpc.IInternalUnblockAccountProto|null);
                public internal_get_outgoing_blocks_proto_10027?: (POGOProtos.Rpc.IInternalGetOutgoingBlocksProto|null);
                public internalis_account_blocked_proto_10028?: (POGOProtos.Rpc.IInternalIsAccountBlockedProto|null);
                public list_friend_activities_request_proto_10029?: (POGOProtos.Rpc.IListFriendActivitiesRequestProto|null);
                public internal_push_notification_registry_proto_10101?: (POGOProtos.Rpc.IInternalPushNotificationRegistryProto|null);
                public internal_update_notification_proto_10103?: (POGOProtos.Rpc.IInternalUpdateNotificationProto|null);
                public get_inbox_proto_10105?: (POGOProtos.Rpc.IGetInboxProto|null);
                public internal_list_opt_out_notification_categories_request_proto_10106?: (POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesRequestProto|null);
                public internal_get_signed_url_proto_10201?: (POGOProtos.Rpc.IInternalGetSignedUrlProto|null);
                public internal_submitimage_proto_10202?: (POGOProtos.Rpc.IInternalSubmitImageProto|null);
                public internal_get_photos_proto_10203?: (POGOProtos.Rpc.IInternalGetPhotosProto|null);
                public internal_update_profile_request_20001?: (POGOProtos.Rpc.IInternalUpdateProfileRequest|null);
                public internal_update_friendship_request_20002?: (POGOProtos.Rpc.IInternalUpdateFriendshipRequest|null);
                public internal_get_profile_request_20003?: (POGOProtos.Rpc.IInternalGetProfileRequest|null);
                public internalinvite_game_request_20004?: (POGOProtos.Rpc.IInternalInviteGameRequest|null);
                public internal_list_friends_request_20006?: (POGOProtos.Rpc.IInternalListFriendsRequest|null);
                public internal_get_friend_details_proto_20007?: (POGOProtos.Rpc.IInternalGetFriendDetailsProto|null);
                public internal_get_client_feature_flags_request_20008?: (POGOProtos.Rpc.IInternalGetClientFeatureFlagsRequest|null);
                public internal_getincoming_gameinvites_request_20010?: (POGOProtos.Rpc.IInternalGetIncomingGameInvitesRequest|null);
                public internal_updateincoming_gameinvite_request_20011?: (POGOProtos.Rpc.IInternalUpdateIncomingGameInviteRequest|null);
                public internal_dismiss_outgoing_gameinvites_request_20012?: (POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesRequest|null);
                public internal_sync_contact_list_request_20013?: (POGOProtos.Rpc.IInternalSyncContactListRequest|null);
                public internal_send_contact_list_friendinvite_request_20014?: (POGOProtos.Rpc.IInternalSendContactListFriendInviteRequest|null);
                public internal_refer_contact_list_friend_request_20015?: (POGOProtos.Rpc.IInternalReferContactListFriendRequest|null);
                public internal_get_contact_listinfo_request_20016?: (POGOProtos.Rpc.IInternalGetContactListInfoRequest|null);
                public internal_dismiss_contact_list_update_request_20017?: (POGOProtos.Rpc.IInternalDismissContactListUpdateRequest|null);
                public internal_notify_contact_list_friends_request_20018?: (POGOProtos.Rpc.IInternalNotifyContactListFriendsRequest|null);
                public internal_get_friend_recommendation_request_20500?: (POGOProtos.Rpc.IInternalGetFriendRecommendationRequest|null);
                public get_outstanding_warnings_request_proto_200000?: (POGOProtos.Rpc.IGetOutstandingWarningsRequestProto|null);
                public acknowledge_warnings_request_proto_200001?: (POGOProtos.Rpc.IAcknowledgeWarningsRequestProto|null);
                public register_background_device_action_proto_230000?: (POGOProtos.Rpc.IRegisterBackgroundDeviceActionProto|null);
                public get_adventure_sync_progress_proto_230002?: (POGOProtos.Rpc.IGetAdventureSyncProgressProto|null);
                public iap_purchase_sku_proto_310000?: (POGOProtos.Rpc.IIapPurchaseSkuProto|null);
                public iap_get_available_skus_and_balances_proto_310001?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesProto|null);
                public iap_setin_game_currency_exchange_rate_proto_310002?: (POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateProto|null);
                public iap_redeem_google_receipt_proto_310100?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptProto|null);
                public iap_redeem_apple_receipt_proto_310101?: (POGOProtos.Rpc.IIapRedeemAppleReceiptProto|null);
                public iap_redeem_desktop_receipt_proto_310102?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptProto|null);
                public iap_redeem_samsung_receipt_proto_310103?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptProto|null);
                public iap_get_available_subscriptions_request_proto_310200?: (POGOProtos.Rpc.IIapGetAvailableSubscriptionsRequestProto|null);
                public iap_get_active_subscriptions_request_proto_310201?: (POGOProtos.Rpc.IIapGetActiveSubscriptionsRequestProto|null);
                public get_reward_tiers_request_proto_310300?: (POGOProtos.Rpc.IGetRewardTiersRequestProto|null);
                public iap_redeem_xsolla_receipt_request_proto_311100?: (POGOProtos.Rpc.IIapRedeemXsollaReceiptRequestProto|null);
                public iap_get_user_request_proto_311101?: (POGOProtos.Rpc.IIapGetUserRequestProto|null);
                public geofence_update_proto_360000?: (POGOProtos.Rpc.IGeofenceUpdateProto|null);
                public location_ping_proto_360001?: (POGOProtos.Rpc.ILocationPingProto|null);
                public update_bulk_player_location_request_proto_360002?: (POGOProtos.Rpc.IUpdateBulkPlayerLocationRequestProto|null);
                public update_breadcrumb_history_request_proto_361000?: (POGOProtos.Rpc.IUpdateBreadcrumbHistoryRequestProto|null);
                public refresh_proximity_tokensrequest_proto_362000?: (POGOProtos.Rpc.IRefreshProximityTokensRequestProto|null);
                public report_proximity_contactsrequest_proto_362001?: (POGOProtos.Rpc.IReportProximityContactsRequestProto|null);
                public internal_add_login_action_proto_600000?: (POGOProtos.Rpc.IInternalAddLoginActionProto|null);
                public internal_remove_login_action_proto_600001?: (POGOProtos.Rpc.IInternalRemoveLoginActionProto|null);
                public internal_replace_login_action_proto_600003?: (POGOProtos.Rpc.IInternalReplaceLoginActionProto|null);
                public internal_set_birthday_request_proto_600004?: (POGOProtos.Rpc.IInternalSetBirthdayRequestProto|null);
                public internal_gar_proxy_request_proto_600005?: (POGOProtos.Rpc.IInternalGarProxyRequestProto|null);
                public internal_link_to_account_login_request_proto_600006?: (POGOProtos.Rpc.IInternalLinkToAccountLoginRequestProto|null);
                public titan_submit_new_poi_proto_620000?: (POGOProtos.Rpc.ITitanSubmitNewPoiProto|null);
                public titan_get_available_submissions_proto_620001?: (POGOProtos.Rpc.ITitanGetAvailableSubmissionsProto|null);
                public titan_get_player_submission_validation_settings_proto_620003?: (POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsProto|null);
                public titan_submit_poi_image_proto_620100?: (POGOProtos.Rpc.ITitanSubmitPoiImageProto|null);
                public titan_submit_poitext_metadata_update_proto_620101?: (POGOProtos.Rpc.ITitanSubmitPoiTextMetadataUpdateProto|null);
                public titan_submit_poi_location_update_proto_620102?: (POGOProtos.Rpc.ITitanSubmitPoiLocationUpdateProto|null);
                public titan_submit_poitakedown_request_proto_620103?: (POGOProtos.Rpc.ITitanSubmitPoiTakedownRequestProto|null);
                public titan_submit_sponsor_poi_report_proto_620104?: (POGOProtos.Rpc.ITitanSubmitSponsorPoiReportProto|null);
                public titan_submit_sponsor_poi_location_update_proto_620105?: (POGOProtos.Rpc.ITitanSubmitSponsorPoiLocationUpdateProto|null);
                public titan_submit_poi_category_vote_record_proto_620106?: (POGOProtos.Rpc.ITitanSubmitPoiCategoryVoteRecordProto|null);
                public titan_generate_gmap_signed_url_proto_620300?: (POGOProtos.Rpc.ITitanGenerateGmapSignedUrlProto|null);
                public titan_get_gmap_settings_proto_620301?: (POGOProtos.Rpc.ITitanGetGmapSettingsProto|null);
                public titan_poi_video_submission_metadata_proto_620400?: (POGOProtos.Rpc.ITitanPoiVideoSubmissionMetadataProto|null);
                public titan_get_grapeshot_upload_url_proto_620401?: (POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlProto|null);
                public titan_async_file_upload_complete_proto_620402?: (POGOProtos.Rpc.ITitanAsyncFileUploadCompleteProto|null);
                public titan_get_a_r_mapping_settings_proto_620403?: (POGOProtos.Rpc.ITitanGetARMappingSettingsProto|null);
                public titan_get_images_for_poi_proto_620500?: (POGOProtos.Rpc.ITitanGetImagesForPoiProto|null);
                public titan_submit_player_image_vote_for_poi_proto_620501?: (POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiProto|null);
                public titan_get_image_gallery_settings_proto_620502?: (POGOProtos.Rpc.ITitanGetImageGallerySettingsProto|null);
                public get_maptiles_settings_request_620600?: (POGOProtos.Rpc.IGetMaptilesSettingsRequest|null);
                public titan_get_pois_in_radius_proto_620601?: (POGOProtos.Rpc.ITitanGetPoisInRadiusProto|null);
                public fitness_update_proto_640000?: (POGOProtos.Rpc.IFitnessUpdateProto|null);
                public get_fitness_report_proto_640001?: (POGOProtos.Rpc.IGetFitnessReportProto|null);
                public get_adventure_sync_settings_request_proto_640002?: (POGOProtos.Rpc.IGetAdventureSyncSettingsRequestProto|null);
                public update_adventure_sync_settings_request_proto_640003?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsRequestProto|null);
                public update_adventure_sync_fitness_request_proto_640004?: (POGOProtos.Rpc.IUpdateAdventureSyncFitnessRequestProto|null);
                public get_adventure_sync_fitness_report_request_proto_640005?: (POGOProtos.Rpc.IGetAdventureSyncFitnessReportRequestProto|null);
                public static encode(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IAllMessagesProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllMessagesProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllMessagesProto;
                public static toObject(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllMessagesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAllResponsesProto {
                get_player_out_proto_2?: (POGOProtos.Rpc.IGetPlayerOutProto|null);
                get_holoholo_inventory_out_proto_4?: (POGOProtos.Rpc.IGetHoloholoInventoryOutProto|null);
                download_settings_response_proto_5?: (POGOProtos.Rpc.IDownloadSettingsResponseProto|null);
                getgame_master_client_templates_out_proto_6?: (POGOProtos.Rpc.IGetGameMasterClientTemplatesOutProto|null);
                get_remote_config_versions_out_proto_7?: (POGOProtos.Rpc.IGetRemoteConfigVersionsOutProto|null);
                register_background_deviceresponse_proto_8?: (POGOProtos.Rpc.IRegisterBackgroundDeviceResponseProto|null);
                get_player_day_out_proto_9?: (POGOProtos.Rpc.IGetPlayerDayOutProto|null);
                acknowledge_punishment_out_proto_10?: (POGOProtos.Rpc.IAcknowledgePunishmentOutProto|null);
                get_server_time_out_proto_11?: (POGOProtos.Rpc.IGetServerTimeOutProto|null);
                get_local_time_out_proto_12?: (POGOProtos.Rpc.IGetLocalTimeOutProto|null);
                set_playerstatus_out_proto_20?: (POGOProtos.Rpc.ISetPlayerStatusOutProto|null);
                getgame_config_versions_out_proto_21?: (POGOProtos.Rpc.IGetGameConfigVersionsOutProto|null);
                get_playergps_bookmarks_out_proto_22?: (POGOProtos.Rpc.IGetPlayerGpsBookmarksOutProto|null);
                update_player_gps_bookmarks_out_proto_23?: (POGOProtos.Rpc.IUpdatePlayerGpsBookmarksOutProto|null);
                fort_search_out_proto_101?: (POGOProtos.Rpc.IFortSearchOutProto|null);
                encounter_out_proto_102?: (POGOProtos.Rpc.IEncounterOutProto|null);
                catch_pokemon_out_proto_103?: (POGOProtos.Rpc.ICatchPokemonOutProto|null);
                fort_details_out_proto_104?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
                get_map_objects_out_proto_106?: (POGOProtos.Rpc.IGetMapObjectsOutProto|null);
                fort_deploy_out_proto_110?: (POGOProtos.Rpc.IFortDeployOutProto|null);
                fort_recall_out_proto_111?: (POGOProtos.Rpc.IFortRecallOutProto|null);
                release_pokemon_out_proto_112?: (POGOProtos.Rpc.IReleasePokemonOutProto|null);
                use_item_potion_out_proto_113?: (POGOProtos.Rpc.IUseItemPotionOutProto|null);
                use_item_capture_out_proto_114?: (POGOProtos.Rpc.IUseItemCaptureOutProto|null);
                use_item_revive_out_proto_116?: (POGOProtos.Rpc.IUseItemReviveOutProto|null);
                playerprofile_outproto_121?: (POGOProtos.Rpc.IPlayerProfileOutProto|null);
                evolve_pokemon_out_proto_125?: (POGOProtos.Rpc.IEvolvePokemonOutProto|null);
                get_hatched_eggs_out_proto_126?: (POGOProtos.Rpc.IGetHatchedEggsOutProto|null);
                encounter_tutorial_complete_out_proto_127?: (POGOProtos.Rpc.IEncounterTutorialCompleteOutProto|null);
                level_up_rewards_out_proto_128?: (POGOProtos.Rpc.ILevelUpRewardsOutProto|null);
                check_awarded_badges_out_proto_129?: (POGOProtos.Rpc.ICheckAwardedBadgesOutProto|null);
                recycle_item_out_proto_137?: (POGOProtos.Rpc.IRecycleItemOutProto|null);
                collect_daily_bonus_out_proto_138?: (POGOProtos.Rpc.ICollectDailyBonusOutProto|null);
                use_item_xp_boost_out_proto_139?: (POGOProtos.Rpc.IUseItemXpBoostOutProto|null);
                use_item_egg_incubator_out_proto_140?: (POGOProtos.Rpc.IUseItemEggIncubatorOutProto|null);
                use_incense_action_out_proto_141?: (POGOProtos.Rpc.IUseIncenseActionOutProto|null);
                get_incense_pokemon_out_proto_142?: (POGOProtos.Rpc.IGetIncensePokemonOutProto|null);
                incense_encounter_out_proto_143?: (POGOProtos.Rpc.IIncenseEncounterOutProto|null);
                add_fort_modifier_out_proto_144?: (POGOProtos.Rpc.IAddFortModifierOutProto|null);
                disk_encounter_out_proto_145?: (POGOProtos.Rpc.IDiskEncounterOutProto|null);
                upgrade_pokemon_out_proto_147?: (POGOProtos.Rpc.IUpgradePokemonOutProto|null);
                set_favorite_pokemon_out_proto_148?: (POGOProtos.Rpc.ISetFavoritePokemonOutProto|null);
                nickname_pokemon_out_proto_149?: (POGOProtos.Rpc.INicknamePokemonOutProto|null);
                set_contactsettings_out_proto_151?: (POGOProtos.Rpc.ISetContactSettingsOutProto|null);
                set_buddy_pokemon_out_proto_152?: (POGOProtos.Rpc.ISetBuddyPokemonOutProto|null);
                get_buddy_walked_out_proto_153?: (POGOProtos.Rpc.IGetBuddyWalkedOutProto|null);
                use_item_encounter_out_proto_154?: (POGOProtos.Rpc.IUseItemEncounterOutProto|null);
                gym_deploy_out_proto_155?: (POGOProtos.Rpc.IGymDeployOutProto|null);
                gymget_info_out_proto_156?: (POGOProtos.Rpc.IGymGetInfoOutProto|null);
                gym_start_session_out_proto_157?: (POGOProtos.Rpc.IGymStartSessionOutProto|null);
                gym_battle_attack_out_proto_158?: (POGOProtos.Rpc.IGymBattleAttackOutProto|null);
                join_lobby_out_proto_159?: (POGOProtos.Rpc.IJoinLobbyOutProto|null);
                leavelobby_out_proto_160?: (POGOProtos.Rpc.ILeaveLobbyOutProto|null);
                set_lobby_visibility_out_proto_161?: (POGOProtos.Rpc.ISetLobbyVisibilityOutProto|null);
                set_lobby_pokemon_out_proto_162?: (POGOProtos.Rpc.ISetLobbyPokemonOutProto|null);
                get_raid_details_out_proto_163?: (POGOProtos.Rpc.IGetRaidDetailsOutProto|null);
                gym_feed_pokemon_out_proto_164?: (POGOProtos.Rpc.IGymFeedPokemonOutProto|null);
                start_raid_battle_out_proto_165?: (POGOProtos.Rpc.IStartRaidBattleOutProto|null);
                attack_raid_battle_out_proto_166?: (POGOProtos.Rpc.IAttackRaidBattleOutProto|null);
                use_item_stardust_boost_out_proto_168?: (POGOProtos.Rpc.IUseItemStardustBoostOutProto|null);
                reassign_player_out_proto_169?: (POGOProtos.Rpc.IReassignPlayerOutProto|null);
                convertcandy_to_xlcandy_out_proto_171?: (POGOProtos.Rpc.IConvertCandyToXlCandyOutProto|null);
                is_sku_available_out_proto_172?: (POGOProtos.Rpc.IIsSkuAvailableOutProto|null);
                use_item_bulk_heal_out_proto_173?: (POGOProtos.Rpc.IUseItemBulkHealOutProto|null);
                use_item_battle_boost_out_proto_174?: (POGOProtos.Rpc.IUseItemBattleBoostOutProto|null);
                use_item_lucky_friend_applicator_out_proto_175?: (POGOProtos.Rpc.IUseItemLuckyFriendApplicatorOutProto|null);
                use_item_stat_increase_out_proto_176?: (POGOProtos.Rpc.IUseItemStatIncreaseOutProto|null);
                asset_digest_out_proto_300?: (POGOProtos.Rpc.IAssetDigestOutProto|null);
                download_url_out_proto_301?: (POGOProtos.Rpc.IDownloadUrlOutProto|null);
                asset_version_out_proto_302?: (POGOProtos.Rpc.IAssetVersionOutProto|null);
                codename_result_proto_403?: (POGOProtos.Rpc.ICodenameResultProto|null);
                set_avatar_out_proto_404?: (POGOProtos.Rpc.ISetAvatarOutProto|null);
                set_player_team_out_proto_405?: (POGOProtos.Rpc.ISetPlayerTeamOutProto|null);
                mark_tutorial_complete_out_proto_406?: (POGOProtos.Rpc.IMarkTutorialCompleteOutProto|null);
                set_neutral_avatar_out_proto_408?: (POGOProtos.Rpc.ISetNeutralAvatarOutProto|null);
                list_avatar_store_items_out_proto_409?: (POGOProtos.Rpc.IListAvatarStoreItemsOutProto|null);
                list_avatar_appearance_items_out_proto_410?: (POGOProtos.Rpc.IListAvatarAppearanceItemsOutProto|null);
                neutral_avatar_badge_reward_out_proto_450?: (POGOProtos.Rpc.INeutralAvatarBadgeRewardOutProto|null);
                checkchallenge_out_proto_600?: (POGOProtos.Rpc.ICheckChallengeOutProto|null);
                verify_challenge_out_proto_601?: (POGOProtos.Rpc.IVerifyChallengeOutProto|null);
                echo_out_proto_666?: (POGOProtos.Rpc.IEchoOutProto|null);
                register_sfidaresponse_800?: (POGOProtos.Rpc.IRegisterSfidaResponse|null);
                sfida_certification_response_802?: (POGOProtos.Rpc.ISfidaCertificationResponse|null);
                sfida_update_response_803?: (POGOProtos.Rpc.ISfidaUpdateResponse|null);
                sfida_dowser_response_805?: (POGOProtos.Rpc.ISfidaDowserResponse|null);
                sfida_capture_response_806?: (POGOProtos.Rpc.ISfidaCaptureResponse|null);
                list_avatar_customizations_out_proto_807?: (POGOProtos.Rpc.IListAvatarCustomizationsOutProto|null);
                set_avatar_item_as_viewed_out_proto_808?: (POGOProtos.Rpc.ISetAvatarItemAsViewedOutProto|null);
                get_inbox_out_proto_809?: (POGOProtos.Rpc.IGetInboxOutProto|null);
                list_gym_badges_out_proto_811?: (POGOProtos.Rpc.IListGymBadgesOutProto|null);
                getgym_badge_details_out_proto_812?: (POGOProtos.Rpc.IGetGymBadgeDetailsOutProto|null);
                use_item_move_reroll_out_proto_813?: (POGOProtos.Rpc.IUseItemMoveRerollOutProto|null);
                use_item_rare_candy_out_proto_814?: (POGOProtos.Rpc.IUseItemRareCandyOutProto|null);
                award_free_raid_ticket_out_proto_815?: (POGOProtos.Rpc.IAwardFreeRaidTicketOutProto|null);
                fetch_all_news_out_proto_816?: (POGOProtos.Rpc.IFetchAllNewsOutProto|null);
                mark_read_news_article_out_proto_817?: (POGOProtos.Rpc.IMarkReadNewsArticleOutProto|null);
                internal_get_player_settings_out_proto_818?: (POGOProtos.Rpc.IInternalGetPlayerSettingsOutProto|null);
                beluga_transaction_start_out_proto_819?: (POGOProtos.Rpc.IBelugaTransactionStartOutProto|null);
                beluga_transaction_complete_out_proto_820?: (POGOProtos.Rpc.IBelugaTransactionCompleteOutProto|null);
                sfida_associate_response_822?: (POGOProtos.Rpc.ISfidaAssociateResponse|null);
                sfida_check_pairing_response_823?: (POGOProtos.Rpc.ISfidaCheckPairingResponse|null);
                sfida_disassociate_response_824?: (POGOProtos.Rpc.ISfidaDisassociateResponse|null);
                waina_get_rewards_response_825?: (POGOProtos.Rpc.IWainaGetRewardsResponse|null);
                waina_submit_sleep_data_response_826?: (POGOProtos.Rpc.IWainaSubmitSleepDataResponse|null);
                saturdaystart_out_proto_827?: (POGOProtos.Rpc.ISaturdayStartOutProto|null);
                saturday_complete_out_proto_828?: (POGOProtos.Rpc.ISaturdayCompleteOutProto|null);
                lift_user_age_gate_confirmation_out_proto_830?: (POGOProtos.Rpc.ILiftUserAgeGateConfirmationOutProto|null);
                get_new_quests_out_proto_900?: (POGOProtos.Rpc.IGetNewQuestsOutProto|null);
                get_quest_details_out_proto_901?: (POGOProtos.Rpc.IGetQuestDetailsOutProto|null);
                complete_quest_out_proto_902?: (POGOProtos.Rpc.ICompleteQuestOutProto|null);
                remove_quest_out_proto_903?: (POGOProtos.Rpc.IRemoveQuestOutProto|null);
                quest_encounter_out_proto_904?: (POGOProtos.Rpc.IQuestEncounterOutProto|null);
                complete_quest_stampcard_out_proto_905?: (POGOProtos.Rpc.ICompleteQuestStampCardOutProto|null);
                progress_quest_outproto_906?: (POGOProtos.Rpc.IProgressQuestOutProto|null);
                read_quest_dialog_out_proto_908?: (POGOProtos.Rpc.IReadQuestDialogOutProto|null);
                send_gift_out_proto_950?: (POGOProtos.Rpc.ISendGiftOutProto|null);
                open_giftout_proto_951?: (POGOProtos.Rpc.IOpenGiftOutProto|null);
                getgift_box_details_out_proto_952?: (POGOProtos.Rpc.IGetGiftBoxDetailsOutProto|null);
                delete_gift_out_proto_953?: (POGOProtos.Rpc.IDeleteGiftOutProto|null);
                save_playersnapshot_out_proto_954?: (POGOProtos.Rpc.ISavePlayerSnapshotOutProto|null);
                get_friendship_rewards_out_proto_955?: (POGOProtos.Rpc.IGetFriendshipRewardsOutProto|null);
                check_send_gift_out_proto_956?: (POGOProtos.Rpc.ICheckSendGiftOutProto|null);
                set_friend_nickname_out_proto_957?: (POGOProtos.Rpc.ISetFriendNicknameOutProto|null);
                delete_gift_from_inventory_out_proto_958?: (POGOProtos.Rpc.IDeleteGiftFromInventoryOutProto|null);
                savesocial_playersettings_out_proto_959?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsOutProto|null);
                open_tradingout_proto_970?: (POGOProtos.Rpc.IOpenTradingOutProto|null);
                update_trading_out_proto_971?: (POGOProtos.Rpc.IUpdateTradingOutProto|null);
                confirm_trading_out_proto_972?: (POGOProtos.Rpc.IConfirmTradingOutProto|null);
                cancel_trading_out_proto_973?: (POGOProtos.Rpc.ICancelTradingOutProto|null);
                get_trading_out_proto_974?: (POGOProtos.Rpc.IGetTradingOutProto|null);
                get_fitness_rewards_out_proto_980?: (POGOProtos.Rpc.IGetFitnessRewardsOutProto|null);
                get_combat_player_profile_out_proto_990?: (POGOProtos.Rpc.IGetCombatPlayerProfileOutProto|null);
                generate_combat_challenge_id_out_proto_991?: (POGOProtos.Rpc.IGenerateCombatChallengeIdOutProto|null);
                createcombatchallenge_out_proto_992?: (POGOProtos.Rpc.ICreateCombatChallengeOutProto|null);
                open_combat_challengeout_proto_993?: (POGOProtos.Rpc.IOpenCombatChallengeOutProto|null);
                get_combat_challenge_out_proto_994?: (POGOProtos.Rpc.IGetCombatChallengeOutProto|null);
                accept_combat_challenge_out_proto_995?: (POGOProtos.Rpc.IAcceptCombatChallengeOutProto|null);
                decline_combat_challenge_out_proto_996?: (POGOProtos.Rpc.IDeclineCombatChallengeOutProto|null);
                cancelcombatchallenge_out_proto_997?: (POGOProtos.Rpc.ICancelCombatChallengeOutProto|null);
                submit_combat_challenge_pokemons_out_proto_998?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsOutProto|null);
                save_combat_player_preferences_out_proto_999?: (POGOProtos.Rpc.ISaveCombatPlayerPreferencesOutProto|null);
                open_combat_sessionout_proto_1000?: (POGOProtos.Rpc.IOpenCombatSessionOutProto|null);
                update_combat_out_proto_1001?: (POGOProtos.Rpc.IUpdateCombatOutProto|null);
                quit_combat_out_proto_1002?: (POGOProtos.Rpc.IQuitCombatOutProto|null);
                get_combat_results_out_proto_1003?: (POGOProtos.Rpc.IGetCombatResultsOutProto|null);
                unlock_pokemon_move_out_proto_1004?: (POGOProtos.Rpc.IUnlockPokemonMoveOutProto|null);
                get_npc_combat_rewards_out_proto_1005?: (POGOProtos.Rpc.IGetNpcCombatRewardsOutProto|null);
                combat_friend_request_out_proto_1006?: (POGOProtos.Rpc.ICombatFriendRequestOutProto|null);
                open_npc_combat_sessionout_proto_1007?: (POGOProtos.Rpc.IOpenNpcCombatSessionOutProto|null);
                send_probe_out_proto_1020?: (POGOProtos.Rpc.ISendProbeOutProto|null);
                check_photobomb_out_proto_1101?: (POGOProtos.Rpc.ICheckPhotobombOutProto|null);
                confirm_photobomb_out_proto_1102?: (POGOProtos.Rpc.IConfirmPhotobombOutProto|null);
                get_photobomb_out_proto_1103?: (POGOProtos.Rpc.IGetPhotobombOutProto|null);
                encounter_photobomb_out_proto_1104?: (POGOProtos.Rpc.IEncounterPhotobombOutProto|null);
                getgmap_settings_out_proto_1105?: (POGOProtos.Rpc.IGetGmapSettingsOutProto|null);
                change_team_out_proto_1106?: (POGOProtos.Rpc.IChangeTeamOutProto|null);
                get_web_token_out_proto_1107?: (POGOProtos.Rpc.IGetWebTokenOutProto|null);
                complete_snapshot_session_out_proto_1110?: (POGOProtos.Rpc.ICompleteSnapshotSessionOutProto|null);
                complete_wild_snapshot_session_out_proto_1111?: (POGOProtos.Rpc.ICompleteWildSnapshotSessionOutProto|null);
                start_incident_out_proto_1200?: (POGOProtos.Rpc.IStartIncidentOutProto|null);
                complete_invasion_dialogue_out_proto_1201?: (POGOProtos.Rpc.ICompleteInvasionDialogueOutProto|null);
                open_invasion_combat_sessionout_proto_1202?: (POGOProtos.Rpc.IOpenInvasionCombatSessionOutProto|null);
                update_invasion_battle_out_proto_1203?: (POGOProtos.Rpc.IUpdateInvasionBattleOutProto|null);
                invasion_encounter_out_proto_1204?: (POGOProtos.Rpc.IInvasionEncounterOutProto|null);
                purifypokemon_outproto_1205?: (POGOProtos.Rpc.IPurifyPokemonOutProto|null);
                get_rocket_balloon_out_proto_1206?: (POGOProtos.Rpc.IGetRocketBalloonOutProto|null);
                vs_seeker_start_matchmaking_out_proto_1300?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingOutProto|null);
                cancel_matchmaking_out_proto_1301?: (POGOProtos.Rpc.ICancelMatchmakingOutProto|null);
                get_matchmaking_status_out_proto_1302?: (POGOProtos.Rpc.IGetMatchmakingStatusOutProto|null);
                complete_vs_seeker_and_restartcharging_out_proto_1303?: (POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingOutProto|null);
                get_vs_seeker_status_out_proto_1304?: (POGOProtos.Rpc.IGetVsSeekerStatusOutProto|null);
                completecompetitive_season_out_proto_1305?: (POGOProtos.Rpc.ICompleteCompetitiveSeasonOutProto|null);
                claim_vs_seeker_rewards_out_proto_1306?: (POGOProtos.Rpc.IClaimVsSeekerRewardsOutProto|null);
                vs_seeker_reward_encounter_out_proto_1307?: (POGOProtos.Rpc.IVsSeekerRewardEncounterOutProto|null);
                activate_vs_seeker_out_proto_1308?: (POGOProtos.Rpc.IActivateVsSeekerOutProto|null);
                buddy_map_out_proto_1350?: (POGOProtos.Rpc.IBuddyMapOutProto|null);
                buddy_stats_out_proto_1351?: (POGOProtos.Rpc.IBuddyStatsOutProto|null);
                buddy_feeding_out_proto_1352?: (POGOProtos.Rpc.IBuddyFeedingOutProto|null);
                open_buddy_giftout_proto_1353?: (POGOProtos.Rpc.IOpenBuddyGiftOutProto|null);
                buddy_petting_out_proto_1354?: (POGOProtos.Rpc.IBuddyPettingOutProto|null);
                get_buddy_history_out_proto_1355?: (POGOProtos.Rpc.IGetBuddyHistoryOutProto|null);
                update_route_draft_out_proto_1400?: (POGOProtos.Rpc.IUpdateRouteDraftOutProto|null);
                get_map_forts_out_proto_1401?: (POGOProtos.Rpc.IGetMapFortsOutProto|null);
                submit_route_draft_out_proto_1402?: (POGOProtos.Rpc.ISubmitRouteDraftOutProto|null);
                get_published_routes_out_proto_1403?: (POGOProtos.Rpc.IGetPublishedRoutesOutProto|null);
                start_route_out_proto_1404?: (POGOProtos.Rpc.IStartRouteOutProto|null);
                get_routes_out_proto_1405?: (POGOProtos.Rpc.IGetRoutesOutProto|null);
                progress_route_outproto_1406?: (POGOProtos.Rpc.IProgressRouteOutProto|null);
                process_tappable_outproto_1408?: (POGOProtos.Rpc.IProcessTappableOutProto|null);
                list_route_badges_out_proto_1409?: (POGOProtos.Rpc.IListRouteBadgesOutProto|null);
                cancel_route_out_proto_1410?: (POGOProtos.Rpc.ICancelRouteOutProto|null);
                list_route_stamps_out_proto_1411?: (POGOProtos.Rpc.IListRouteStampsOutProto|null);
                rateroute_out_proto_1412?: (POGOProtos.Rpc.IRateRouteOutProto|null);
                create_route_draft_out_proto_1413?: (POGOProtos.Rpc.ICreateRouteDraftOutProto|null);
                delete_routedraft_out_proto_1414?: (POGOProtos.Rpc.IDeleteRouteDraftOutProto|null);
                reportroute_out_proto_1415?: (POGOProtos.Rpc.IReportRouteOutProto|null);
                process_tappable_outproto_1416?: (POGOProtos.Rpc.IProcessTappableOutProto|null);
                attracted_pokemon_encounter_out_proto_1417?: (POGOProtos.Rpc.IAttractedPokemonEncounterOutProto|null);
                can_report_route_out_proto_1418?: (POGOProtos.Rpc.ICanReportRouteOutProto|null);
                route_update_seen_out_proto_1420?: (POGOProtos.Rpc.IRouteUpdateSeenOutProto|null);
                recallroute_draft_out_proto_1421?: (POGOProtos.Rpc.IRecallRouteDraftOutProto|null);
                route_nearby_notif_shown_out_proto_1422?: (POGOProtos.Rpc.IRouteNearbyNotifShownOutProto|null);
                npc_route_gift_out_proto_1423?: (POGOProtos.Rpc.INpcRouteGiftOutProto|null);
                get_route_creations_out_proto_1424?: (POGOProtos.Rpc.IGetRouteCreationsOutProto|null);
                appeal_route_out_proto_1425?: (POGOProtos.Rpc.IAppealRouteOutProto|null);
                get_route_draft_out_proto_1426?: (POGOProtos.Rpc.IGetRouteDraftOutProto|null);
                favorite_route_out_proto_1427?: (POGOProtos.Rpc.IFavoriteRouteOutProto|null);
                create_route_shortcode_out_proto_1428?: (POGOProtos.Rpc.ICreateRouteShortcodeOutProto|null);
                get_route_by_short_code_out_proto_1429?: (POGOProtos.Rpc.IGetRouteByShortCodeOutProto|null);
                create_buddy_multiplayer_session_out_proto_1456?: (POGOProtos.Rpc.ICreateBuddyMultiplayerSessionOutProto|null);
                join_buddy_multiplayer_session_out_proto_1457?: (POGOProtos.Rpc.IJoinBuddyMultiplayerSessionOutProto|null);
                leave_buddy_multiplayer_session_out_proto_1458?: (POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionOutProto|null);
                mega_evolve_pokemon_out_proto_1502?: (POGOProtos.Rpc.IMegaEvolvePokemonOutProto|null);
                remote_gift_pingresponse_proto_1503?: (POGOProtos.Rpc.IRemoteGiftPingResponseProto|null);
                send_raid_invitation_out_proto_1504?: (POGOProtos.Rpc.ISendRaidInvitationOutProto|null);
                send_bread_battle_invitation_out_proto_1505?: (POGOProtos.Rpc.ISendBreadBattleInvitationOutProto|null);
                get_daily_encounter_out_proto_1601?: (POGOProtos.Rpc.IGetDailyEncounterOutProto|null);
                daily_encounter_out_proto_1602?: (POGOProtos.Rpc.IDailyEncounterOutProto|null);
                open_sponsored_giftout_proto_1650?: (POGOProtos.Rpc.IOpenSponsoredGiftOutProto|null);
                report_ad_interactionresponse_1651?: (POGOProtos.Rpc.IReportAdInteractionResponse|null);
                save_player_preferences_out_proto_1652?: (POGOProtos.Rpc.ISavePlayerPreferencesOutProto|null);
                profanity_check_outproto_1653?: (POGOProtos.Rpc.IProfanityCheckOutProto|null);
                get_timedgroup_challenge_out_proto_1700?: (POGOProtos.Rpc.IGetTimedGroupChallengeOutProto|null);
                get_nintendo_account_out_proto_1710?: (POGOProtos.Rpc.IGetNintendoAccountOutProto|null);
                unlink_nintendo_account_out_proto_1711?: (POGOProtos.Rpc.IUnlinkNintendoAccountOutProto|null);
                get_nintendo_o_auth2_url_out_proto_1712?: (POGOProtos.Rpc.IGetNintendoOAuth2UrlOutProto|null);
                transfer_pokemonto_pokemon_home_out_proto_1713?: (POGOProtos.Rpc.ITransferPokemonToPokemonHomeOutProto|null);
                report_ad_feedbackresponse_1716?: (POGOProtos.Rpc.IReportAdFeedbackResponse|null);
                create_pokemon_tag_out_proto_1717?: (POGOProtos.Rpc.ICreatePokemonTagOutProto|null);
                delete_pokemon_tag_out_proto_1718?: (POGOProtos.Rpc.IDeletePokemonTagOutProto|null);
                edit_pokemon_tag_out_proto_1719?: (POGOProtos.Rpc.IEditPokemonTagOutProto|null);
                set_pokemon_tags_for_pokemon_out_proto_1720?: (POGOProtos.Rpc.ISetPokemonTagsForPokemonOutProto|null);
                get_pokemon_tags_out_proto_1721?: (POGOProtos.Rpc.IGetPokemonTagsOutProto|null);
                change_pokemon_form_out_proto_1722?: (POGOProtos.Rpc.IChangePokemonFormOutProto|null);
                choose_global_ticketed_event_variant_out_proto_1723?: (POGOProtos.Rpc.IChooseGlobalTicketedEventVariantOutProto|null);
                butterfly_collector_reward_encounter_proto_response_1724?: (POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoResponse|null);
                get_additional_pokemon_details_out_proto_1725?: (POGOProtos.Rpc.IGetAdditionalPokemonDetailsOutProto|null);
                create_route_pin_out_proto_1726?: (POGOProtos.Rpc.ICreateRoutePinOutProto|null);
                like_route_pin_out_proto_1727?: (POGOProtos.Rpc.ILikeRoutePinOutProto|null);
                view_route_pin_out_proto_1728?: (POGOProtos.Rpc.IViewRoutePinOutProto|null);
                get_referral_code_out_proto_1800?: (POGOProtos.Rpc.IGetReferralCodeOutProto|null);
                add_referrer_out_proto_1801?: (POGOProtos.Rpc.IAddReferrerOutProto|null);
                send_friend_invite_via_referral_code_out_proto_1802?: (POGOProtos.Rpc.ISendFriendInviteViaReferralCodeOutProto|null);
                get_milestones_out_proto_1803?: (POGOProtos.Rpc.IGetMilestonesOutProto|null);
                markmilestone_as_viewed_out_proto_1804?: (POGOProtos.Rpc.IMarkMilestoneAsViewedOutProto|null);
                get_milestones_preview_out_proto_1805?: (POGOProtos.Rpc.IGetMilestonesPreviewOutProto|null);
                complete_milestone_out_proto_1806?: (POGOProtos.Rpc.ICompleteMilestoneOutProto|null);
                getgeofenced_ad_out_proto_1820?: (POGOProtos.Rpc.IGetGeofencedAdOutProto|null);
                power_uppokestop_encounter_outproto_1900?: (POGOProtos.Rpc.IPowerUpPokestopEncounterOutProto|null);
                get_player_stamp_collections_out_proto_1901?: (POGOProtos.Rpc.IGetPlayerStampCollectionsOutProto|null);
                savestamp_out_proto_1902?: (POGOProtos.Rpc.ISaveStampOutProto|null);
                claim_stampcollection_reward_out_proto_1904?: (POGOProtos.Rpc.IClaimStampCollectionRewardOutProto|null);
                change_stampcollection_player_data_out_proto_1905?: (POGOProtos.Rpc.IChangeStampCollectionPlayerDataOutProto|null);
                check_stamp_giftability_out_proto_1906?: (POGOProtos.Rpc.ICheckStampGiftabilityOutProto|null);
                delete_postcards_out_proto_1909?: (POGOProtos.Rpc.IDeletePostcardsOutProto|null);
                create_postcard_out_proto_1910?: (POGOProtos.Rpc.ICreatePostcardOutProto|null);
                update_postcard_out_proto_1911?: (POGOProtos.Rpc.IUpdatePostcardOutProto|null);
                delete_postcard_out_proto_1912?: (POGOProtos.Rpc.IDeletePostcardOutProto|null);
                get_memento_list_out_proto_1913?: (POGOProtos.Rpc.IGetMementoListOutProto|null);
                upload_raid_client_log_out_proto_1914?: (POGOProtos.Rpc.IUploadRaidClientLogOutProto|null);
                skip_enter_referral_code_out_proto_1915?: (POGOProtos.Rpc.ISkipEnterReferralCodeOutProto|null);
                upload_combat_client_log_out_proto_1916?: (POGOProtos.Rpc.IUploadCombatClientLogOutProto|null);
                combat_sync_server_offset_out_proto_1917?: (POGOProtos.Rpc.ICombatSyncServerOffsetOutProto|null);
                check_gifting_eligibility_out_proto_2000?: (POGOProtos.Rpc.ICheckGiftingEligibilityOutProto|null);
                redeem_ticket_gift_for_friend_out_proto_2001?: (POGOProtos.Rpc.IRedeemTicketGiftForFriendOutProto|null);
                get_incense_recap_out_proto_2002?: (POGOProtos.Rpc.IGetIncenseRecapOutProto|null);
                acknowledge_view_latest_incense_recap_out_proto_2003?: (POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapOutProto|null);
                boot_raid_out_proto_2004?: (POGOProtos.Rpc.IBootRaidOutProto|null);
                get_pokestop_encounter_out_proto_2005?: (POGOProtos.Rpc.IGetPokestopEncounterOutProto|null);
                encounter_pokestopencounter_out_proto_2006?: (POGOProtos.Rpc.IEncounterPokestopEncounterOutProto|null);
                player_spawnablepokemon_outproto_2007?: (POGOProtos.Rpc.IPlayerSpawnablePokemonOutProto|null);
                get_quest_ui_out_proto_2008?: (POGOProtos.Rpc.IGetQuestUiOutProto|null);
                get_eligible_combat_leagues_out_proto_2009?: (POGOProtos.Rpc.IGetEligibleCombatLeaguesOutProto|null);
                send_friend_request_via_player_id_out_proto_2010?: (POGOProtos.Rpc.ISendFriendRequestViaPlayerIdOutProto|null);
                get_raid_lobby_counter_out_proto_2011?: (POGOProtos.Rpc.IGetRaidLobbyCounterOutProto|null);
                use_non_combat_move_response_proto_2014?: (POGOProtos.Rpc.IUseNonCombatMoveResponseProto|null);
                check_pokemon_size_leaderboard_eligibility_out_proto_2100?: (POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityOutProto|null);
                update_pokemon_size_leaderboard_entry_out_proto_2101?: (POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryOutProto|null);
                transfer_pokemon_size_leaderboard_entry_out_proto_2102?: (POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryOutProto|null);
                remove_pokemon_size_leaderboard_entry_out_proto_2103?: (POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryOutProto|null);
                get_pokemon_size_leaderboard_entry_out_proto_2104?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryOutProto|null);
                get_contest_data_out_proto_2105?: (POGOProtos.Rpc.IGetContestDataOutProto|null);
                get_contests_unclaimed_rewards_out_proto_2106?: (POGOProtos.Rpc.IGetContestsUnclaimedRewardsOutProto|null);
                claimcontests_rewards_out_proto_2107?: (POGOProtos.Rpc.IClaimContestsRewardsOutProto|null);
                get_entered_contest_out_proto_2108?: (POGOProtos.Rpc.IGetEnteredContestOutProto|null);
                get_pokemon_size_leaderboard_friend_entry_out_proto_2109?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryOutProto|null);
                checkcontest_eligibility_out_proto_2150?: (POGOProtos.Rpc.ICheckContestEligibilityOutProto|null);
                update_contest_entry_out_proto_2151?: (POGOProtos.Rpc.IUpdateContestEntryOutProto|null);
                transfer_contest_entry_out_proto_2152?: (POGOProtos.Rpc.ITransferContestEntryOutProto|null);
                get_contest_friend_entry_out_proto_2153?: (POGOProtos.Rpc.IGetContestFriendEntryOutProto|null);
                get_contest_entry_out_proto_2154?: (POGOProtos.Rpc.IGetContestEntryOutProto|null);
                create_party_out_proto_2300?: (POGOProtos.Rpc.ICreatePartyOutProto|null);
                join_party_out_proto_2301?: (POGOProtos.Rpc.IJoinPartyOutProto|null);
                start_party_out_proto_2302?: (POGOProtos.Rpc.IStartPartyOutProto|null);
                leave_party_out_proto_2303?: (POGOProtos.Rpc.ILeavePartyOutProto|null);
                get_party_out_proto_2304?: (POGOProtos.Rpc.IGetPartyOutProto|null);
                party_update_location_outproto_2305?: (POGOProtos.Rpc.IPartyUpdateLocationOutProto|null);
                party_send_dark_launch_log_outproto_2306?: (POGOProtos.Rpc.IPartySendDarkLaunchLogOutProto|null);
                start_party_quest_out_proto_2308?: (POGOProtos.Rpc.IStartPartyQuestOutProto|null);
                complete_party_quest_out_proto_2309?: (POGOProtos.Rpc.ICompletePartyQuestOutProto|null);
                get_bonus_attracted_pokemon_out_proto_2350?: (POGOProtos.Rpc.IGetBonusAttractedPokemonOutProto|null);
                get_bonuses_out_proto_2352?: (POGOProtos.Rpc.IGetBonusesOutProto|null);
                badge_reward_encounter_response_proto_2360?: (POGOProtos.Rpc.IBadgeRewardEncounterResponseProto|null);
                npc_update_state_out_proto_2400?: (POGOProtos.Rpc.INpcUpdateStateOutProto|null);
                npc_send_gift_out_proto_2401?: (POGOProtos.Rpc.INpcSendGiftOutProto|null);
                npc_open_gift_out_proto_2402?: (POGOProtos.Rpc.INpcOpenGiftOutProto|null);
                join_bread_lobby_out_proto_2450?: (POGOProtos.Rpc.IJoinBreadLobbyOutProto|null);
                prepare_bread_lobby_outproto_2453?: (POGOProtos.Rpc.IPrepareBreadLobbyOutProto|null);
                leave_breadlobby_out_proto_2455?: (POGOProtos.Rpc.ILeaveBreadLobbyOutProto|null);
                start_bread_battle_out_proto_2456?: (POGOProtos.Rpc.IStartBreadBattleOutProto|null);
                get_bread_lobby_details_out_proto_2457?: (POGOProtos.Rpc.IGetBreadLobbyDetailsOutProto|null);
                start_mp_walk_quest_out_proto_2458?: (POGOProtos.Rpc.IStartMpWalkQuestOutProto|null);
                enhance_bread_move_out_proto_2459?: (POGOProtos.Rpc.IEnhanceBreadMoveOutProto|null);
                station_pokemon_out_proto_2460?: (POGOProtos.Rpc.IStationPokemonOutProto|null);
                loot_station_out_proto_2461?: (POGOProtos.Rpc.ILootStationOutProto|null);
                get_stationed_pokemon_details_out_proto_2462?: (POGOProtos.Rpc.IGetStationedPokemonDetailsOutProto|null);
                mark_save_for_later_out_proto_2463?: (POGOProtos.Rpc.IMarkSaveForLaterOutProto|null);
                use_save_for_later_out_proto_2464?: (POGOProtos.Rpc.IUseSaveForLaterOutProto|null);
                remove_save_for_later_out_proto_2465?: (POGOProtos.Rpc.IRemoveSaveForLaterOutProto|null);
                get_save_for_later_entries_out_proto_2466?: (POGOProtos.Rpc.IGetSaveForLaterEntriesOutProto|null);
                get_mp_summary_out_proto_2467?: (POGOProtos.Rpc.IGetMpSummaryOutProto|null);
                use_item_mp_replenish_out_proto_2468?: (POGOProtos.Rpc.IUseItemMpReplenishOutProto|null);
                report_station_out_proto_2470?: (POGOProtos.Rpc.IReportStationOutProto|null);
                debug_resetdaily_mp_progress_out_proto_2471?: (POGOProtos.Rpc.IDebugResetDailyMpProgressOutProto|null);
                release_stationed_pokemon_out_proto_2472?: (POGOProtos.Rpc.IReleaseStationedPokemonOutProto|null);
                complete_bread_battle_out_proto_2473?: (POGOProtos.Rpc.ICompleteBreadBattleOutProto|null);
                encounter_station_spawn_out_proto_2475?: (POGOProtos.Rpc.IEncounterStationSpawnOutProto|null);
                get_num_station_assists_out_proto_2476?: (POGOProtos.Rpc.IGetNumStationAssistsOutProto|null);
                get_vps_event_out_proto_3000?: (POGOProtos.Rpc.IGetVpsEventOutProto|null);
                update_vps_event_out_proto_3001?: (POGOProtos.Rpc.IUpdateVpsEventOutProto|null);
                add_ptc_loginaction_out_proto_3002?: (POGOProtos.Rpc.IAddPtcLoginActionOutProto|null);
                claim_ptc_linking_reward_out_proto_3003?: (POGOProtos.Rpc.IClaimPtcLinkingRewardOutProto|null);
                canclaim_ptc_reward_action_out_proto_3004?: (POGOProtos.Rpc.ICanClaimPtcRewardActionOutProto|null);
                contribute_party_item_out_proto_3005?: (POGOProtos.Rpc.IContributePartyItemOutProto|null);
                consume_party_items_out_proto_3006?: (POGOProtos.Rpc.IConsumePartyItemsOutProto|null);
                remove_ptc_login_action_out_proto_3007?: (POGOProtos.Rpc.IRemovePtcLoginActionOutProto|null);
                send_party_invitation_out_proto_3008?: (POGOProtos.Rpc.ISendPartyInvitationOutProto|null);
                consume_stickers_out_proto_3009?: (POGOProtos.Rpc.IConsumeStickersOutProto|null);
                complete_raid_battle_out_proto_3010?: (POGOProtos.Rpc.ICompleteRaidBattleOutProto|null);
                sync_battle_inventory_out_proto_3011?: (POGOProtos.Rpc.ISyncBattleInventoryOutProto|null);
                preview_contributeparty_item_outproto_3015?: (POGOProtos.Rpc.IPreviewContributePartyItemOutProto|null);
                kick_other_player_from_party_out_proto_3016?: (POGOProtos.Rpc.IKickOtherPlayerFromPartyOutProto|null);
                fuse_pokemon_response_proto_3017?: (POGOProtos.Rpc.IFusePokemonResponseProto|null);
                unfuse_pokemon_response_proto_3018?: (POGOProtos.Rpc.IUnfusePokemonResponseProto|null);
                get_iris_social_scene_out_proto_3019?: (POGOProtos.Rpc.IGetIrisSocialSceneOutProto|null);
                update_iris_social_scene_out_proto_3020?: (POGOProtos.Rpc.IUpdateIrisSocialSceneOutProto|null);
                get_change_pokemon_form_preview_response_proto_3021?: (POGOProtos.Rpc.IGetChangePokemonFormPreviewResponseProto|null);
                get_unfuse_pokemon_preview_response_proto_3023?: (POGOProtos.Rpc.IGetUnfusePokemonPreviewResponseProto|null);
                processplayer_inbox_outproto_3024?: (POGOProtos.Rpc.IProcessPlayerInboxOutProto|null);
                get_survey_eligibility_out_proto_3025?: (POGOProtos.Rpc.IGetSurveyEligibilityOutProto|null);
                update_survey_eligibility_out_proto_3026?: (POGOProtos.Rpc.IUpdateSurveyEligibilityOutProto|null);
                smart_glassessyncsettings_response_proto_3027?: (POGOProtos.Rpc.ISmartGlassesSyncSettingsResponseProto|null);
                complete_visit_page_quest_out_proto_3030?: (POGOProtos.Rpc.ICompleteVisitPageQuestOutProto|null);
                get_event_rsvps_out_proto_3031?: (POGOProtos.Rpc.IGetEventRsvpsOutProto|null);
                create_event_rsvp_out_proto_3032?: (POGOProtos.Rpc.ICreateEventRsvpOutProto|null);
                cancel_event_rsvp_out_proto_3033?: (POGOProtos.Rpc.ICancelEventRsvpOutProto|null);
                claim_event_pass_rewards_response_proto_3034?: (POGOProtos.Rpc.IClaimEventPassRewardsResponseProto|null);
                get_event_rsvp_count_out_proto_3036?: (POGOProtos.Rpc.IGetEventRsvpCountOutProto|null);
                send_event_rsvp_invitation_out_proto_3039?: (POGOProtos.Rpc.ISendEventRsvpInvitationOutProto|null);
                update_event_rsvp_selection_out_proto_3040?: (POGOProtos.Rpc.IUpdateEventRsvpSelectionOutProto|null);
                get_station_info_out_proto_3051?: (POGOProtos.Rpc.IGetStationInfoOutProto|null);
                age_confirmation_out_proto_3052?: (POGOProtos.Rpc.IAgeConfirmationOutProto|null);
                change_stat_increase_goal_out_proto_3053?: (POGOProtos.Rpc.IChangeStatIncreaseGoalOutProto|null);
                push_notification_registry_outproto_5000?: (POGOProtos.Rpc.IPushNotificationRegistryOutProto|null);
                update_notification_out_proto_5002?: (POGOProtos.Rpc.IUpdateNotificationOutProto|null);
                optout_proto_5003?: (POGOProtos.Rpc.IOptOutProto|null);
                download_gm_templates_response_proto_5004?: (POGOProtos.Rpc.IDownloadGmTemplatesResponseProto|null);
                get_inventory_response_proto_5005?: (POGOProtos.Rpc.IGetInventoryResponseProto|null);
                redeem_passcoderesponse_proto_5006?: (POGOProtos.Rpc.IRedeemPasscodeResponseProto|null);
                ping_responseproto_5007?: (POGOProtos.Rpc.IPingResponseProto|null);
                add_loginaction_out_proto_5008?: (POGOProtos.Rpc.IAddLoginActionOutProto|null);
                remove_login_action_out_proto_5009?: (POGOProtos.Rpc.IRemoveLoginActionOutProto|null);
                listlogin_action_out_proto_5010?: (POGOProtos.Rpc.IListLoginActionOutProto|null);
                submit_new_poi_out_proto_5011?: (POGOProtos.Rpc.ISubmitNewPoiOutProto|null);
                proxy_responseproto_5012?: (POGOProtos.Rpc.IProxyResponseProto|null);
                get_available_submissions_out_proto_5014?: (POGOProtos.Rpc.IGetAvailableSubmissionsOutProto|null);
                replace_login_action_out_proto_5015?: (POGOProtos.Rpc.IReplaceLoginActionOutProto|null);
                iap_purchase_sku_out_proto_5019?: (POGOProtos.Rpc.IIapPurchaseSkuOutProto|null);
                iap_get_available_skus_and_balances_out_proto_5020?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesOutProto|null);
                iap_redeem_google_receipt_out_proto_5021?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptOutProto|null);
                iap_redeem_apple_receipt_out_proto_5022?: (POGOProtos.Rpc.IIapRedeemAppleReceiptOutProto|null);
                iap_redeem_desktop_receipt_out_proto_5023?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptOutProto|null);
                fitness_update_out_proto_5024?: (POGOProtos.Rpc.IFitnessUpdateOutProto|null);
                get_fitness_report_out_proto_5025?: (POGOProtos.Rpc.IGetFitnessReportOutProto|null);
                client_telemetryclient_settings_proto_5026?: (POGOProtos.Rpc.IClientTelemetryClientSettingsProto|null);
                auth_register_background_device_response_proto_5028?: (POGOProtos.Rpc.IAuthRegisterBackgroundDeviceResponseProto|null);
                internal_setin_game_currency_exchange_rate_out_proto_5032?: (POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateOutProto|null);
                geofence_update_out_proto_5033?: (POGOProtos.Rpc.IGeofenceUpdateOutProto|null);
                location_ping_out_proto_5034?: (POGOProtos.Rpc.ILocationPingOutProto|null);
                generategmap_signed_url_out_proto_5035?: (POGOProtos.Rpc.IGenerateGmapSignedUrlOutProto|null);
                getgmap_settings_out_proto_5036?: (POGOProtos.Rpc.IGetGmapSettingsOutProto|null);
                iap_redeem_samsung_receipt_out_proto_5037?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptOutProto|null);
                get_outstanding_warnings_response_proto_5039?: (POGOProtos.Rpc.IGetOutstandingWarningsResponseProto|null);
                acknowledge_warnings_response_proto_5040?: (POGOProtos.Rpc.IAcknowledgeWarningsResponseProto|null);
                get_web_token_out_proto_5045?: (POGOProtos.Rpc.IGetWebTokenOutProto|null);
                get_adventure_sync_settings_response_proto_5046?: (POGOProtos.Rpc.IGetAdventureSyncSettingsResponseProto|null);
                update_adventure_sync_settings_response_proto_5047?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsResponseProto|null);
                set_birthday_response_proto_5048?: (POGOProtos.Rpc.ISetBirthdayResponseProto|null);
                fetch_newsfeed_response_5049?: (POGOProtos.Rpc.IFetchNewsfeedResponse|null);
                mark_newsfeed_read_response_5050?: (POGOProtos.Rpc.IMarkNewsfeedReadResponse|null);
                internal_search_player_out_proto_10000?: (POGOProtos.Rpc.IInternalSearchPlayerOutProto|null);
                internal_send_friendinvite_out_proto_10002?: (POGOProtos.Rpc.IInternalSendFriendInviteOutProto|null);
                internal_cancel_friendinvite_out_proto_10003?: (POGOProtos.Rpc.IInternalCancelFriendInviteOutProto|null);
                internal_accept_friendinvite_out_proto_10004?: (POGOProtos.Rpc.IInternalAcceptFriendInviteOutProto|null);
                internal_decline_friendinvite_out_proto_10005?: (POGOProtos.Rpc.IInternalDeclineFriendInviteOutProto|null);
                internal_get_friends_list_out_proto_10006?: (POGOProtos.Rpc.IInternalGetFriendsListOutProto|null);
                internal_get_outgoing_friendinvites_out_proto_10007?: (POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesOutProto|null);
                internal_getincoming_friendinvites_out_proto_10008?: (POGOProtos.Rpc.IInternalGetIncomingFriendInvitesOutProto|null);
                internal_remove_friend_out_proto_10009?: (POGOProtos.Rpc.IInternalRemoveFriendOutProto|null);
                internal_get_friend_details_out_proto_10010?: (POGOProtos.Rpc.IInternalGetFriendDetailsOutProto|null);
                internalinvite_facebook_friend_out_proto_10011?: (POGOProtos.Rpc.IInternalInviteFacebookFriendOutProto|null);
                internalis_my_friend_out_proto_10012?: (POGOProtos.Rpc.IInternalIsMyFriendOutProto|null);
                internal_get_friend_code_out_proto_10013?: (POGOProtos.Rpc.IInternalGetFriendCodeOutProto|null);
                internal_get_facebook_friend_list_out_proto_10014?: (POGOProtos.Rpc.IInternalGetFacebookFriendListOutProto|null);
                internal_update_facebook_status_out_proto_10015?: (POGOProtos.Rpc.IInternalUpdateFacebookStatusOutProto|null);
                savesocial_playersettings_out_proto_10016?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsOutProto|null);
                internal_get_player_settings_out_proto_10017?: (POGOProtos.Rpc.IInternalGetPlayerSettingsOutProto|null);
                internal_set_account_settings_out_proto_10021?: (POGOProtos.Rpc.IInternalSetAccountSettingsOutProto|null);
                internal_get_account_settings_out_proto_10022?: (POGOProtos.Rpc.IInternalGetAccountSettingsOutProto|null);
                internal_add_favorite_friend_response_10023?: (POGOProtos.Rpc.IInternalAddFavoriteFriendResponse|null);
                internal_remove_favorite_friend_response_10024?: (POGOProtos.Rpc.IInternalRemoveFavoriteFriendResponse|null);
                internal_block_account_out_proto_10025?: (POGOProtos.Rpc.IInternalBlockAccountOutProto|null);
                internal_unblock_account_out_proto_10026?: (POGOProtos.Rpc.IInternalUnblockAccountOutProto|null);
                internal_get_outgoing_blocks_out_proto_10027?: (POGOProtos.Rpc.IInternalGetOutgoingBlocksOutProto|null);
                internalis_account_blocked_out_proto_10028?: (POGOProtos.Rpc.IInternalIsAccountBlockedOutProto|null);
                list_friend_activities_response_proto_10029?: (POGOProtos.Rpc.IListFriendActivitiesResponseProto|null);
                internal_push_notification_registry_out_proto_10101?: (POGOProtos.Rpc.IInternalPushNotificationRegistryOutProto|null);
                internal_update_notification_out_proto_10103?: (POGOProtos.Rpc.IInternalUpdateNotificationOutProto|null);
                optout_proto_10104?: (POGOProtos.Rpc.IOptOutProto|null);
                get_inbox_out_proto_10105?: (POGOProtos.Rpc.IGetInboxOutProto|null);
                internal_list_opt_out_notification_categories_response_proto_10106?: (POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesResponseProto|null);
                internal_get_signed_url_out_proto_10201?: (POGOProtos.Rpc.IInternalGetSignedUrlOutProto|null);
                internal_submitimage_out_proto_10202?: (POGOProtos.Rpc.IInternalSubmitImageOutProto|null);
                internal_get_photos_out_proto_10203?: (POGOProtos.Rpc.IInternalGetPhotosOutProto|null);
                internal_update_profile_response_20001?: (POGOProtos.Rpc.IInternalUpdateProfileResponse|null);
                internal_update_friendship_response_20002?: (POGOProtos.Rpc.IInternalUpdateFriendshipResponse|null);
                internal_get_profile_response_20003?: (POGOProtos.Rpc.IInternalGetProfileResponse|null);
                internalinvite_game_response_20004?: (POGOProtos.Rpc.IInternalInviteGameResponse|null);
                internal_list_friends_response_20006?: (POGOProtos.Rpc.IInternalListFriendsResponse|null);
                internal_get_friend_details_out_proto_20007?: (POGOProtos.Rpc.IInternalGetFriendDetailsOutProto|null);
                internal_get_client_feature_flags_response_20008?: (POGOProtos.Rpc.IInternalGetClientFeatureFlagsResponse|null);
                internal_getincoming_gameinvites_response_20010?: (POGOProtos.Rpc.IInternalGetIncomingGameInvitesResponse|null);
                internal_updateincoming_gameinvite_response_20011?: (POGOProtos.Rpc.IInternalUpdateIncomingGameInviteResponse|null);
                internal_dismiss_outgoing_gameinvites_response_20012?: (POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesResponse|null);
                internal_sync_contact_list_response_20013?: (POGOProtos.Rpc.IInternalSyncContactListResponse|null);
                internal_send_contact_list_friendinvite_response_20014?: (POGOProtos.Rpc.IInternalSendContactListFriendInviteResponse|null);
                internal_refer_contact_list_friend_response_20015?: (POGOProtos.Rpc.IInternalReferContactListFriendResponse|null);
                internal_get_contact_listinfo_response_20016?: (POGOProtos.Rpc.IInternalGetContactListInfoResponse|null);
                internal_dismiss_contact_list_update_response_20017?: (POGOProtos.Rpc.IInternalDismissContactListUpdateResponse|null);
                internal_notify_contact_list_friends_response_20018?: (POGOProtos.Rpc.IInternalNotifyContactListFriendsResponse|null);
                internal_get_friend_recommendation_response_20500?: (POGOProtos.Rpc.IInternalGetFriendRecommendationResponse|null);
                get_outstanding_warnings_response_proto_200000?: (POGOProtos.Rpc.IGetOutstandingWarningsResponseProto|null);
                acknowledge_warnings_response_proto_200001?: (POGOProtos.Rpc.IAcknowledgeWarningsResponseProto|null);
                register_background_deviceresponse_proto_230000?: (POGOProtos.Rpc.IRegisterBackgroundDeviceResponseProto|null);
                get_adventure_sync_progress_out_proto_230002?: (POGOProtos.Rpc.IGetAdventureSyncProgressOutProto|null);
                iap_purchase_sku_out_proto_310000?: (POGOProtos.Rpc.IIapPurchaseSkuOutProto|null);
                iap_get_available_skus_and_balances_out_proto_310001?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesOutProto|null);
                iap_setin_game_currency_exchange_rate_out_proto_310002?: (POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateOutProto|null);
                iap_redeem_google_receipt_out_proto_310100?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptOutProto|null);
                iap_redeem_apple_receipt_out_proto_310101?: (POGOProtos.Rpc.IIapRedeemAppleReceiptOutProto|null);
                iap_redeem_desktop_receipt_out_proto_310102?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptOutProto|null);
                iap_redeem_samsung_receipt_out_proto_310103?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptOutProto|null);
                iap_get_available_subscriptions_response_proto_310200?: (POGOProtos.Rpc.IIapGetAvailableSubscriptionsResponseProto|null);
                iap_get_active_subscriptions_response_proto_310201?: (POGOProtos.Rpc.IIapGetActiveSubscriptionsResponseProto|null);
                get_reward_tiers_response_proto_310300?: (POGOProtos.Rpc.IGetRewardTiersResponseProto|null);
                iap_redeem_xsolla_receipt_response_proto_311100?: (POGOProtos.Rpc.IIapRedeemXsollaReceiptResponseProto|null);
                iap_get_user_response_proto_311101?: (POGOProtos.Rpc.IIapGetUserResponseProto|null);
                geofence_update_out_proto_360000?: (POGOProtos.Rpc.IGeofenceUpdateOutProto|null);
                location_ping_out_proto_360001?: (POGOProtos.Rpc.ILocationPingOutProto|null);
                update_bulk_player_location_response_proto_360002?: (POGOProtos.Rpc.IUpdateBulkPlayerLocationResponseProto|null);
                update_breadcrumb_history_response_proto_361000?: (POGOProtos.Rpc.IUpdateBreadcrumbHistoryResponseProto|null);
                refresh_proximity_tokensresponse_proto_362000?: (POGOProtos.Rpc.IRefreshProximityTokensResponseProto|null);
                report_proximity_contactsresponse_proto_362001?: (POGOProtos.Rpc.IReportProximityContactsResponseProto|null);
                internal_add_login_action_out_proto_600000?: (POGOProtos.Rpc.IInternalAddLoginActionOutProto|null);
                internal_remove_login_action_out_proto_600001?: (POGOProtos.Rpc.IInternalRemoveLoginActionOutProto|null);
                internal_list_login_action_out_proto_600002?: (POGOProtos.Rpc.IInternalListLoginActionOutProto|null);
                internal_replace_login_action_out_proto_600003?: (POGOProtos.Rpc.IInternalReplaceLoginActionOutProto|null);
                internal_set_birthday_response_proto_600004?: (POGOProtos.Rpc.IInternalSetBirthdayResponseProto|null);
                internal_gar_proxy_response_proto_600005?: (POGOProtos.Rpc.IInternalGarProxyResponseProto|null);
                internal_link_to_account_login_response_proto_600006?: (POGOProtos.Rpc.IInternalLinkToAccountLoginResponseProto|null);
                titan_submit_new_poi_out_proto_620000?: (POGOProtos.Rpc.ITitanSubmitNewPoiOutProto|null);
                titan_get_available_submissions_out_proto_620001?: (POGOProtos.Rpc.ITitanGetAvailableSubmissionsOutProto|null);
                titan_get_player_submission_validation_settings_out_proto_620003?: (POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsOutProto|null);
                titan_generate_gmap_signed_url_out_proto_620300?: (POGOProtos.Rpc.ITitanGenerateGmapSignedUrlOutProto|null);
                titan_get_gmap_settings_out_proto_620301?: (POGOProtos.Rpc.ITitanGetGmapSettingsOutProto|null);
                titan_get_grapeshot_upload_url_out_proto_620401?: (POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlOutProto|null);
                titan_async_file_upload_complete_out_proto_620402?: (POGOProtos.Rpc.ITitanAsyncFileUploadCompleteOutProto|null);
                titan_get_a_r_mapping_settings_out_proto_620403?: (POGOProtos.Rpc.ITitanGetARMappingSettingsOutProto|null);
                titan_get_images_for_poi_out_proto_620500?: (POGOProtos.Rpc.ITitanGetImagesForPoiOutProto|null);
                titan_submit_player_image_vote_for_poi_out_proto_620501?: (POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiOutProto|null);
                titan_get_image_gallery_settings_out_proto_620502?: (POGOProtos.Rpc.ITitanGetImageGallerySettingsOutProto|null);
                get_maptiles_settings_response_620600?: (POGOProtos.Rpc.IGetMaptilesSettingsResponse|null);
                titan_get_pois_in_radius_out_proto_620601?: (POGOProtos.Rpc.ITitanGetPoisInRadiusOutProto|null);
                fitness_update_out_proto_640000?: (POGOProtos.Rpc.IFitnessUpdateOutProto|null);
                get_fitness_report_out_proto_640001?: (POGOProtos.Rpc.IGetFitnessReportOutProto|null);
                get_adventure_sync_settings_response_proto_640002?: (POGOProtos.Rpc.IGetAdventureSyncSettingsResponseProto|null);
                update_adventure_sync_settings_response_proto_640003?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsResponseProto|null);
                update_adventure_sync_fitness_response_proto_640004?: (POGOProtos.Rpc.IUpdateAdventureSyncFitnessResponseProto|null);
                get_adventure_sync_fitness_report_response_proto_640005?: (POGOProtos.Rpc.IGetAdventureSyncFitnessReportResponseProto|null);
            }

            class AllResponsesProto implements IAllResponsesProto {
                constructor(properties?: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IAllResponsesProto);
                public get_player_out_proto_2?: (POGOProtos.Rpc.IGetPlayerOutProto|null);
                public get_holoholo_inventory_out_proto_4?: (POGOProtos.Rpc.IGetHoloholoInventoryOutProto|null);
                public download_settings_response_proto_5?: (POGOProtos.Rpc.IDownloadSettingsResponseProto|null);
                public getgame_master_client_templates_out_proto_6?: (POGOProtos.Rpc.IGetGameMasterClientTemplatesOutProto|null);
                public get_remote_config_versions_out_proto_7?: (POGOProtos.Rpc.IGetRemoteConfigVersionsOutProto|null);
                public register_background_deviceresponse_proto_8?: (POGOProtos.Rpc.IRegisterBackgroundDeviceResponseProto|null);
                public get_player_day_out_proto_9?: (POGOProtos.Rpc.IGetPlayerDayOutProto|null);
                public acknowledge_punishment_out_proto_10?: (POGOProtos.Rpc.IAcknowledgePunishmentOutProto|null);
                public get_server_time_out_proto_11?: (POGOProtos.Rpc.IGetServerTimeOutProto|null);
                public get_local_time_out_proto_12?: (POGOProtos.Rpc.IGetLocalTimeOutProto|null);
                public set_playerstatus_out_proto_20?: (POGOProtos.Rpc.ISetPlayerStatusOutProto|null);
                public getgame_config_versions_out_proto_21?: (POGOProtos.Rpc.IGetGameConfigVersionsOutProto|null);
                public get_playergps_bookmarks_out_proto_22?: (POGOProtos.Rpc.IGetPlayerGpsBookmarksOutProto|null);
                public update_player_gps_bookmarks_out_proto_23?: (POGOProtos.Rpc.IUpdatePlayerGpsBookmarksOutProto|null);
                public fort_search_out_proto_101?: (POGOProtos.Rpc.IFortSearchOutProto|null);
                public encounter_out_proto_102?: (POGOProtos.Rpc.IEncounterOutProto|null);
                public catch_pokemon_out_proto_103?: (POGOProtos.Rpc.ICatchPokemonOutProto|null);
                public fort_details_out_proto_104?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
                public get_map_objects_out_proto_106?: (POGOProtos.Rpc.IGetMapObjectsOutProto|null);
                public fort_deploy_out_proto_110?: (POGOProtos.Rpc.IFortDeployOutProto|null);
                public fort_recall_out_proto_111?: (POGOProtos.Rpc.IFortRecallOutProto|null);
                public release_pokemon_out_proto_112?: (POGOProtos.Rpc.IReleasePokemonOutProto|null);
                public use_item_potion_out_proto_113?: (POGOProtos.Rpc.IUseItemPotionOutProto|null);
                public use_item_capture_out_proto_114?: (POGOProtos.Rpc.IUseItemCaptureOutProto|null);
                public use_item_revive_out_proto_116?: (POGOProtos.Rpc.IUseItemReviveOutProto|null);
                public playerprofile_outproto_121?: (POGOProtos.Rpc.IPlayerProfileOutProto|null);
                public evolve_pokemon_out_proto_125?: (POGOProtos.Rpc.IEvolvePokemonOutProto|null);
                public get_hatched_eggs_out_proto_126?: (POGOProtos.Rpc.IGetHatchedEggsOutProto|null);
                public encounter_tutorial_complete_out_proto_127?: (POGOProtos.Rpc.IEncounterTutorialCompleteOutProto|null);
                public level_up_rewards_out_proto_128?: (POGOProtos.Rpc.ILevelUpRewardsOutProto|null);
                public check_awarded_badges_out_proto_129?: (POGOProtos.Rpc.ICheckAwardedBadgesOutProto|null);
                public recycle_item_out_proto_137?: (POGOProtos.Rpc.IRecycleItemOutProto|null);
                public collect_daily_bonus_out_proto_138?: (POGOProtos.Rpc.ICollectDailyBonusOutProto|null);
                public use_item_xp_boost_out_proto_139?: (POGOProtos.Rpc.IUseItemXpBoostOutProto|null);
                public use_item_egg_incubator_out_proto_140?: (POGOProtos.Rpc.IUseItemEggIncubatorOutProto|null);
                public use_incense_action_out_proto_141?: (POGOProtos.Rpc.IUseIncenseActionOutProto|null);
                public get_incense_pokemon_out_proto_142?: (POGOProtos.Rpc.IGetIncensePokemonOutProto|null);
                public incense_encounter_out_proto_143?: (POGOProtos.Rpc.IIncenseEncounterOutProto|null);
                public add_fort_modifier_out_proto_144?: (POGOProtos.Rpc.IAddFortModifierOutProto|null);
                public disk_encounter_out_proto_145?: (POGOProtos.Rpc.IDiskEncounterOutProto|null);
                public upgrade_pokemon_out_proto_147?: (POGOProtos.Rpc.IUpgradePokemonOutProto|null);
                public set_favorite_pokemon_out_proto_148?: (POGOProtos.Rpc.ISetFavoritePokemonOutProto|null);
                public nickname_pokemon_out_proto_149?: (POGOProtos.Rpc.INicknamePokemonOutProto|null);
                public set_contactsettings_out_proto_151?: (POGOProtos.Rpc.ISetContactSettingsOutProto|null);
                public set_buddy_pokemon_out_proto_152?: (POGOProtos.Rpc.ISetBuddyPokemonOutProto|null);
                public get_buddy_walked_out_proto_153?: (POGOProtos.Rpc.IGetBuddyWalkedOutProto|null);
                public use_item_encounter_out_proto_154?: (POGOProtos.Rpc.IUseItemEncounterOutProto|null);
                public gym_deploy_out_proto_155?: (POGOProtos.Rpc.IGymDeployOutProto|null);
                public gymget_info_out_proto_156?: (POGOProtos.Rpc.IGymGetInfoOutProto|null);
                public gym_start_session_out_proto_157?: (POGOProtos.Rpc.IGymStartSessionOutProto|null);
                public gym_battle_attack_out_proto_158?: (POGOProtos.Rpc.IGymBattleAttackOutProto|null);
                public join_lobby_out_proto_159?: (POGOProtos.Rpc.IJoinLobbyOutProto|null);
                public leavelobby_out_proto_160?: (POGOProtos.Rpc.ILeaveLobbyOutProto|null);
                public set_lobby_visibility_out_proto_161?: (POGOProtos.Rpc.ISetLobbyVisibilityOutProto|null);
                public set_lobby_pokemon_out_proto_162?: (POGOProtos.Rpc.ISetLobbyPokemonOutProto|null);
                public get_raid_details_out_proto_163?: (POGOProtos.Rpc.IGetRaidDetailsOutProto|null);
                public gym_feed_pokemon_out_proto_164?: (POGOProtos.Rpc.IGymFeedPokemonOutProto|null);
                public start_raid_battle_out_proto_165?: (POGOProtos.Rpc.IStartRaidBattleOutProto|null);
                public attack_raid_battle_out_proto_166?: (POGOProtos.Rpc.IAttackRaidBattleOutProto|null);
                public use_item_stardust_boost_out_proto_168?: (POGOProtos.Rpc.IUseItemStardustBoostOutProto|null);
                public reassign_player_out_proto_169?: (POGOProtos.Rpc.IReassignPlayerOutProto|null);
                public convertcandy_to_xlcandy_out_proto_171?: (POGOProtos.Rpc.IConvertCandyToXlCandyOutProto|null);
                public is_sku_available_out_proto_172?: (POGOProtos.Rpc.IIsSkuAvailableOutProto|null);
                public use_item_bulk_heal_out_proto_173?: (POGOProtos.Rpc.IUseItemBulkHealOutProto|null);
                public use_item_battle_boost_out_proto_174?: (POGOProtos.Rpc.IUseItemBattleBoostOutProto|null);
                public use_item_lucky_friend_applicator_out_proto_175?: (POGOProtos.Rpc.IUseItemLuckyFriendApplicatorOutProto|null);
                public use_item_stat_increase_out_proto_176?: (POGOProtos.Rpc.IUseItemStatIncreaseOutProto|null);
                public asset_digest_out_proto_300?: (POGOProtos.Rpc.IAssetDigestOutProto|null);
                public download_url_out_proto_301?: (POGOProtos.Rpc.IDownloadUrlOutProto|null);
                public asset_version_out_proto_302?: (POGOProtos.Rpc.IAssetVersionOutProto|null);
                public codename_result_proto_403?: (POGOProtos.Rpc.ICodenameResultProto|null);
                public set_avatar_out_proto_404?: (POGOProtos.Rpc.ISetAvatarOutProto|null);
                public set_player_team_out_proto_405?: (POGOProtos.Rpc.ISetPlayerTeamOutProto|null);
                public mark_tutorial_complete_out_proto_406?: (POGOProtos.Rpc.IMarkTutorialCompleteOutProto|null);
                public set_neutral_avatar_out_proto_408?: (POGOProtos.Rpc.ISetNeutralAvatarOutProto|null);
                public list_avatar_store_items_out_proto_409?: (POGOProtos.Rpc.IListAvatarStoreItemsOutProto|null);
                public list_avatar_appearance_items_out_proto_410?: (POGOProtos.Rpc.IListAvatarAppearanceItemsOutProto|null);
                public neutral_avatar_badge_reward_out_proto_450?: (POGOProtos.Rpc.INeutralAvatarBadgeRewardOutProto|null);
                public checkchallenge_out_proto_600?: (POGOProtos.Rpc.ICheckChallengeOutProto|null);
                public verify_challenge_out_proto_601?: (POGOProtos.Rpc.IVerifyChallengeOutProto|null);
                public echo_out_proto_666?: (POGOProtos.Rpc.IEchoOutProto|null);
                public register_sfidaresponse_800?: (POGOProtos.Rpc.IRegisterSfidaResponse|null);
                public sfida_certification_response_802?: (POGOProtos.Rpc.ISfidaCertificationResponse|null);
                public sfida_update_response_803?: (POGOProtos.Rpc.ISfidaUpdateResponse|null);
                public sfida_dowser_response_805?: (POGOProtos.Rpc.ISfidaDowserResponse|null);
                public sfida_capture_response_806?: (POGOProtos.Rpc.ISfidaCaptureResponse|null);
                public list_avatar_customizations_out_proto_807?: (POGOProtos.Rpc.IListAvatarCustomizationsOutProto|null);
                public set_avatar_item_as_viewed_out_proto_808?: (POGOProtos.Rpc.ISetAvatarItemAsViewedOutProto|null);
                public get_inbox_out_proto_809?: (POGOProtos.Rpc.IGetInboxOutProto|null);
                public list_gym_badges_out_proto_811?: (POGOProtos.Rpc.IListGymBadgesOutProto|null);
                public getgym_badge_details_out_proto_812?: (POGOProtos.Rpc.IGetGymBadgeDetailsOutProto|null);
                public use_item_move_reroll_out_proto_813?: (POGOProtos.Rpc.IUseItemMoveRerollOutProto|null);
                public use_item_rare_candy_out_proto_814?: (POGOProtos.Rpc.IUseItemRareCandyOutProto|null);
                public award_free_raid_ticket_out_proto_815?: (POGOProtos.Rpc.IAwardFreeRaidTicketOutProto|null);
                public fetch_all_news_out_proto_816?: (POGOProtos.Rpc.IFetchAllNewsOutProto|null);
                public mark_read_news_article_out_proto_817?: (POGOProtos.Rpc.IMarkReadNewsArticleOutProto|null);
                public internal_get_player_settings_out_proto_818?: (POGOProtos.Rpc.IInternalGetPlayerSettingsOutProto|null);
                public beluga_transaction_start_out_proto_819?: (POGOProtos.Rpc.IBelugaTransactionStartOutProto|null);
                public beluga_transaction_complete_out_proto_820?: (POGOProtos.Rpc.IBelugaTransactionCompleteOutProto|null);
                public sfida_associate_response_822?: (POGOProtos.Rpc.ISfidaAssociateResponse|null);
                public sfida_check_pairing_response_823?: (POGOProtos.Rpc.ISfidaCheckPairingResponse|null);
                public sfida_disassociate_response_824?: (POGOProtos.Rpc.ISfidaDisassociateResponse|null);
                public waina_get_rewards_response_825?: (POGOProtos.Rpc.IWainaGetRewardsResponse|null);
                public waina_submit_sleep_data_response_826?: (POGOProtos.Rpc.IWainaSubmitSleepDataResponse|null);
                public saturdaystart_out_proto_827?: (POGOProtos.Rpc.ISaturdayStartOutProto|null);
                public saturday_complete_out_proto_828?: (POGOProtos.Rpc.ISaturdayCompleteOutProto|null);
                public lift_user_age_gate_confirmation_out_proto_830?: (POGOProtos.Rpc.ILiftUserAgeGateConfirmationOutProto|null);
                public get_new_quests_out_proto_900?: (POGOProtos.Rpc.IGetNewQuestsOutProto|null);
                public get_quest_details_out_proto_901?: (POGOProtos.Rpc.IGetQuestDetailsOutProto|null);
                public complete_quest_out_proto_902?: (POGOProtos.Rpc.ICompleteQuestOutProto|null);
                public remove_quest_out_proto_903?: (POGOProtos.Rpc.IRemoveQuestOutProto|null);
                public quest_encounter_out_proto_904?: (POGOProtos.Rpc.IQuestEncounterOutProto|null);
                public complete_quest_stampcard_out_proto_905?: (POGOProtos.Rpc.ICompleteQuestStampCardOutProto|null);
                public progress_quest_outproto_906?: (POGOProtos.Rpc.IProgressQuestOutProto|null);
                public read_quest_dialog_out_proto_908?: (POGOProtos.Rpc.IReadQuestDialogOutProto|null);
                public send_gift_out_proto_950?: (POGOProtos.Rpc.ISendGiftOutProto|null);
                public open_giftout_proto_951?: (POGOProtos.Rpc.IOpenGiftOutProto|null);
                public getgift_box_details_out_proto_952?: (POGOProtos.Rpc.IGetGiftBoxDetailsOutProto|null);
                public delete_gift_out_proto_953?: (POGOProtos.Rpc.IDeleteGiftOutProto|null);
                public save_playersnapshot_out_proto_954?: (POGOProtos.Rpc.ISavePlayerSnapshotOutProto|null);
                public get_friendship_rewards_out_proto_955?: (POGOProtos.Rpc.IGetFriendshipRewardsOutProto|null);
                public check_send_gift_out_proto_956?: (POGOProtos.Rpc.ICheckSendGiftOutProto|null);
                public set_friend_nickname_out_proto_957?: (POGOProtos.Rpc.ISetFriendNicknameOutProto|null);
                public delete_gift_from_inventory_out_proto_958?: (POGOProtos.Rpc.IDeleteGiftFromInventoryOutProto|null);
                public savesocial_playersettings_out_proto_959?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsOutProto|null);
                public open_tradingout_proto_970?: (POGOProtos.Rpc.IOpenTradingOutProto|null);
                public update_trading_out_proto_971?: (POGOProtos.Rpc.IUpdateTradingOutProto|null);
                public confirm_trading_out_proto_972?: (POGOProtos.Rpc.IConfirmTradingOutProto|null);
                public cancel_trading_out_proto_973?: (POGOProtos.Rpc.ICancelTradingOutProto|null);
                public get_trading_out_proto_974?: (POGOProtos.Rpc.IGetTradingOutProto|null);
                public get_fitness_rewards_out_proto_980?: (POGOProtos.Rpc.IGetFitnessRewardsOutProto|null);
                public get_combat_player_profile_out_proto_990?: (POGOProtos.Rpc.IGetCombatPlayerProfileOutProto|null);
                public generate_combat_challenge_id_out_proto_991?: (POGOProtos.Rpc.IGenerateCombatChallengeIdOutProto|null);
                public createcombatchallenge_out_proto_992?: (POGOProtos.Rpc.ICreateCombatChallengeOutProto|null);
                public open_combat_challengeout_proto_993?: (POGOProtos.Rpc.IOpenCombatChallengeOutProto|null);
                public get_combat_challenge_out_proto_994?: (POGOProtos.Rpc.IGetCombatChallengeOutProto|null);
                public accept_combat_challenge_out_proto_995?: (POGOProtos.Rpc.IAcceptCombatChallengeOutProto|null);
                public decline_combat_challenge_out_proto_996?: (POGOProtos.Rpc.IDeclineCombatChallengeOutProto|null);
                public cancelcombatchallenge_out_proto_997?: (POGOProtos.Rpc.ICancelCombatChallengeOutProto|null);
                public submit_combat_challenge_pokemons_out_proto_998?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsOutProto|null);
                public save_combat_player_preferences_out_proto_999?: (POGOProtos.Rpc.ISaveCombatPlayerPreferencesOutProto|null);
                public open_combat_sessionout_proto_1000?: (POGOProtos.Rpc.IOpenCombatSessionOutProto|null);
                public update_combat_out_proto_1001?: (POGOProtos.Rpc.IUpdateCombatOutProto|null);
                public quit_combat_out_proto_1002?: (POGOProtos.Rpc.IQuitCombatOutProto|null);
                public get_combat_results_out_proto_1003?: (POGOProtos.Rpc.IGetCombatResultsOutProto|null);
                public unlock_pokemon_move_out_proto_1004?: (POGOProtos.Rpc.IUnlockPokemonMoveOutProto|null);
                public get_npc_combat_rewards_out_proto_1005?: (POGOProtos.Rpc.IGetNpcCombatRewardsOutProto|null);
                public combat_friend_request_out_proto_1006?: (POGOProtos.Rpc.ICombatFriendRequestOutProto|null);
                public open_npc_combat_sessionout_proto_1007?: (POGOProtos.Rpc.IOpenNpcCombatSessionOutProto|null);
                public send_probe_out_proto_1020?: (POGOProtos.Rpc.ISendProbeOutProto|null);
                public check_photobomb_out_proto_1101?: (POGOProtos.Rpc.ICheckPhotobombOutProto|null);
                public confirm_photobomb_out_proto_1102?: (POGOProtos.Rpc.IConfirmPhotobombOutProto|null);
                public get_photobomb_out_proto_1103?: (POGOProtos.Rpc.IGetPhotobombOutProto|null);
                public encounter_photobomb_out_proto_1104?: (POGOProtos.Rpc.IEncounterPhotobombOutProto|null);
                public getgmap_settings_out_proto_1105?: (POGOProtos.Rpc.IGetGmapSettingsOutProto|null);
                public change_team_out_proto_1106?: (POGOProtos.Rpc.IChangeTeamOutProto|null);
                public get_web_token_out_proto_1107?: (POGOProtos.Rpc.IGetWebTokenOutProto|null);
                public complete_snapshot_session_out_proto_1110?: (POGOProtos.Rpc.ICompleteSnapshotSessionOutProto|null);
                public complete_wild_snapshot_session_out_proto_1111?: (POGOProtos.Rpc.ICompleteWildSnapshotSessionOutProto|null);
                public start_incident_out_proto_1200?: (POGOProtos.Rpc.IStartIncidentOutProto|null);
                public complete_invasion_dialogue_out_proto_1201?: (POGOProtos.Rpc.ICompleteInvasionDialogueOutProto|null);
                public open_invasion_combat_sessionout_proto_1202?: (POGOProtos.Rpc.IOpenInvasionCombatSessionOutProto|null);
                public update_invasion_battle_out_proto_1203?: (POGOProtos.Rpc.IUpdateInvasionBattleOutProto|null);
                public invasion_encounter_out_proto_1204?: (POGOProtos.Rpc.IInvasionEncounterOutProto|null);
                public purifypokemon_outproto_1205?: (POGOProtos.Rpc.IPurifyPokemonOutProto|null);
                public get_rocket_balloon_out_proto_1206?: (POGOProtos.Rpc.IGetRocketBalloonOutProto|null);
                public vs_seeker_start_matchmaking_out_proto_1300?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingOutProto|null);
                public cancel_matchmaking_out_proto_1301?: (POGOProtos.Rpc.ICancelMatchmakingOutProto|null);
                public get_matchmaking_status_out_proto_1302?: (POGOProtos.Rpc.IGetMatchmakingStatusOutProto|null);
                public complete_vs_seeker_and_restartcharging_out_proto_1303?: (POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingOutProto|null);
                public get_vs_seeker_status_out_proto_1304?: (POGOProtos.Rpc.IGetVsSeekerStatusOutProto|null);
                public completecompetitive_season_out_proto_1305?: (POGOProtos.Rpc.ICompleteCompetitiveSeasonOutProto|null);
                public claim_vs_seeker_rewards_out_proto_1306?: (POGOProtos.Rpc.IClaimVsSeekerRewardsOutProto|null);
                public vs_seeker_reward_encounter_out_proto_1307?: (POGOProtos.Rpc.IVsSeekerRewardEncounterOutProto|null);
                public activate_vs_seeker_out_proto_1308?: (POGOProtos.Rpc.IActivateVsSeekerOutProto|null);
                public buddy_map_out_proto_1350?: (POGOProtos.Rpc.IBuddyMapOutProto|null);
                public buddy_stats_out_proto_1351?: (POGOProtos.Rpc.IBuddyStatsOutProto|null);
                public buddy_feeding_out_proto_1352?: (POGOProtos.Rpc.IBuddyFeedingOutProto|null);
                public open_buddy_giftout_proto_1353?: (POGOProtos.Rpc.IOpenBuddyGiftOutProto|null);
                public buddy_petting_out_proto_1354?: (POGOProtos.Rpc.IBuddyPettingOutProto|null);
                public get_buddy_history_out_proto_1355?: (POGOProtos.Rpc.IGetBuddyHistoryOutProto|null);
                public update_route_draft_out_proto_1400?: (POGOProtos.Rpc.IUpdateRouteDraftOutProto|null);
                public get_map_forts_out_proto_1401?: (POGOProtos.Rpc.IGetMapFortsOutProto|null);
                public submit_route_draft_out_proto_1402?: (POGOProtos.Rpc.ISubmitRouteDraftOutProto|null);
                public get_published_routes_out_proto_1403?: (POGOProtos.Rpc.IGetPublishedRoutesOutProto|null);
                public start_route_out_proto_1404?: (POGOProtos.Rpc.IStartRouteOutProto|null);
                public get_routes_out_proto_1405?: (POGOProtos.Rpc.IGetRoutesOutProto|null);
                public progress_route_outproto_1406?: (POGOProtos.Rpc.IProgressRouteOutProto|null);
                public process_tappable_outproto_1408?: (POGOProtos.Rpc.IProcessTappableOutProto|null);
                public list_route_badges_out_proto_1409?: (POGOProtos.Rpc.IListRouteBadgesOutProto|null);
                public cancel_route_out_proto_1410?: (POGOProtos.Rpc.ICancelRouteOutProto|null);
                public list_route_stamps_out_proto_1411?: (POGOProtos.Rpc.IListRouteStampsOutProto|null);
                public rateroute_out_proto_1412?: (POGOProtos.Rpc.IRateRouteOutProto|null);
                public create_route_draft_out_proto_1413?: (POGOProtos.Rpc.ICreateRouteDraftOutProto|null);
                public delete_routedraft_out_proto_1414?: (POGOProtos.Rpc.IDeleteRouteDraftOutProto|null);
                public reportroute_out_proto_1415?: (POGOProtos.Rpc.IReportRouteOutProto|null);
                public process_tappable_outproto_1416?: (POGOProtos.Rpc.IProcessTappableOutProto|null);
                public attracted_pokemon_encounter_out_proto_1417?: (POGOProtos.Rpc.IAttractedPokemonEncounterOutProto|null);
                public can_report_route_out_proto_1418?: (POGOProtos.Rpc.ICanReportRouteOutProto|null);
                public route_update_seen_out_proto_1420?: (POGOProtos.Rpc.IRouteUpdateSeenOutProto|null);
                public recallroute_draft_out_proto_1421?: (POGOProtos.Rpc.IRecallRouteDraftOutProto|null);
                public route_nearby_notif_shown_out_proto_1422?: (POGOProtos.Rpc.IRouteNearbyNotifShownOutProto|null);
                public npc_route_gift_out_proto_1423?: (POGOProtos.Rpc.INpcRouteGiftOutProto|null);
                public get_route_creations_out_proto_1424?: (POGOProtos.Rpc.IGetRouteCreationsOutProto|null);
                public appeal_route_out_proto_1425?: (POGOProtos.Rpc.IAppealRouteOutProto|null);
                public get_route_draft_out_proto_1426?: (POGOProtos.Rpc.IGetRouteDraftOutProto|null);
                public favorite_route_out_proto_1427?: (POGOProtos.Rpc.IFavoriteRouteOutProto|null);
                public create_route_shortcode_out_proto_1428?: (POGOProtos.Rpc.ICreateRouteShortcodeOutProto|null);
                public get_route_by_short_code_out_proto_1429?: (POGOProtos.Rpc.IGetRouteByShortCodeOutProto|null);
                public create_buddy_multiplayer_session_out_proto_1456?: (POGOProtos.Rpc.ICreateBuddyMultiplayerSessionOutProto|null);
                public join_buddy_multiplayer_session_out_proto_1457?: (POGOProtos.Rpc.IJoinBuddyMultiplayerSessionOutProto|null);
                public leave_buddy_multiplayer_session_out_proto_1458?: (POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionOutProto|null);
                public mega_evolve_pokemon_out_proto_1502?: (POGOProtos.Rpc.IMegaEvolvePokemonOutProto|null);
                public remote_gift_pingresponse_proto_1503?: (POGOProtos.Rpc.IRemoteGiftPingResponseProto|null);
                public send_raid_invitation_out_proto_1504?: (POGOProtos.Rpc.ISendRaidInvitationOutProto|null);
                public send_bread_battle_invitation_out_proto_1505?: (POGOProtos.Rpc.ISendBreadBattleInvitationOutProto|null);
                public get_daily_encounter_out_proto_1601?: (POGOProtos.Rpc.IGetDailyEncounterOutProto|null);
                public daily_encounter_out_proto_1602?: (POGOProtos.Rpc.IDailyEncounterOutProto|null);
                public open_sponsored_giftout_proto_1650?: (POGOProtos.Rpc.IOpenSponsoredGiftOutProto|null);
                public report_ad_interactionresponse_1651?: (POGOProtos.Rpc.IReportAdInteractionResponse|null);
                public save_player_preferences_out_proto_1652?: (POGOProtos.Rpc.ISavePlayerPreferencesOutProto|null);
                public profanity_check_outproto_1653?: (POGOProtos.Rpc.IProfanityCheckOutProto|null);
                public get_timedgroup_challenge_out_proto_1700?: (POGOProtos.Rpc.IGetTimedGroupChallengeOutProto|null);
                public get_nintendo_account_out_proto_1710?: (POGOProtos.Rpc.IGetNintendoAccountOutProto|null);
                public unlink_nintendo_account_out_proto_1711?: (POGOProtos.Rpc.IUnlinkNintendoAccountOutProto|null);
                public get_nintendo_o_auth2_url_out_proto_1712?: (POGOProtos.Rpc.IGetNintendoOAuth2UrlOutProto|null);
                public transfer_pokemonto_pokemon_home_out_proto_1713?: (POGOProtos.Rpc.ITransferPokemonToPokemonHomeOutProto|null);
                public report_ad_feedbackresponse_1716?: (POGOProtos.Rpc.IReportAdFeedbackResponse|null);
                public create_pokemon_tag_out_proto_1717?: (POGOProtos.Rpc.ICreatePokemonTagOutProto|null);
                public delete_pokemon_tag_out_proto_1718?: (POGOProtos.Rpc.IDeletePokemonTagOutProto|null);
                public edit_pokemon_tag_out_proto_1719?: (POGOProtos.Rpc.IEditPokemonTagOutProto|null);
                public set_pokemon_tags_for_pokemon_out_proto_1720?: (POGOProtos.Rpc.ISetPokemonTagsForPokemonOutProto|null);
                public get_pokemon_tags_out_proto_1721?: (POGOProtos.Rpc.IGetPokemonTagsOutProto|null);
                public change_pokemon_form_out_proto_1722?: (POGOProtos.Rpc.IChangePokemonFormOutProto|null);
                public choose_global_ticketed_event_variant_out_proto_1723?: (POGOProtos.Rpc.IChooseGlobalTicketedEventVariantOutProto|null);
                public butterfly_collector_reward_encounter_proto_response_1724?: (POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoResponse|null);
                public get_additional_pokemon_details_out_proto_1725?: (POGOProtos.Rpc.IGetAdditionalPokemonDetailsOutProto|null);
                public create_route_pin_out_proto_1726?: (POGOProtos.Rpc.ICreateRoutePinOutProto|null);
                public like_route_pin_out_proto_1727?: (POGOProtos.Rpc.ILikeRoutePinOutProto|null);
                public view_route_pin_out_proto_1728?: (POGOProtos.Rpc.IViewRoutePinOutProto|null);
                public get_referral_code_out_proto_1800?: (POGOProtos.Rpc.IGetReferralCodeOutProto|null);
                public add_referrer_out_proto_1801?: (POGOProtos.Rpc.IAddReferrerOutProto|null);
                public send_friend_invite_via_referral_code_out_proto_1802?: (POGOProtos.Rpc.ISendFriendInviteViaReferralCodeOutProto|null);
                public get_milestones_out_proto_1803?: (POGOProtos.Rpc.IGetMilestonesOutProto|null);
                public markmilestone_as_viewed_out_proto_1804?: (POGOProtos.Rpc.IMarkMilestoneAsViewedOutProto|null);
                public get_milestones_preview_out_proto_1805?: (POGOProtos.Rpc.IGetMilestonesPreviewOutProto|null);
                public complete_milestone_out_proto_1806?: (POGOProtos.Rpc.ICompleteMilestoneOutProto|null);
                public getgeofenced_ad_out_proto_1820?: (POGOProtos.Rpc.IGetGeofencedAdOutProto|null);
                public power_uppokestop_encounter_outproto_1900?: (POGOProtos.Rpc.IPowerUpPokestopEncounterOutProto|null);
                public get_player_stamp_collections_out_proto_1901?: (POGOProtos.Rpc.IGetPlayerStampCollectionsOutProto|null);
                public savestamp_out_proto_1902?: (POGOProtos.Rpc.ISaveStampOutProto|null);
                public claim_stampcollection_reward_out_proto_1904?: (POGOProtos.Rpc.IClaimStampCollectionRewardOutProto|null);
                public change_stampcollection_player_data_out_proto_1905?: (POGOProtos.Rpc.IChangeStampCollectionPlayerDataOutProto|null);
                public check_stamp_giftability_out_proto_1906?: (POGOProtos.Rpc.ICheckStampGiftabilityOutProto|null);
                public delete_postcards_out_proto_1909?: (POGOProtos.Rpc.IDeletePostcardsOutProto|null);
                public create_postcard_out_proto_1910?: (POGOProtos.Rpc.ICreatePostcardOutProto|null);
                public update_postcard_out_proto_1911?: (POGOProtos.Rpc.IUpdatePostcardOutProto|null);
                public delete_postcard_out_proto_1912?: (POGOProtos.Rpc.IDeletePostcardOutProto|null);
                public get_memento_list_out_proto_1913?: (POGOProtos.Rpc.IGetMementoListOutProto|null);
                public upload_raid_client_log_out_proto_1914?: (POGOProtos.Rpc.IUploadRaidClientLogOutProto|null);
                public skip_enter_referral_code_out_proto_1915?: (POGOProtos.Rpc.ISkipEnterReferralCodeOutProto|null);
                public upload_combat_client_log_out_proto_1916?: (POGOProtos.Rpc.IUploadCombatClientLogOutProto|null);
                public combat_sync_server_offset_out_proto_1917?: (POGOProtos.Rpc.ICombatSyncServerOffsetOutProto|null);
                public check_gifting_eligibility_out_proto_2000?: (POGOProtos.Rpc.ICheckGiftingEligibilityOutProto|null);
                public redeem_ticket_gift_for_friend_out_proto_2001?: (POGOProtos.Rpc.IRedeemTicketGiftForFriendOutProto|null);
                public get_incense_recap_out_proto_2002?: (POGOProtos.Rpc.IGetIncenseRecapOutProto|null);
                public acknowledge_view_latest_incense_recap_out_proto_2003?: (POGOProtos.Rpc.IAcknowledgeViewLatestIncenseRecapOutProto|null);
                public boot_raid_out_proto_2004?: (POGOProtos.Rpc.IBootRaidOutProto|null);
                public get_pokestop_encounter_out_proto_2005?: (POGOProtos.Rpc.IGetPokestopEncounterOutProto|null);
                public encounter_pokestopencounter_out_proto_2006?: (POGOProtos.Rpc.IEncounterPokestopEncounterOutProto|null);
                public player_spawnablepokemon_outproto_2007?: (POGOProtos.Rpc.IPlayerSpawnablePokemonOutProto|null);
                public get_quest_ui_out_proto_2008?: (POGOProtos.Rpc.IGetQuestUiOutProto|null);
                public get_eligible_combat_leagues_out_proto_2009?: (POGOProtos.Rpc.IGetEligibleCombatLeaguesOutProto|null);
                public send_friend_request_via_player_id_out_proto_2010?: (POGOProtos.Rpc.ISendFriendRequestViaPlayerIdOutProto|null);
                public get_raid_lobby_counter_out_proto_2011?: (POGOProtos.Rpc.IGetRaidLobbyCounterOutProto|null);
                public use_non_combat_move_response_proto_2014?: (POGOProtos.Rpc.IUseNonCombatMoveResponseProto|null);
                public check_pokemon_size_leaderboard_eligibility_out_proto_2100?: (POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityOutProto|null);
                public update_pokemon_size_leaderboard_entry_out_proto_2101?: (POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryOutProto|null);
                public transfer_pokemon_size_leaderboard_entry_out_proto_2102?: (POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryOutProto|null);
                public remove_pokemon_size_leaderboard_entry_out_proto_2103?: (POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryOutProto|null);
                public get_pokemon_size_leaderboard_entry_out_proto_2104?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryOutProto|null);
                public get_contest_data_out_proto_2105?: (POGOProtos.Rpc.IGetContestDataOutProto|null);
                public get_contests_unclaimed_rewards_out_proto_2106?: (POGOProtos.Rpc.IGetContestsUnclaimedRewardsOutProto|null);
                public claimcontests_rewards_out_proto_2107?: (POGOProtos.Rpc.IClaimContestsRewardsOutProto|null);
                public get_entered_contest_out_proto_2108?: (POGOProtos.Rpc.IGetEnteredContestOutProto|null);
                public get_pokemon_size_leaderboard_friend_entry_out_proto_2109?: (POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryOutProto|null);
                public checkcontest_eligibility_out_proto_2150?: (POGOProtos.Rpc.ICheckContestEligibilityOutProto|null);
                public update_contest_entry_out_proto_2151?: (POGOProtos.Rpc.IUpdateContestEntryOutProto|null);
                public transfer_contest_entry_out_proto_2152?: (POGOProtos.Rpc.ITransferContestEntryOutProto|null);
                public get_contest_friend_entry_out_proto_2153?: (POGOProtos.Rpc.IGetContestFriendEntryOutProto|null);
                public get_contest_entry_out_proto_2154?: (POGOProtos.Rpc.IGetContestEntryOutProto|null);
                public create_party_out_proto_2300?: (POGOProtos.Rpc.ICreatePartyOutProto|null);
                public join_party_out_proto_2301?: (POGOProtos.Rpc.IJoinPartyOutProto|null);
                public start_party_out_proto_2302?: (POGOProtos.Rpc.IStartPartyOutProto|null);
                public leave_party_out_proto_2303?: (POGOProtos.Rpc.ILeavePartyOutProto|null);
                public get_party_out_proto_2304?: (POGOProtos.Rpc.IGetPartyOutProto|null);
                public party_update_location_outproto_2305?: (POGOProtos.Rpc.IPartyUpdateLocationOutProto|null);
                public party_send_dark_launch_log_outproto_2306?: (POGOProtos.Rpc.IPartySendDarkLaunchLogOutProto|null);
                public start_party_quest_out_proto_2308?: (POGOProtos.Rpc.IStartPartyQuestOutProto|null);
                public complete_party_quest_out_proto_2309?: (POGOProtos.Rpc.ICompletePartyQuestOutProto|null);
                public get_bonus_attracted_pokemon_out_proto_2350?: (POGOProtos.Rpc.IGetBonusAttractedPokemonOutProto|null);
                public get_bonuses_out_proto_2352?: (POGOProtos.Rpc.IGetBonusesOutProto|null);
                public badge_reward_encounter_response_proto_2360?: (POGOProtos.Rpc.IBadgeRewardEncounterResponseProto|null);
                public npc_update_state_out_proto_2400?: (POGOProtos.Rpc.INpcUpdateStateOutProto|null);
                public npc_send_gift_out_proto_2401?: (POGOProtos.Rpc.INpcSendGiftOutProto|null);
                public npc_open_gift_out_proto_2402?: (POGOProtos.Rpc.INpcOpenGiftOutProto|null);
                public join_bread_lobby_out_proto_2450?: (POGOProtos.Rpc.IJoinBreadLobbyOutProto|null);
                public prepare_bread_lobby_outproto_2453?: (POGOProtos.Rpc.IPrepareBreadLobbyOutProto|null);
                public leave_breadlobby_out_proto_2455?: (POGOProtos.Rpc.ILeaveBreadLobbyOutProto|null);
                public start_bread_battle_out_proto_2456?: (POGOProtos.Rpc.IStartBreadBattleOutProto|null);
                public get_bread_lobby_details_out_proto_2457?: (POGOProtos.Rpc.IGetBreadLobbyDetailsOutProto|null);
                public start_mp_walk_quest_out_proto_2458?: (POGOProtos.Rpc.IStartMpWalkQuestOutProto|null);
                public enhance_bread_move_out_proto_2459?: (POGOProtos.Rpc.IEnhanceBreadMoveOutProto|null);
                public station_pokemon_out_proto_2460?: (POGOProtos.Rpc.IStationPokemonOutProto|null);
                public loot_station_out_proto_2461?: (POGOProtos.Rpc.ILootStationOutProto|null);
                public get_stationed_pokemon_details_out_proto_2462?: (POGOProtos.Rpc.IGetStationedPokemonDetailsOutProto|null);
                public mark_save_for_later_out_proto_2463?: (POGOProtos.Rpc.IMarkSaveForLaterOutProto|null);
                public use_save_for_later_out_proto_2464?: (POGOProtos.Rpc.IUseSaveForLaterOutProto|null);
                public remove_save_for_later_out_proto_2465?: (POGOProtos.Rpc.IRemoveSaveForLaterOutProto|null);
                public get_save_for_later_entries_out_proto_2466?: (POGOProtos.Rpc.IGetSaveForLaterEntriesOutProto|null);
                public get_mp_summary_out_proto_2467?: (POGOProtos.Rpc.IGetMpSummaryOutProto|null);
                public use_item_mp_replenish_out_proto_2468?: (POGOProtos.Rpc.IUseItemMpReplenishOutProto|null);
                public report_station_out_proto_2470?: (POGOProtos.Rpc.IReportStationOutProto|null);
                public debug_resetdaily_mp_progress_out_proto_2471?: (POGOProtos.Rpc.IDebugResetDailyMpProgressOutProto|null);
                public release_stationed_pokemon_out_proto_2472?: (POGOProtos.Rpc.IReleaseStationedPokemonOutProto|null);
                public complete_bread_battle_out_proto_2473?: (POGOProtos.Rpc.ICompleteBreadBattleOutProto|null);
                public encounter_station_spawn_out_proto_2475?: (POGOProtos.Rpc.IEncounterStationSpawnOutProto|null);
                public get_num_station_assists_out_proto_2476?: (POGOProtos.Rpc.IGetNumStationAssistsOutProto|null);
                public get_vps_event_out_proto_3000?: (POGOProtos.Rpc.IGetVpsEventOutProto|null);
                public update_vps_event_out_proto_3001?: (POGOProtos.Rpc.IUpdateVpsEventOutProto|null);
                public add_ptc_loginaction_out_proto_3002?: (POGOProtos.Rpc.IAddPtcLoginActionOutProto|null);
                public claim_ptc_linking_reward_out_proto_3003?: (POGOProtos.Rpc.IClaimPtcLinkingRewardOutProto|null);
                public canclaim_ptc_reward_action_out_proto_3004?: (POGOProtos.Rpc.ICanClaimPtcRewardActionOutProto|null);
                public contribute_party_item_out_proto_3005?: (POGOProtos.Rpc.IContributePartyItemOutProto|null);
                public consume_party_items_out_proto_3006?: (POGOProtos.Rpc.IConsumePartyItemsOutProto|null);
                public remove_ptc_login_action_out_proto_3007?: (POGOProtos.Rpc.IRemovePtcLoginActionOutProto|null);
                public send_party_invitation_out_proto_3008?: (POGOProtos.Rpc.ISendPartyInvitationOutProto|null);
                public consume_stickers_out_proto_3009?: (POGOProtos.Rpc.IConsumeStickersOutProto|null);
                public complete_raid_battle_out_proto_3010?: (POGOProtos.Rpc.ICompleteRaidBattleOutProto|null);
                public sync_battle_inventory_out_proto_3011?: (POGOProtos.Rpc.ISyncBattleInventoryOutProto|null);
                public preview_contributeparty_item_outproto_3015?: (POGOProtos.Rpc.IPreviewContributePartyItemOutProto|null);
                public kick_other_player_from_party_out_proto_3016?: (POGOProtos.Rpc.IKickOtherPlayerFromPartyOutProto|null);
                public fuse_pokemon_response_proto_3017?: (POGOProtos.Rpc.IFusePokemonResponseProto|null);
                public unfuse_pokemon_response_proto_3018?: (POGOProtos.Rpc.IUnfusePokemonResponseProto|null);
                public get_iris_social_scene_out_proto_3019?: (POGOProtos.Rpc.IGetIrisSocialSceneOutProto|null);
                public update_iris_social_scene_out_proto_3020?: (POGOProtos.Rpc.IUpdateIrisSocialSceneOutProto|null);
                public get_change_pokemon_form_preview_response_proto_3021?: (POGOProtos.Rpc.IGetChangePokemonFormPreviewResponseProto|null);
                public get_unfuse_pokemon_preview_response_proto_3023?: (POGOProtos.Rpc.IGetUnfusePokemonPreviewResponseProto|null);
                public processplayer_inbox_outproto_3024?: (POGOProtos.Rpc.IProcessPlayerInboxOutProto|null);
                public get_survey_eligibility_out_proto_3025?: (POGOProtos.Rpc.IGetSurveyEligibilityOutProto|null);
                public update_survey_eligibility_out_proto_3026?: (POGOProtos.Rpc.IUpdateSurveyEligibilityOutProto|null);
                public smart_glassessyncsettings_response_proto_3027?: (POGOProtos.Rpc.ISmartGlassesSyncSettingsResponseProto|null);
                public complete_visit_page_quest_out_proto_3030?: (POGOProtos.Rpc.ICompleteVisitPageQuestOutProto|null);
                public get_event_rsvps_out_proto_3031?: (POGOProtos.Rpc.IGetEventRsvpsOutProto|null);
                public create_event_rsvp_out_proto_3032?: (POGOProtos.Rpc.ICreateEventRsvpOutProto|null);
                public cancel_event_rsvp_out_proto_3033?: (POGOProtos.Rpc.ICancelEventRsvpOutProto|null);
                public claim_event_pass_rewards_response_proto_3034?: (POGOProtos.Rpc.IClaimEventPassRewardsResponseProto|null);
                public get_event_rsvp_count_out_proto_3036?: (POGOProtos.Rpc.IGetEventRsvpCountOutProto|null);
                public send_event_rsvp_invitation_out_proto_3039?: (POGOProtos.Rpc.ISendEventRsvpInvitationOutProto|null);
                public update_event_rsvp_selection_out_proto_3040?: (POGOProtos.Rpc.IUpdateEventRsvpSelectionOutProto|null);
                public get_station_info_out_proto_3051?: (POGOProtos.Rpc.IGetStationInfoOutProto|null);
                public age_confirmation_out_proto_3052?: (POGOProtos.Rpc.IAgeConfirmationOutProto|null);
                public change_stat_increase_goal_out_proto_3053?: (POGOProtos.Rpc.IChangeStatIncreaseGoalOutProto|null);
                public push_notification_registry_outproto_5000?: (POGOProtos.Rpc.IPushNotificationRegistryOutProto|null);
                public update_notification_out_proto_5002?: (POGOProtos.Rpc.IUpdateNotificationOutProto|null);
                public optout_proto_5003?: (POGOProtos.Rpc.IOptOutProto|null);
                public download_gm_templates_response_proto_5004?: (POGOProtos.Rpc.IDownloadGmTemplatesResponseProto|null);
                public get_inventory_response_proto_5005?: (POGOProtos.Rpc.IGetInventoryResponseProto|null);
                public redeem_passcoderesponse_proto_5006?: (POGOProtos.Rpc.IRedeemPasscodeResponseProto|null);
                public ping_responseproto_5007?: (POGOProtos.Rpc.IPingResponseProto|null);
                public add_loginaction_out_proto_5008?: (POGOProtos.Rpc.IAddLoginActionOutProto|null);
                public remove_login_action_out_proto_5009?: (POGOProtos.Rpc.IRemoveLoginActionOutProto|null);
                public listlogin_action_out_proto_5010?: (POGOProtos.Rpc.IListLoginActionOutProto|null);
                public submit_new_poi_out_proto_5011?: (POGOProtos.Rpc.ISubmitNewPoiOutProto|null);
                public proxy_responseproto_5012?: (POGOProtos.Rpc.IProxyResponseProto|null);
                public get_available_submissions_out_proto_5014?: (POGOProtos.Rpc.IGetAvailableSubmissionsOutProto|null);
                public replace_login_action_out_proto_5015?: (POGOProtos.Rpc.IReplaceLoginActionOutProto|null);
                public iap_purchase_sku_out_proto_5019?: (POGOProtos.Rpc.IIapPurchaseSkuOutProto|null);
                public iap_get_available_skus_and_balances_out_proto_5020?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesOutProto|null);
                public iap_redeem_google_receipt_out_proto_5021?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptOutProto|null);
                public iap_redeem_apple_receipt_out_proto_5022?: (POGOProtos.Rpc.IIapRedeemAppleReceiptOutProto|null);
                public iap_redeem_desktop_receipt_out_proto_5023?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptOutProto|null);
                public fitness_update_out_proto_5024?: (POGOProtos.Rpc.IFitnessUpdateOutProto|null);
                public get_fitness_report_out_proto_5025?: (POGOProtos.Rpc.IGetFitnessReportOutProto|null);
                public client_telemetryclient_settings_proto_5026?: (POGOProtos.Rpc.IClientTelemetryClientSettingsProto|null);
                public auth_register_background_device_response_proto_5028?: (POGOProtos.Rpc.IAuthRegisterBackgroundDeviceResponseProto|null);
                public internal_setin_game_currency_exchange_rate_out_proto_5032?: (POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateOutProto|null);
                public geofence_update_out_proto_5033?: (POGOProtos.Rpc.IGeofenceUpdateOutProto|null);
                public location_ping_out_proto_5034?: (POGOProtos.Rpc.ILocationPingOutProto|null);
                public generategmap_signed_url_out_proto_5035?: (POGOProtos.Rpc.IGenerateGmapSignedUrlOutProto|null);
                public getgmap_settings_out_proto_5036?: (POGOProtos.Rpc.IGetGmapSettingsOutProto|null);
                public iap_redeem_samsung_receipt_out_proto_5037?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptOutProto|null);
                public get_outstanding_warnings_response_proto_5039?: (POGOProtos.Rpc.IGetOutstandingWarningsResponseProto|null);
                public acknowledge_warnings_response_proto_5040?: (POGOProtos.Rpc.IAcknowledgeWarningsResponseProto|null);
                public get_web_token_out_proto_5045?: (POGOProtos.Rpc.IGetWebTokenOutProto|null);
                public get_adventure_sync_settings_response_proto_5046?: (POGOProtos.Rpc.IGetAdventureSyncSettingsResponseProto|null);
                public update_adventure_sync_settings_response_proto_5047?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsResponseProto|null);
                public set_birthday_response_proto_5048?: (POGOProtos.Rpc.ISetBirthdayResponseProto|null);
                public fetch_newsfeed_response_5049?: (POGOProtos.Rpc.IFetchNewsfeedResponse|null);
                public mark_newsfeed_read_response_5050?: (POGOProtos.Rpc.IMarkNewsfeedReadResponse|null);
                public internal_search_player_out_proto_10000?: (POGOProtos.Rpc.IInternalSearchPlayerOutProto|null);
                public internal_send_friendinvite_out_proto_10002?: (POGOProtos.Rpc.IInternalSendFriendInviteOutProto|null);
                public internal_cancel_friendinvite_out_proto_10003?: (POGOProtos.Rpc.IInternalCancelFriendInviteOutProto|null);
                public internal_accept_friendinvite_out_proto_10004?: (POGOProtos.Rpc.IInternalAcceptFriendInviteOutProto|null);
                public internal_decline_friendinvite_out_proto_10005?: (POGOProtos.Rpc.IInternalDeclineFriendInviteOutProto|null);
                public internal_get_friends_list_out_proto_10006?: (POGOProtos.Rpc.IInternalGetFriendsListOutProto|null);
                public internal_get_outgoing_friendinvites_out_proto_10007?: (POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesOutProto|null);
                public internal_getincoming_friendinvites_out_proto_10008?: (POGOProtos.Rpc.IInternalGetIncomingFriendInvitesOutProto|null);
                public internal_remove_friend_out_proto_10009?: (POGOProtos.Rpc.IInternalRemoveFriendOutProto|null);
                public internal_get_friend_details_out_proto_10010?: (POGOProtos.Rpc.IInternalGetFriendDetailsOutProto|null);
                public internalinvite_facebook_friend_out_proto_10011?: (POGOProtos.Rpc.IInternalInviteFacebookFriendOutProto|null);
                public internalis_my_friend_out_proto_10012?: (POGOProtos.Rpc.IInternalIsMyFriendOutProto|null);
                public internal_get_friend_code_out_proto_10013?: (POGOProtos.Rpc.IInternalGetFriendCodeOutProto|null);
                public internal_get_facebook_friend_list_out_proto_10014?: (POGOProtos.Rpc.IInternalGetFacebookFriendListOutProto|null);
                public internal_update_facebook_status_out_proto_10015?: (POGOProtos.Rpc.IInternalUpdateFacebookStatusOutProto|null);
                public savesocial_playersettings_out_proto_10016?: (POGOProtos.Rpc.ISaveSocialPlayerSettingsOutProto|null);
                public internal_get_player_settings_out_proto_10017?: (POGOProtos.Rpc.IInternalGetPlayerSettingsOutProto|null);
                public internal_set_account_settings_out_proto_10021?: (POGOProtos.Rpc.IInternalSetAccountSettingsOutProto|null);
                public internal_get_account_settings_out_proto_10022?: (POGOProtos.Rpc.IInternalGetAccountSettingsOutProto|null);
                public internal_add_favorite_friend_response_10023?: (POGOProtos.Rpc.IInternalAddFavoriteFriendResponse|null);
                public internal_remove_favorite_friend_response_10024?: (POGOProtos.Rpc.IInternalRemoveFavoriteFriendResponse|null);
                public internal_block_account_out_proto_10025?: (POGOProtos.Rpc.IInternalBlockAccountOutProto|null);
                public internal_unblock_account_out_proto_10026?: (POGOProtos.Rpc.IInternalUnblockAccountOutProto|null);
                public internal_get_outgoing_blocks_out_proto_10027?: (POGOProtos.Rpc.IInternalGetOutgoingBlocksOutProto|null);
                public internalis_account_blocked_out_proto_10028?: (POGOProtos.Rpc.IInternalIsAccountBlockedOutProto|null);
                public list_friend_activities_response_proto_10029?: (POGOProtos.Rpc.IListFriendActivitiesResponseProto|null);
                public internal_push_notification_registry_out_proto_10101?: (POGOProtos.Rpc.IInternalPushNotificationRegistryOutProto|null);
                public internal_update_notification_out_proto_10103?: (POGOProtos.Rpc.IInternalUpdateNotificationOutProto|null);
                public optout_proto_10104?: (POGOProtos.Rpc.IOptOutProto|null);
                public get_inbox_out_proto_10105?: (POGOProtos.Rpc.IGetInboxOutProto|null);
                public internal_list_opt_out_notification_categories_response_proto_10106?: (POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesResponseProto|null);
                public internal_get_signed_url_out_proto_10201?: (POGOProtos.Rpc.IInternalGetSignedUrlOutProto|null);
                public internal_submitimage_out_proto_10202?: (POGOProtos.Rpc.IInternalSubmitImageOutProto|null);
                public internal_get_photos_out_proto_10203?: (POGOProtos.Rpc.IInternalGetPhotosOutProto|null);
                public internal_update_profile_response_20001?: (POGOProtos.Rpc.IInternalUpdateProfileResponse|null);
                public internal_update_friendship_response_20002?: (POGOProtos.Rpc.IInternalUpdateFriendshipResponse|null);
                public internal_get_profile_response_20003?: (POGOProtos.Rpc.IInternalGetProfileResponse|null);
                public internalinvite_game_response_20004?: (POGOProtos.Rpc.IInternalInviteGameResponse|null);
                public internal_list_friends_response_20006?: (POGOProtos.Rpc.IInternalListFriendsResponse|null);
                public internal_get_friend_details_out_proto_20007?: (POGOProtos.Rpc.IInternalGetFriendDetailsOutProto|null);
                public internal_get_client_feature_flags_response_20008?: (POGOProtos.Rpc.IInternalGetClientFeatureFlagsResponse|null);
                public internal_getincoming_gameinvites_response_20010?: (POGOProtos.Rpc.IInternalGetIncomingGameInvitesResponse|null);
                public internal_updateincoming_gameinvite_response_20011?: (POGOProtos.Rpc.IInternalUpdateIncomingGameInviteResponse|null);
                public internal_dismiss_outgoing_gameinvites_response_20012?: (POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesResponse|null);
                public internal_sync_contact_list_response_20013?: (POGOProtos.Rpc.IInternalSyncContactListResponse|null);
                public internal_send_contact_list_friendinvite_response_20014?: (POGOProtos.Rpc.IInternalSendContactListFriendInviteResponse|null);
                public internal_refer_contact_list_friend_response_20015?: (POGOProtos.Rpc.IInternalReferContactListFriendResponse|null);
                public internal_get_contact_listinfo_response_20016?: (POGOProtos.Rpc.IInternalGetContactListInfoResponse|null);
                public internal_dismiss_contact_list_update_response_20017?: (POGOProtos.Rpc.IInternalDismissContactListUpdateResponse|null);
                public internal_notify_contact_list_friends_response_20018?: (POGOProtos.Rpc.IInternalNotifyContactListFriendsResponse|null);
                public internal_get_friend_recommendation_response_20500?: (POGOProtos.Rpc.IInternalGetFriendRecommendationResponse|null);
                public get_outstanding_warnings_response_proto_200000?: (POGOProtos.Rpc.IGetOutstandingWarningsResponseProto|null);
                public acknowledge_warnings_response_proto_200001?: (POGOProtos.Rpc.IAcknowledgeWarningsResponseProto|null);
                public register_background_deviceresponse_proto_230000?: (POGOProtos.Rpc.IRegisterBackgroundDeviceResponseProto|null);
                public get_adventure_sync_progress_out_proto_230002?: (POGOProtos.Rpc.IGetAdventureSyncProgressOutProto|null);
                public iap_purchase_sku_out_proto_310000?: (POGOProtos.Rpc.IIapPurchaseSkuOutProto|null);
                public iap_get_available_skus_and_balances_out_proto_310001?: (POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesOutProto|null);
                public iap_setin_game_currency_exchange_rate_out_proto_310002?: (POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateOutProto|null);
                public iap_redeem_google_receipt_out_proto_310100?: (POGOProtos.Rpc.IIapRedeemGoogleReceiptOutProto|null);
                public iap_redeem_apple_receipt_out_proto_310101?: (POGOProtos.Rpc.IIapRedeemAppleReceiptOutProto|null);
                public iap_redeem_desktop_receipt_out_proto_310102?: (POGOProtos.Rpc.IIapRedeemDesktopReceiptOutProto|null);
                public iap_redeem_samsung_receipt_out_proto_310103?: (POGOProtos.Rpc.IIapRedeemSamsungReceiptOutProto|null);
                public iap_get_available_subscriptions_response_proto_310200?: (POGOProtos.Rpc.IIapGetAvailableSubscriptionsResponseProto|null);
                public iap_get_active_subscriptions_response_proto_310201?: (POGOProtos.Rpc.IIapGetActiveSubscriptionsResponseProto|null);
                public get_reward_tiers_response_proto_310300?: (POGOProtos.Rpc.IGetRewardTiersResponseProto|null);
                public iap_redeem_xsolla_receipt_response_proto_311100?: (POGOProtos.Rpc.IIapRedeemXsollaReceiptResponseProto|null);
                public iap_get_user_response_proto_311101?: (POGOProtos.Rpc.IIapGetUserResponseProto|null);
                public geofence_update_out_proto_360000?: (POGOProtos.Rpc.IGeofenceUpdateOutProto|null);
                public location_ping_out_proto_360001?: (POGOProtos.Rpc.ILocationPingOutProto|null);
                public update_bulk_player_location_response_proto_360002?: (POGOProtos.Rpc.IUpdateBulkPlayerLocationResponseProto|null);
                public update_breadcrumb_history_response_proto_361000?: (POGOProtos.Rpc.IUpdateBreadcrumbHistoryResponseProto|null);
                public refresh_proximity_tokensresponse_proto_362000?: (POGOProtos.Rpc.IRefreshProximityTokensResponseProto|null);
                public report_proximity_contactsresponse_proto_362001?: (POGOProtos.Rpc.IReportProximityContactsResponseProto|null);
                public internal_add_login_action_out_proto_600000?: (POGOProtos.Rpc.IInternalAddLoginActionOutProto|null);
                public internal_remove_login_action_out_proto_600001?: (POGOProtos.Rpc.IInternalRemoveLoginActionOutProto|null);
                public internal_list_login_action_out_proto_600002?: (POGOProtos.Rpc.IInternalListLoginActionOutProto|null);
                public internal_replace_login_action_out_proto_600003?: (POGOProtos.Rpc.IInternalReplaceLoginActionOutProto|null);
                public internal_set_birthday_response_proto_600004?: (POGOProtos.Rpc.IInternalSetBirthdayResponseProto|null);
                public internal_gar_proxy_response_proto_600005?: (POGOProtos.Rpc.IInternalGarProxyResponseProto|null);
                public internal_link_to_account_login_response_proto_600006?: (POGOProtos.Rpc.IInternalLinkToAccountLoginResponseProto|null);
                public titan_submit_new_poi_out_proto_620000?: (POGOProtos.Rpc.ITitanSubmitNewPoiOutProto|null);
                public titan_get_available_submissions_out_proto_620001?: (POGOProtos.Rpc.ITitanGetAvailableSubmissionsOutProto|null);
                public titan_get_player_submission_validation_settings_out_proto_620003?: (POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsOutProto|null);
                public titan_generate_gmap_signed_url_out_proto_620300?: (POGOProtos.Rpc.ITitanGenerateGmapSignedUrlOutProto|null);
                public titan_get_gmap_settings_out_proto_620301?: (POGOProtos.Rpc.ITitanGetGmapSettingsOutProto|null);
                public titan_get_grapeshot_upload_url_out_proto_620401?: (POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlOutProto|null);
                public titan_async_file_upload_complete_out_proto_620402?: (POGOProtos.Rpc.ITitanAsyncFileUploadCompleteOutProto|null);
                public titan_get_a_r_mapping_settings_out_proto_620403?: (POGOProtos.Rpc.ITitanGetARMappingSettingsOutProto|null);
                public titan_get_images_for_poi_out_proto_620500?: (POGOProtos.Rpc.ITitanGetImagesForPoiOutProto|null);
                public titan_submit_player_image_vote_for_poi_out_proto_620501?: (POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiOutProto|null);
                public titan_get_image_gallery_settings_out_proto_620502?: (POGOProtos.Rpc.ITitanGetImageGallerySettingsOutProto|null);
                public get_maptiles_settings_response_620600?: (POGOProtos.Rpc.IGetMaptilesSettingsResponse|null);
                public titan_get_pois_in_radius_out_proto_620601?: (POGOProtos.Rpc.ITitanGetPoisInRadiusOutProto|null);
                public fitness_update_out_proto_640000?: (POGOProtos.Rpc.IFitnessUpdateOutProto|null);
                public get_fitness_report_out_proto_640001?: (POGOProtos.Rpc.IGetFitnessReportOutProto|null);
                public get_adventure_sync_settings_response_proto_640002?: (POGOProtos.Rpc.IGetAdventureSyncSettingsResponseProto|null);
                public update_adventure_sync_settings_response_proto_640003?: (POGOProtos.Rpc.IUpdateAdventureSyncSettingsResponseProto|null);
                public update_adventure_sync_fitness_response_proto_640004?: (POGOProtos.Rpc.IUpdateAdventureSyncFitnessResponseProto|null);
                public get_adventure_sync_fitness_report_response_proto_640005?: (POGOProtos.Rpc.IGetAdventureSyncFitnessReportResponseProto|null);
                public static encode(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IAllResponsesProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResponsesProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResponsesProto;
                public static toObject(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResponsesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMessage {
                method?: (POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResquestTypesProto|null);
                message?: (Uint8Array|null);
            }

            class Message implements IMessage {
                constructor(properties?: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IMessage);
                public method: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResquestTypesProto;
                public message: Uint8Array;
                public static encode(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.Message;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.Message;
                public static toObject(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.Message, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IResponse {
                method?: (POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResquestTypesProto|null);
                response?: (Uint8Array|null);
            }

            class Response implements IResponse {
                constructor(properties?: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IResponse);
                public method: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.AllResquestTypesProto;
                public response: Uint8Array;
                public static encode(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.IResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.Response;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.Response;
                public static toObject(message: POGOProtos.Rpc.AllTypesAndMessagesResponsesProto.Response, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IAnchorUpdateProto {
            update_type?: (POGOProtos.Rpc.AnchorUpdateProto.AnchorUpdateType|null);
            updated_anchor?: (POGOProtos.Rpc.IVpsAnchor|null);
        }

        class AnchorUpdateProto implements IAnchorUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IAnchorUpdateProto);
            public update_type: POGOProtos.Rpc.AnchorUpdateProto.AnchorUpdateType;
            public updated_anchor?: (POGOProtos.Rpc.IVpsAnchor|null);
            public static encode(message: POGOProtos.Rpc.IAnchorUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AnchorUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AnchorUpdateProto;
            public static toObject(message: POGOProtos.Rpc.AnchorUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AnchorUpdateProto {

            enum AnchorUpdateType {
                UNSET = 0,
                ADD = 1,
                EDIT = 2,
                REMOVE = 3
            }
        }

        interface IAndroidDataSource {
            is_raw?: (boolean|null);
            app_package_name?: (string|null);
            stream_identifier?: (string|null);
            stream_name?: (string|null);
            device?: (POGOProtos.Rpc.IAndroidDevice|null);
            data_type?: (string|null);
        }

        class AndroidDataSource implements IAndroidDataSource {
            constructor(properties?: POGOProtos.Rpc.IAndroidDataSource);
            public is_raw: boolean;
            public app_package_name: string;
            public stream_identifier: string;
            public stream_name: string;
            public device?: (POGOProtos.Rpc.IAndroidDevice|null);
            public data_type: string;
            public static encode(message: POGOProtos.Rpc.IAndroidDataSource, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AndroidDataSource;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AndroidDataSource;
            public static toObject(message: POGOProtos.Rpc.AndroidDataSource, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAndroidDevice {
            manufacturer?: (string|null);
            model?: (string|null);
            type?: (POGOProtos.Rpc.AndroidDevice.DeviceType|null);
            uid?: (string|null);
        }

        class AndroidDevice implements IAndroidDevice {
            constructor(properties?: POGOProtos.Rpc.IAndroidDevice);
            public manufacturer: string;
            public model: string;
            public type: POGOProtos.Rpc.AndroidDevice.DeviceType;
            public uid: string;
            public static encode(message: POGOProtos.Rpc.IAndroidDevice, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AndroidDevice;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AndroidDevice;
            public static toObject(message: POGOProtos.Rpc.AndroidDevice, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AndroidDevice {

            enum DeviceType {
                UNKNOWN = 0,
                PHONE = 1,
                TABLET = 2,
                WATCH = 3,
                CHEST_STRAP = 4,
                SCALE = 5,
                HEAD_MOUNTED = 6
            }
        }

        interface IAnimationOverrideProto {
            animation?: (POGOProtos.Rpc.AnimationOverrideProto.PokemonAnim|null);
            blacklist?: (boolean|null);
            anim_min?: (number|null);
            anim_max?: (number|null);
        }

        class AnimationOverrideProto implements IAnimationOverrideProto {
            constructor(properties?: POGOProtos.Rpc.IAnimationOverrideProto);
            public animation: POGOProtos.Rpc.AnimationOverrideProto.PokemonAnim;
            public blacklist: boolean;
            public anim_min: number;
            public anim_max: number;
            public static encode(message: POGOProtos.Rpc.IAnimationOverrideProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AnimationOverrideProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AnimationOverrideProto;
            public static toObject(message: POGOProtos.Rpc.AnimationOverrideProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AnimationOverrideProto {

            enum PokemonAnim {
                NONE = 0,
                IDLE_01 = 1,
                IDLE_02 = 2,
                LAND = 3,
                ATTACK_01 = 4,
                ATTACK_02 = 5,
                DAMAGED = 6,
                STUNNED = 7,
                LOOP = 8
            }
        }

        interface IAntiLeakSettingsProto {
            prevent_leaks?: (boolean|null);
        }

        class AntiLeakSettingsProto implements IAntiLeakSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAntiLeakSettingsProto);
            public prevent_leaks: boolean;
            public static encode(message: POGOProtos.Rpc.IAntiLeakSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AntiLeakSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AntiLeakSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AntiLeakSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IApi {
            name?: (string|null);
            methods?: (POGOProtos.Rpc.IMethodGoogle[]|null);
            options?: (POGOProtos.Rpc.IOption[]|null);
            version?: (string|null);
            source_context?: (POGOProtos.Rpc.ISourceContext|null);
            mixins?: (POGOProtos.Rpc.IMixin[]|null);
            syntax?: (POGOProtos.Rpc.Syntax|null);
        }

        class Api implements IApi {
            constructor(properties?: POGOProtos.Rpc.IApi);
            public name: string;
            public methods: POGOProtos.Rpc.IMethodGoogle[];
            public options: POGOProtos.Rpc.IOption[];
            public version: string;
            public source_context?: (POGOProtos.Rpc.ISourceContext|null);
            public mixins: POGOProtos.Rpc.IMixin[];
            public syntax: POGOProtos.Rpc.Syntax;
            public static encode(message: POGOProtos.Rpc.IApi, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Api;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Api;
            public static toObject(message: POGOProtos.Rpc.Api, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IApnToken {
            registration_id?: (string|null);
            bundle_identifier?: (string|null);
            payload_byte_size?: (number|null);
        }

        class ApnToken implements IApnToken {
            constructor(properties?: POGOProtos.Rpc.IApnToken);
            public registration_id: string;
            public bundle_identifier: string;
            public payload_byte_size: number;
            public static encode(message: POGOProtos.Rpc.IApnToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ApnToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ApnToken;
            public static toObject(message: POGOProtos.Rpc.ApnToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppealRouteOutProto {
            result?: (POGOProtos.Rpc.AppealRouteOutProto.Result|null);
            updated_route?: (POGOProtos.Rpc.ISharedRouteProto|null);
        }

        class AppealRouteOutProto implements IAppealRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.IAppealRouteOutProto);
            public result: POGOProtos.Rpc.AppealRouteOutProto.Result;
            public updated_route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public static encode(message: POGOProtos.Rpc.IAppealRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppealRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppealRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.AppealRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AppealRouteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_ROUTE = 3,
                ERROR_ALREADY_APPEALED = 4
            }
        }

        interface IAppealRouteProto {
            route_id?: (string|null);
            appeal_reason?: (string|null);
            preferred_language?: (string|null);
        }

        class AppealRouteProto implements IAppealRouteProto {
            constructor(properties?: POGOProtos.Rpc.IAppealRouteProto);
            public route_id: string;
            public appeal_reason: string;
            public preferred_language: string;
            public static encode(message: POGOProtos.Rpc.IAppealRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppealRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppealRouteProto;
            public static toObject(message: POGOProtos.Rpc.AppealRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppleToken {
            id_token?: (string|null);
            session_token?: (Uint8Array|null);
        }

        class AppleToken implements IAppleToken {
            constructor(properties?: POGOProtos.Rpc.IAppleToken);
            public id_token: string;
            public session_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAppleToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppleToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppleToken;
            public static toObject(message: POGOProtos.Rpc.AppleToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedAttackDefenseBonusProto {
            attributes?: (POGOProtos.Rpc.IAttackDefenseBonusAttributeSettingsProto[]|null);
        }

        class AppliedAttackDefenseBonusProto implements IAppliedAttackDefenseBonusProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedAttackDefenseBonusProto);
            public attributes: POGOProtos.Rpc.IAttackDefenseBonusAttributeSettingsProto[];
            public static encode(message: POGOProtos.Rpc.IAppliedAttackDefenseBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedAttackDefenseBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedAttackDefenseBonusProto;
            public static toObject(message: POGOProtos.Rpc.AppliedAttackDefenseBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedBonusEffectProto {
            time_bonus?: (POGOProtos.Rpc.IAppliedTimeBonusProto|null);
            space_bonus?: (POGOProtos.Rpc.IAppliedSpaceBonusProto|null);
            day_night_bonus?: (POGOProtos.Rpc.IAppliedDayNightBonusProto|null);
            slow_freeze_bonus?: (POGOProtos.Rpc.IAppliedSlowFreezeBonusProto|null);
            attack_defense_bonus?: (POGOProtos.Rpc.IAppliedAttackDefenseBonusProto|null);
        }

        class AppliedBonusEffectProto implements IAppliedBonusEffectProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedBonusEffectProto);
            public time_bonus?: (POGOProtos.Rpc.IAppliedTimeBonusProto|null);
            public space_bonus?: (POGOProtos.Rpc.IAppliedSpaceBonusProto|null);
            public day_night_bonus?: (POGOProtos.Rpc.IAppliedDayNightBonusProto|null);
            public slow_freeze_bonus?: (POGOProtos.Rpc.IAppliedSlowFreezeBonusProto|null);
            public attack_defense_bonus?: (POGOProtos.Rpc.IAppliedAttackDefenseBonusProto|null);
            public Bonus?: ("time_bonus"|"space_bonus"|"day_night_bonus"|"slow_freeze_bonus"|"attack_defense_bonus");
            public static encode(message: POGOProtos.Rpc.IAppliedBonusEffectProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedBonusEffectProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedBonusEffectProto;
            public static toObject(message: POGOProtos.Rpc.AppliedBonusEffectProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedBonusProto {
            bonus_type?: (POGOProtos.Rpc.PlayerBonusType|null);
            expiration_time_ms?: (number|Long|null);
            applied_time_ms?: (number|Long|null);
            effect?: (POGOProtos.Rpc.IAppliedBonusEffectProto|null);
        }

        class AppliedBonusProto implements IAppliedBonusProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedBonusProto);
            public bonus_type: POGOProtos.Rpc.PlayerBonusType;
            public expiration_time_ms: (number|Long);
            public applied_time_ms: (number|Long);
            public effect?: (POGOProtos.Rpc.IAppliedBonusEffectProto|null);
            public static encode(message: POGOProtos.Rpc.IAppliedBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedBonusProto;
            public static toObject(message: POGOProtos.Rpc.AppliedBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedBonusesProto {
            item?: (POGOProtos.Rpc.IAppliedBonusProto[]|null);
        }

        class AppliedBonusesProto implements IAppliedBonusesProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedBonusesProto);
            public item: POGOProtos.Rpc.IAppliedBonusProto[];
            public static encode(message: POGOProtos.Rpc.IAppliedBonusesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedBonusesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedBonusesProto;
            public static toObject(message: POGOProtos.Rpc.AppliedBonusesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedDayNightBonusProto {
            incense_item?: (POGOProtos.Rpc.Item|null);
            incense_spawn_distribution?: (POGOProtos.Rpc.IEggDistributionProto|null);
        }

        class AppliedDayNightBonusProto implements IAppliedDayNightBonusProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedDayNightBonusProto);
            public incense_item: POGOProtos.Rpc.Item;
            public incense_spawn_distribution?: (POGOProtos.Rpc.IEggDistributionProto|null);
            public static encode(message: POGOProtos.Rpc.IAppliedDayNightBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedDayNightBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedDayNightBonusProto;
            public static toObject(message: POGOProtos.Rpc.AppliedDayNightBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedItemProto {
            item?: (POGOProtos.Rpc.Item|null);
            item_type?: (POGOProtos.Rpc.HoloItemType|null);
            expiration_ms?: (number|Long|null);
            applied_ms?: (number|Long|null);
        }

        class AppliedItemProto implements IAppliedItemProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedItemProto);
            public item: POGOProtos.Rpc.Item;
            public item_type: POGOProtos.Rpc.HoloItemType;
            public expiration_ms: (number|Long);
            public applied_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IAppliedItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedItemProto;
            public static toObject(message: POGOProtos.Rpc.AppliedItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedItemsProto {
            item?: (POGOProtos.Rpc.IAppliedItemProto[]|null);
        }

        class AppliedItemsProto implements IAppliedItemsProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedItemsProto);
            public item: POGOProtos.Rpc.IAppliedItemProto[];
            public static encode(message: POGOProtos.Rpc.IAppliedItemsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedItemsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedItemsProto;
            public static toObject(message: POGOProtos.Rpc.AppliedItemsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedSlowFreezeBonusProto {
            catch_circle_speed_override?: (number|null);
            catch_rate_increase_multiplier?: (number|null);
            catch_circle_speed_change_threshold?: (number|null);
            catch_circle_outer_time_scale_override?: (number|null);
        }

        class AppliedSlowFreezeBonusProto implements IAppliedSlowFreezeBonusProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedSlowFreezeBonusProto);
            public catch_circle_speed_override: number;
            public catch_rate_increase_multiplier: number;
            public catch_circle_speed_change_threshold: number;
            public catch_circle_outer_time_scale_override: number;
            public static encode(message: POGOProtos.Rpc.IAppliedSlowFreezeBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedSlowFreezeBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedSlowFreezeBonusProto;
            public static toObject(message: POGOProtos.Rpc.AppliedSlowFreezeBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedSpaceBonusProto {
            pokemon_visible_range_meters?: (number|null);
            encounter_range_meters?: (number|null);
            server_allowable_encounter_range_meters?: (number|null);
        }

        class AppliedSpaceBonusProto implements IAppliedSpaceBonusProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedSpaceBonusProto);
            public pokemon_visible_range_meters: number;
            public encounter_range_meters: number;
            public server_allowable_encounter_range_meters: number;
            public static encode(message: POGOProtos.Rpc.IAppliedSpaceBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedSpaceBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedSpaceBonusProto;
            public static toObject(message: POGOProtos.Rpc.AppliedSpaceBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedTimeBonusProto {
            affected_items?: (POGOProtos.Rpc.Item[]|null);
        }

        class AppliedTimeBonusProto implements IAppliedTimeBonusProto {
            constructor(properties?: POGOProtos.Rpc.IAppliedTimeBonusProto);
            public affected_items: POGOProtos.Rpc.Item[];
            public static encode(message: POGOProtos.Rpc.IAppliedTimeBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppliedTimeBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppliedTimeBonusProto;
            public static toObject(message: POGOProtos.Rpc.AppliedTimeBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppraisalStarThresholdSettings {
            threshold_one_star?: (number|null);
            threshold_two_star?: (number|null);
            threshold_three_star?: (number|null);
            threshold_four_star?: (number|null);
        }

        class AppraisalStarThresholdSettings implements IAppraisalStarThresholdSettings {
            constructor(properties?: POGOProtos.Rpc.IAppraisalStarThresholdSettings);
            public threshold_one_star: number;
            public threshold_two_star: number;
            public threshold_three_star: number;
            public threshold_four_star: number;
            public static encode(message: POGOProtos.Rpc.IAppraisalStarThresholdSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AppraisalStarThresholdSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AppraisalStarThresholdSettings;
            public static toObject(message: POGOProtos.Rpc.AppraisalStarThresholdSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IApprovedCommonTelemetryProto {
            boot_time?: (POGOProtos.Rpc.ICommonTelemetryBootTime|null);
            shop_click?: (POGOProtos.Rpc.ICommonTelemetryShopClick|null);
            shop_view?: (POGOProtos.Rpc.ICommonTelemetryShopView|null);
            poi_submission_telemetry?: (POGOProtos.Rpc.IPoiSubmissionTelemetry|null);
            poi_submission_photo_upload_error_telemetry?: (POGOProtos.Rpc.IPoiSubmissionPhotoUploadErrorTelemetry|null);
            log_in?: (POGOProtos.Rpc.ICommonTelemetryLogIn|null);
            poi_categorization_entry_telemetry?: (POGOProtos.Rpc.IPoiCategorizationEntryTelemetry|null);
            poi_categorization_operation_telemetry?: (POGOProtos.Rpc.IPoiCategorizationOperationTelemetry|null);
            poi_categorization_selected_telemetry?: (POGOProtos.Rpc.IPoiCategorySelectedTelemetry|null);
            poi_categorization_removed_telemetry?: (POGOProtos.Rpc.IPoiCategoryRemovedTelemetry|null);
            wayfarer_onboarding_flow_telemetry?: (POGOProtos.Rpc.IWayfarerOnboardingFlowTelemetry|null);
            as_permission_flow_telemetry?: (POGOProtos.Rpc.IASPermissionFlowTelemetry|null);
            log_out?: (POGOProtos.Rpc.ICommonTelemetryLogOut|null);
            server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
        }

        class ApprovedCommonTelemetryProto implements IApprovedCommonTelemetryProto {
            constructor(properties?: POGOProtos.Rpc.IApprovedCommonTelemetryProto);
            public boot_time?: (POGOProtos.Rpc.ICommonTelemetryBootTime|null);
            public shop_click?: (POGOProtos.Rpc.ICommonTelemetryShopClick|null);
            public shop_view?: (POGOProtos.Rpc.ICommonTelemetryShopView|null);
            public poi_submission_telemetry?: (POGOProtos.Rpc.IPoiSubmissionTelemetry|null);
            public poi_submission_photo_upload_error_telemetry?: (POGOProtos.Rpc.IPoiSubmissionPhotoUploadErrorTelemetry|null);
            public log_in?: (POGOProtos.Rpc.ICommonTelemetryLogIn|null);
            public poi_categorization_entry_telemetry?: (POGOProtos.Rpc.IPoiCategorizationEntryTelemetry|null);
            public poi_categorization_operation_telemetry?: (POGOProtos.Rpc.IPoiCategorizationOperationTelemetry|null);
            public poi_categorization_selected_telemetry?: (POGOProtos.Rpc.IPoiCategorySelectedTelemetry|null);
            public poi_categorization_removed_telemetry?: (POGOProtos.Rpc.IPoiCategoryRemovedTelemetry|null);
            public wayfarer_onboarding_flow_telemetry?: (POGOProtos.Rpc.IWayfarerOnboardingFlowTelemetry|null);
            public as_permission_flow_telemetry?: (POGOProtos.Rpc.IASPermissionFlowTelemetry|null);
            public log_out?: (POGOProtos.Rpc.ICommonTelemetryLogOut|null);
            public server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            public common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
            public TelemetryData?: ("boot_time"|"shop_click"|"shop_view"|"poi_submission_telemetry"|"poi_submission_photo_upload_error_telemetry"|"log_in"|"poi_categorization_entry_telemetry"|"poi_categorization_operation_telemetry"|"poi_categorization_selected_telemetry"|"poi_categorization_removed_telemetry"|"wayfarer_onboarding_flow_telemetry"|"as_permission_flow_telemetry"|"log_out");
            public static encode(message: POGOProtos.Rpc.IApprovedCommonTelemetryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ApprovedCommonTelemetryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ApprovedCommonTelemetryProto;
            public static toObject(message: POGOProtos.Rpc.ApprovedCommonTelemetryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IArMappingSessionTelemetryProto {
            fulfilled_geotargeted_quest?: (boolean|null);
        }

        class ArMappingSessionTelemetryProto implements IArMappingSessionTelemetryProto {
            constructor(properties?: POGOProtos.Rpc.IArMappingSessionTelemetryProto);
            public fulfilled_geotargeted_quest: boolean;
            public static encode(message: POGOProtos.Rpc.IArMappingSessionTelemetryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArMappingSessionTelemetryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArMappingSessionTelemetryProto;
            public static toObject(message: POGOProtos.Rpc.ArMappingSessionTelemetryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IArMappingSettingsProto {
            min_hours_between_prompt?: (number|null);
            max_video_time_seconds?: (number|null);
            preview_video_bitrate_kbps?: (number|null);
            preview_video_deadline_ms?: (number|null);
            research_video_bitrate_kbps?: (number|null);
            research_video_deadline_ms?: (number|null);
            min_video_time_seconds?: (number|null);
            preview_frame_rate_fps?: (number|null);
            preview_frames_to_jump?: (number|null);
            max_upload_chunk_rejected_count?: (number|null);
            ardk_desired_accuracy_mm?: (number|null);
            ardk_update_distance_mm?: (number|null);
            max_pending_upload_kilobytes?: (number|null);
            enable_sponsor_poi_scan?: (boolean|null);
            min_disk_space_needed_mb?: (number|null);
            scan_validation_enabled?: (boolean|null);
            scan_validation_start_delay_s?: (number|null);
            scan_validation_lumens_min_threshold?: (number|null);
            scan_validation_lumens_smoothing_factor?: (number|null);
            scan_validation_average_pixel_threshold?: (number|null);
            scan_validation_average_pixel_smoothing_factor?: (number|null);
            scan_validation_speed_min_threshold_mper_s?: (number|null);
            scan_validation_speed_max_threshold_mper_s?: (number|null);
            scan_validation_speed_smoothing_factor?: (number|null);
            scan_validation_max_warning_time_s?: (number|null);
            ar_recorder_v2_enabled?: (boolean|null);
        }

        class ArMappingSettingsProto implements IArMappingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IArMappingSettingsProto);
            public min_hours_between_prompt: number;
            public max_video_time_seconds: number;
            public preview_video_bitrate_kbps: number;
            public preview_video_deadline_ms: number;
            public research_video_bitrate_kbps: number;
            public research_video_deadline_ms: number;
            public min_video_time_seconds: number;
            public preview_frame_rate_fps: number;
            public preview_frames_to_jump: number;
            public max_upload_chunk_rejected_count: number;
            public ardk_desired_accuracy_mm: number;
            public ardk_update_distance_mm: number;
            public max_pending_upload_kilobytes: number;
            public enable_sponsor_poi_scan: boolean;
            public min_disk_space_needed_mb: number;
            public scan_validation_enabled: boolean;
            public scan_validation_start_delay_s: number;
            public scan_validation_lumens_min_threshold: number;
            public scan_validation_lumens_smoothing_factor: number;
            public scan_validation_average_pixel_threshold: number;
            public scan_validation_average_pixel_smoothing_factor: number;
            public scan_validation_speed_min_threshold_mper_s: number;
            public scan_validation_speed_max_threshold_mper_s: number;
            public scan_validation_speed_smoothing_factor: number;
            public scan_validation_max_warning_time_s: number;
            public ar_recorder_v2_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IArMappingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArMappingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArMappingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ArMappingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IArMappingTelemetryProto {
            ar_mapping_telemetry_id?: (POGOProtos.Rpc.ArMappingTelemetryProto.ArMappingEventId|null);
            source?: (POGOProtos.Rpc.ArMappingTelemetryProto.ArMappingEntryPoint|null);
            recording_length_seconds?: (number|null);
            time_elapsed_seconds?: (number|null);
            percent_encoded?: (number|null);
            data_size_bytes?: (number|Long|null);
            validation_failure_reason?: (POGOProtos.Rpc.ArMappingTelemetryProto.ArMappingValidationFailureReason|null);
        }

        class ArMappingTelemetryProto implements IArMappingTelemetryProto {
            constructor(properties?: POGOProtos.Rpc.IArMappingTelemetryProto);
            public ar_mapping_telemetry_id: POGOProtos.Rpc.ArMappingTelemetryProto.ArMappingEventId;
            public source: POGOProtos.Rpc.ArMappingTelemetryProto.ArMappingEntryPoint;
            public recording_length_seconds: number;
            public time_elapsed_seconds: number;
            public percent_encoded: number;
            public data_size_bytes: (number|Long);
            public validation_failure_reason: POGOProtos.Rpc.ArMappingTelemetryProto.ArMappingValidationFailureReason;
            public static encode(message: POGOProtos.Rpc.IArMappingTelemetryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArMappingTelemetryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArMappingTelemetryProto;
            public static toObject(message: POGOProtos.Rpc.ArMappingTelemetryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ArMappingTelemetryProto {

            enum ArMappingEntryPoint {
                UNKNOWN_ENTRY = 0,
                POI_EDIT_MENU = 1,
                POI_EDIT_TITLE = 2,
                POI_EDIT_DESCRIPTION = 3,
                POI_ADD_PHOTO = 4,
                POI_EDIT_LOCATION = 5,
                POI_NOMINATION = 6,
                POI_FULLSCREEN_INSPECTION = 7,
                GEOTARGETED_QUESTS = 8
            }

            enum ArMappingEventId {
                UNKNOWN = 0,
                ENTER_STATE = 1,
                OPT_IN_ACCEPT = 2,
                OPT_IN_DENY = 3,
                OPT_IN_SETTINGS = 4,
                OPT_OUT_SETTINGS = 5,
                EXIT_FROM_RECORDING = 6,
                START_RECORDING = 7,
                STOP_RECORDING = 8,
                CANCEL_ENCODING = 9,
                UPLOAD_NOW = 10,
                UPLOAD_LATER = 11,
                CANCEL_UPLOAD = 12,
                START_UPLOAD_SETTINGS = 13,
                UPLOAD_SUCCESS = 14,
                OPT_IN_LEARN_MORE = 15,
                EXIT_FROM_PREVIEW = 16,
                SUBMIT_POI_AR_VIDEO_METADATA_FAIL = 17,
                UPLOAD_FAILURE = 18,
                UPLOAD_LATER_WIFI_PROMPT = 19,
                CLEAR_SCANS = 20,
                OPEN_INFO_PANEL = 21,
                RESCAN_FROM_PREVIEW = 22,
                SCAN_VALIDATION_FAILURE = 23
            }

            enum ArMappingValidationFailureReason {
                UNKNOWN_REASON = 0,
                TOO_FAST = 1,
                TOO_SLOW = 2,
                TOO_DARK = 3
            }
        }

        interface IArPhotoGlobalSettings {
            min_player_level?: (number|null);
        }

        class ArPhotoGlobalSettings implements IArPhotoGlobalSettings {
            constructor(properties?: POGOProtos.Rpc.IArPhotoGlobalSettings);
            public min_player_level: number;
            public static encode(message: POGOProtos.Rpc.IArPhotoGlobalSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArPhotoGlobalSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArPhotoGlobalSettings;
            public static toObject(message: POGOProtos.Rpc.ArPhotoGlobalSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IArPhotoSessionProto {
            ar_type?: (POGOProtos.Rpc.ArPhotoSessionProto.ArType|null);
            furthest_step_completed?: (POGOProtos.Rpc.ArPhotoSessionProto.Step|null);
            num_photos_taken?: (number|null);
            num_photos_shared?: (number|null);
            num_photos_taken_occlusions?: (number|null);
            num_occlusions_enabled?: (number|null);
            num_occlusions_disabled?: (number|null);
            ar_context?: (POGOProtos.Rpc.ArPhotoSessionProto.ArContext|null);
            session_length?: (number|Long|null);
            session_length_occlusions?: (number|Long|null);
            num_photos_shared_occlusions?: (number|null);
            model_url?: (string|null);
            ardk_version?: (string|null);
            average_framerate?: (number|null);
            average_battery_per_min?: (number|null);
            average_cpu_usage?: (number|null);
            average_gpu_usage?: (number|null);
            framerate_samples?: (POGOProtos.Rpc.ArPhotoSessionProto.IFramerateSample[]|null);
            battery_samples?: (POGOProtos.Rpc.ArPhotoSessionProto.IBatterySample[]|null);
            processor_samples?: (POGOProtos.Rpc.ArPhotoSessionProto.IProcessorSample[]|null);
            session_start_to_plane_detection_ms?: (number|null);
            plane_detection_to_user_interaction_ms?: (number|null);
        }

        class ArPhotoSessionProto implements IArPhotoSessionProto {
            constructor(properties?: POGOProtos.Rpc.IArPhotoSessionProto);
            public ar_type: POGOProtos.Rpc.ArPhotoSessionProto.ArType;
            public furthest_step_completed: POGOProtos.Rpc.ArPhotoSessionProto.Step;
            public num_photos_taken: number;
            public num_photos_shared: number;
            public num_photos_taken_occlusions: number;
            public num_occlusions_enabled: number;
            public num_occlusions_disabled: number;
            public ar_context: POGOProtos.Rpc.ArPhotoSessionProto.ArContext;
            public session_length: (number|Long);
            public session_length_occlusions: (number|Long);
            public num_photos_shared_occlusions: number;
            public model_url: string;
            public ardk_version: string;
            public average_framerate: number;
            public average_battery_per_min: number;
            public average_cpu_usage: number;
            public average_gpu_usage: number;
            public framerate_samples: POGOProtos.Rpc.ArPhotoSessionProto.IFramerateSample[];
            public battery_samples: POGOProtos.Rpc.ArPhotoSessionProto.IBatterySample[];
            public processor_samples: POGOProtos.Rpc.ArPhotoSessionProto.IProcessorSample[];
            public session_start_to_plane_detection_ms: number;
            public plane_detection_to_user_interaction_ms: number;
            public static encode(message: POGOProtos.Rpc.IArPhotoSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArPhotoSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArPhotoSessionProto;
            public static toObject(message: POGOProtos.Rpc.ArPhotoSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ArPhotoSessionProto {

            enum ArContext {
                NONE = 0,
                AR_ENCOUNTER = 1,
                AR_SNAPSHOT = 2,
                SINGLEPLAYER_BUDDY = 3,
                MULTIPLAYER_BUDDY = 4
            }

            enum ArType {
                UNSET = 0,
                PLUS = 1,
                CLASSIC = 2
            }

            enum BatteryStatus {
                UNDETERMINED = 0,
                CHARGING = 1,
                DISCHARGING = 2,
                NOT_CHARGING = 3,
                FULL = 4
            }

            enum Step {
                UNKNOWN = 0,
                CAMERA_PERMISSION_GRANTED = 1,
                ARPLUS_PLANE_FOUND = 2,
                ARPLUS_POKEMON_PLACED = 3,
                PHOTO_TAKEN = 4,
                PHOTO_SHARED = 5
            }

            interface IArConditions {
                timestamp?: (number|Long|null);
                occlusions_enabled?: (boolean|null);
                current_ar_step?: (POGOProtos.Rpc.ArPhotoSessionProto.Step|null);
            }

            class ArConditions implements IArConditions {
                constructor(properties?: POGOProtos.Rpc.ArPhotoSessionProto.IArConditions);
                public timestamp: (number|Long);
                public occlusions_enabled: boolean;
                public current_ar_step: POGOProtos.Rpc.ArPhotoSessionProto.Step;
                public static encode(message: POGOProtos.Rpc.ArPhotoSessionProto.IArConditions, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArPhotoSessionProto.ArConditions;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArPhotoSessionProto.ArConditions;
                public static toObject(message: POGOProtos.Rpc.ArPhotoSessionProto.ArConditions, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBatterySample {
                conditions?: (POGOProtos.Rpc.ArPhotoSessionProto.IArConditions|null);
                battery_level?: (number|null);
                status?: (POGOProtos.Rpc.ArPhotoSessionProto.BatteryStatus|null);
            }

            class BatterySample implements IBatterySample {
                constructor(properties?: POGOProtos.Rpc.ArPhotoSessionProto.IBatterySample);
                public conditions?: (POGOProtos.Rpc.ArPhotoSessionProto.IArConditions|null);
                public battery_level: number;
                public status: POGOProtos.Rpc.ArPhotoSessionProto.BatteryStatus;
                public static encode(message: POGOProtos.Rpc.ArPhotoSessionProto.IBatterySample, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArPhotoSessionProto.BatterySample;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArPhotoSessionProto.BatterySample;
                public static toObject(message: POGOProtos.Rpc.ArPhotoSessionProto.BatterySample, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFramerateSample {
                conditions?: (POGOProtos.Rpc.ArPhotoSessionProto.IArConditions|null);
                framerate?: (number|null);
            }

            class FramerateSample implements IFramerateSample {
                constructor(properties?: POGOProtos.Rpc.ArPhotoSessionProto.IFramerateSample);
                public conditions?: (POGOProtos.Rpc.ArPhotoSessionProto.IArConditions|null);
                public framerate: number;
                public static encode(message: POGOProtos.Rpc.ArPhotoSessionProto.IFramerateSample, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArPhotoSessionProto.FramerateSample;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArPhotoSessionProto.FramerateSample;
                public static toObject(message: POGOProtos.Rpc.ArPhotoSessionProto.FramerateSample, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IProcessorSample {
                conditions?: (POGOProtos.Rpc.ArPhotoSessionProto.IArConditions|null);
                cpu_usage?: (number|null);
                gpu_usage?: (number|null);
            }

            class ProcessorSample implements IProcessorSample {
                constructor(properties?: POGOProtos.Rpc.ArPhotoSessionProto.IProcessorSample);
                public conditions?: (POGOProtos.Rpc.ArPhotoSessionProto.IArConditions|null);
                public cpu_usage: number;
                public gpu_usage: number;
                public static encode(message: POGOProtos.Rpc.ArPhotoSessionProto.IProcessorSample, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArPhotoSessionProto.ProcessorSample;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArPhotoSessionProto.ProcessorSample;
                public static toObject(message: POGOProtos.Rpc.ArPhotoSessionProto.ProcessorSample, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IArSessionStartEvent {
            empty_field?: (boolean|null);
        }

        class ArSessionStartEvent implements IArSessionStartEvent {
            constructor(properties?: POGOProtos.Rpc.IArSessionStartEvent);
            public empty_field: boolean;
            public static encode(message: POGOProtos.Rpc.IArSessionStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArSessionStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArSessionStartEvent;
            public static toObject(message: POGOProtos.Rpc.ArSessionStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IArTelemetrySettingsProto {
            measure_battery?: (boolean|null);
            battery_sampling_interval_ms?: (number|null);
            measure_processor?: (boolean|null);
            processor_sampling_interval_ms?: (number|null);
            measure_framerate?: (boolean|null);
            framerate_sampling_interval_ms?: (number|null);
            percentage_sessions_to_sample?: (number|null);
            enable_ardk_telemetry?: (boolean|null);
        }

        class ArTelemetrySettingsProto implements IArTelemetrySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IArTelemetrySettingsProto);
            public measure_battery: boolean;
            public battery_sampling_interval_ms: number;
            public measure_processor: boolean;
            public processor_sampling_interval_ms: number;
            public measure_framerate: boolean;
            public framerate_sampling_interval_ms: number;
            public percentage_sessions_to_sample: number;
            public enable_ardk_telemetry: boolean;
            public static encode(message: POGOProtos.Rpc.IArTelemetrySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArTelemetrySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArTelemetrySettingsProto;
            public static toObject(message: POGOProtos.Rpc.ArTelemetrySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IArdkConfigSettingsProto {
            orb_vocab_url?: (string|null);
            monodpeth_model_url?: (string|null);
            monodepth_devices?: (string[]|null);
            monodepth_contexts?: (POGOProtos.Rpc.ArdkConfigSettingsProto.ArContext[]|null);
            ios_monodepth_model_url?: (string|null);
            android_monodepth_model_url?: (string|null);
            monodepth_model_url?: (string|null);
        }

        class ArdkConfigSettingsProto implements IArdkConfigSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IArdkConfigSettingsProto);
            public orb_vocab_url: string;
            public monodpeth_model_url: string;
            public monodepth_devices: string[];
            public monodepth_contexts: POGOProtos.Rpc.ArdkConfigSettingsProto.ArContext[];
            public ios_monodepth_model_url: string;
            public android_monodepth_model_url: string;
            public monodepth_model_url: string;
            public static encode(message: POGOProtos.Rpc.IArdkConfigSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArdkConfigSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArdkConfigSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ArdkConfigSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ArdkConfigSettingsProto {

            enum ArContext {
                UNSET = 0,
                AR_ENCOUNTER = 1,
                AR_SNAPSHOT = 2,
                SINGLEPLAYER_BUDDY = 3,
                MULTIPLAYER_BUDDY = 4
            }
        }

        interface IArdkNextTelemetryOmniProto {
            initialization_event?: (POGOProtos.Rpc.IInitializationEvent|null);
            scan_recorder_start_event?: (POGOProtos.Rpc.IScanRecorderStartEvent|null);
            scan_recorder_stop_event?: (POGOProtos.Rpc.IScanRecorderStopEvent|null);
            scan_sqc_run_event?: (POGOProtos.Rpc.IScanSQCRunEvent|null);
            scan_sqc_done_event?: (POGOProtos.Rpc.IScanSQCDoneEvent|null);
            scan_error_event?: (POGOProtos.Rpc.IScanErrorEvent|null);
            scan_archive_builder_get_next_chunk_event?: (POGOProtos.Rpc.IScanArchiveBuilderGetNextChunkEvent|null);
            scan_archive_builder_cancel_event?: (POGOProtos.Rpc.IScanArchiveBuilderCancelEvent|null);
            vps_localization_started_event?: (POGOProtos.Rpc.IVpsLocalizationStartedEvent|null);
            vps_localization_success_event?: (POGOProtos.Rpc.IVpsLocalizationSuccessEvent|null);
            vps_session_ended_event?: (POGOProtos.Rpc.IVpsSessionEndedEvent|null);
            ar_session_start_event?: (POGOProtos.Rpc.IArSessionStartEvent|null);
            depth_start_event?: (POGOProtos.Rpc.IDepthStartEvent|null);
            depth_stop_event?: (POGOProtos.Rpc.IDepthStopEvent|null);
            semantics_start_event?: (POGOProtos.Rpc.ISemanticsStartEvent|null);
            semantics_stop_event?: (POGOProtos.Rpc.ISemanticsStopEvent|null);
            meshing_start_event?: (POGOProtos.Rpc.IMeshingStartEvent|null);
            meshing_stop_event?: (POGOProtos.Rpc.IMeshingStopEvent|null);
            object_detection_start_event?: (POGOProtos.Rpc.IObjectDetectionStartEvent|null);
            object_detection_stop_event?: (POGOProtos.Rpc.IObjectDetectionStopEvent|null);
            wps_start_event?: (POGOProtos.Rpc.IWpsStartEvent|null);
            wps_available_event?: (POGOProtos.Rpc.IWpsAvailableEvent|null);
            wps_stop_event?: (POGOProtos.Rpc.IWpsStopEvent|null);
            ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            developer_key?: (string|null);
            timestamp_ms?: (number|Long|null);
        }

        class ArdkNextTelemetryOmniProto implements IArdkNextTelemetryOmniProto {
            constructor(properties?: POGOProtos.Rpc.IArdkNextTelemetryOmniProto);
            public initialization_event?: (POGOProtos.Rpc.IInitializationEvent|null);
            public scan_recorder_start_event?: (POGOProtos.Rpc.IScanRecorderStartEvent|null);
            public scan_recorder_stop_event?: (POGOProtos.Rpc.IScanRecorderStopEvent|null);
            public scan_sqc_run_event?: (POGOProtos.Rpc.IScanSQCRunEvent|null);
            public scan_sqc_done_event?: (POGOProtos.Rpc.IScanSQCDoneEvent|null);
            public scan_error_event?: (POGOProtos.Rpc.IScanErrorEvent|null);
            public scan_archive_builder_get_next_chunk_event?: (POGOProtos.Rpc.IScanArchiveBuilderGetNextChunkEvent|null);
            public scan_archive_builder_cancel_event?: (POGOProtos.Rpc.IScanArchiveBuilderCancelEvent|null);
            public vps_localization_started_event?: (POGOProtos.Rpc.IVpsLocalizationStartedEvent|null);
            public vps_localization_success_event?: (POGOProtos.Rpc.IVpsLocalizationSuccessEvent|null);
            public vps_session_ended_event?: (POGOProtos.Rpc.IVpsSessionEndedEvent|null);
            public ar_session_start_event?: (POGOProtos.Rpc.IArSessionStartEvent|null);
            public depth_start_event?: (POGOProtos.Rpc.IDepthStartEvent|null);
            public depth_stop_event?: (POGOProtos.Rpc.IDepthStopEvent|null);
            public semantics_start_event?: (POGOProtos.Rpc.ISemanticsStartEvent|null);
            public semantics_stop_event?: (POGOProtos.Rpc.ISemanticsStopEvent|null);
            public meshing_start_event?: (POGOProtos.Rpc.IMeshingStartEvent|null);
            public meshing_stop_event?: (POGOProtos.Rpc.IMeshingStopEvent|null);
            public object_detection_start_event?: (POGOProtos.Rpc.IObjectDetectionStartEvent|null);
            public object_detection_stop_event?: (POGOProtos.Rpc.IObjectDetectionStopEvent|null);
            public wps_start_event?: (POGOProtos.Rpc.IWpsStartEvent|null);
            public wps_available_event?: (POGOProtos.Rpc.IWpsAvailableEvent|null);
            public wps_stop_event?: (POGOProtos.Rpc.IWpsStopEvent|null);
            public ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            public developer_key: string;
            public timestamp_ms: (number|Long);
            public TelemetryEvent?: ("initialization_event"|"scan_recorder_start_event"|"scan_recorder_stop_event"|"scan_sqc_run_event"|"scan_sqc_done_event"|"scan_error_event"|"scan_archive_builder_get_next_chunk_event"|"scan_archive_builder_cancel_event"|"vps_localization_started_event"|"vps_localization_success_event"|"vps_session_ended_event"|"ar_session_start_event"|"depth_start_event"|"depth_stop_event"|"semantics_start_event"|"semantics_stop_event"|"meshing_start_event"|"meshing_stop_event"|"object_detection_start_event"|"object_detection_stop_event"|"wps_start_event"|"wps_available_event"|"wps_stop_event");
            public static encode(message: POGOProtos.Rpc.IArdkNextTelemetryOmniProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ArdkNextTelemetryOmniProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ArdkNextTelemetryOmniProto;
            public static toObject(message: POGOProtos.Rpc.ArdkNextTelemetryOmniProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssertionFailed {
            timestamp_ms?: (number|Long|null);
            message?: (string|null);
        }

        class AssertionFailed implements IAssertionFailed {
            constructor(properties?: POGOProtos.Rpc.IAssertionFailed);
            public timestamp_ms: (number|Long);
            public message: string;
            public static encode(message: POGOProtos.Rpc.IAssertionFailed, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssertionFailed;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssertionFailed;
            public static toObject(message: POGOProtos.Rpc.AssertionFailed, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetBundleDownloadTelemetry {
            asset_event_id?: (POGOProtos.Rpc.AssetTelemetryIds|null);
            bundle_name?: (string|null);
            size?: (number|null);
        }

        class AssetBundleDownloadTelemetry implements IAssetBundleDownloadTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAssetBundleDownloadTelemetry);
            public asset_event_id: POGOProtos.Rpc.AssetTelemetryIds;
            public bundle_name: string;
            public size: number;
            public static encode(message: POGOProtos.Rpc.IAssetBundleDownloadTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetBundleDownloadTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetBundleDownloadTelemetry;
            public static toObject(message: POGOProtos.Rpc.AssetBundleDownloadTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetDigestEntryProto {
            asset_id?: (string|null);
            bundle_name?: (string|null);
            version?: (number|Long|null);
            checksum?: (number|null);
            size?: (number|null);
            key?: (Uint8Array|null);
        }

        class AssetDigestEntryProto implements IAssetDigestEntryProto {
            constructor(properties?: POGOProtos.Rpc.IAssetDigestEntryProto);
            public asset_id: string;
            public bundle_name: string;
            public version: (number|Long);
            public checksum: number;
            public size: number;
            public key: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAssetDigestEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetDigestEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetDigestEntryProto;
            public static toObject(message: POGOProtos.Rpc.AssetDigestEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetDigestOutProto {
            digest?: (POGOProtos.Rpc.IAssetDigestEntryProto[]|null);
            timestamp?: (number|Long|null);
            result?: (POGOProtos.Rpc.AssetDigestOutProto.Result|null);
            page_offset?: (number|null);
        }

        class AssetDigestOutProto implements IAssetDigestOutProto {
            constructor(properties?: POGOProtos.Rpc.IAssetDigestOutProto);
            public digest: POGOProtos.Rpc.IAssetDigestEntryProto[];
            public timestamp: (number|Long);
            public result: POGOProtos.Rpc.AssetDigestOutProto.Result;
            public page_offset: number;
            public static encode(message: POGOProtos.Rpc.IAssetDigestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetDigestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetDigestOutProto;
            public static toObject(message: POGOProtos.Rpc.AssetDigestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AssetDigestOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                PAGE = 2,
                RETRY = 3
            }
        }

        interface IAssetDigestRequestProto {
            platform?: (POGOProtos.Rpc.Platform|null);
            device_manufacturer?: (string|null);
            device_model?: (string|null);
            locale?: (string|null);
            app_version?: (number|null);
            paginate?: (boolean|null);
            page_offset?: (number|null);
            page_timestamp?: (number|Long|null);
        }

        class AssetDigestRequestProto implements IAssetDigestRequestProto {
            constructor(properties?: POGOProtos.Rpc.IAssetDigestRequestProto);
            public platform: POGOProtos.Rpc.Platform;
            public device_manufacturer: string;
            public device_model: string;
            public locale: string;
            public app_version: number;
            public paginate: boolean;
            public page_offset: number;
            public page_timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IAssetDigestRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetDigestRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetDigestRequestProto;
            public static toObject(message: POGOProtos.Rpc.AssetDigestRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetPoiDownloadTelemetry {
            asset_event_id?: (POGOProtos.Rpc.AssetTelemetryIds|null);
            fort_id?: (string|null);
            size?: (number|null);
        }

        class AssetPoiDownloadTelemetry implements IAssetPoiDownloadTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAssetPoiDownloadTelemetry);
            public asset_event_id: POGOProtos.Rpc.AssetTelemetryIds;
            public fort_id: string;
            public size: number;
            public static encode(message: POGOProtos.Rpc.IAssetPoiDownloadTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetPoiDownloadTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetPoiDownloadTelemetry;
            public static toObject(message: POGOProtos.Rpc.AssetPoiDownloadTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetRefreshProto {
            string_refresh_seconds?: (number|null);
        }

        class AssetRefreshProto implements IAssetRefreshProto {
            constructor(properties?: POGOProtos.Rpc.IAssetRefreshProto);
            public string_refresh_seconds: number;
            public static encode(message: POGOProtos.Rpc.IAssetRefreshProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetRefreshProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetRefreshProto;
            public static toObject(message: POGOProtos.Rpc.AssetRefreshProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetRefreshTelemetry {
            timestamp?: (number|Long|null);
        }

        class AssetRefreshTelemetry implements IAssetRefreshTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAssetRefreshTelemetry);
            public timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IAssetRefreshTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetRefreshTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetRefreshTelemetry;
            public static toObject(message: POGOProtos.Rpc.AssetRefreshTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetStreamCacheCulledTelemetry {
            asset_event_id?: (POGOProtos.Rpc.AssetTelemetryIds|null);
            space_released?: (number|null);
        }

        class AssetStreamCacheCulledTelemetry implements IAssetStreamCacheCulledTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAssetStreamCacheCulledTelemetry);
            public asset_event_id: POGOProtos.Rpc.AssetTelemetryIds;
            public space_released: number;
            public static encode(message: POGOProtos.Rpc.IAssetStreamCacheCulledTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetStreamCacheCulledTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetStreamCacheCulledTelemetry;
            public static toObject(message: POGOProtos.Rpc.AssetStreamCacheCulledTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetStreamDownloadTelemetry {
            asset_event_id?: (POGOProtos.Rpc.AssetTelemetryIds|null);
            url?: (string|null);
            size?: (number|null);
        }

        class AssetStreamDownloadTelemetry implements IAssetStreamDownloadTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAssetStreamDownloadTelemetry);
            public asset_event_id: POGOProtos.Rpc.AssetTelemetryIds;
            public url: string;
            public size: number;
            public static encode(message: POGOProtos.Rpc.IAssetStreamDownloadTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetStreamDownloadTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetStreamDownloadTelemetry;
            public static toObject(message: POGOProtos.Rpc.AssetStreamDownloadTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAssetVersionOutProto {
            response?: (POGOProtos.Rpc.AssetVersionOutProto.IAssetVersionResponseProto[]|null);
        }

        class AssetVersionOutProto implements IAssetVersionOutProto {
            constructor(properties?: POGOProtos.Rpc.IAssetVersionOutProto);
            public response: POGOProtos.Rpc.AssetVersionOutProto.IAssetVersionResponseProto[];
            public static encode(message: POGOProtos.Rpc.IAssetVersionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetVersionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetVersionOutProto;
            public static toObject(message: POGOProtos.Rpc.AssetVersionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AssetVersionOutProto {

            enum Result {
                UNSET = 0,
                ERROR = 1,
                VALID = 2,
                EXPIRED = 3
            }

            interface IAssetVersionResponseProto {
                result?: (POGOProtos.Rpc.AssetVersionOutProto.Result|null);
                digest?: (POGOProtos.Rpc.IAssetDigestEntryProto|null);
                url?: (string|null);
            }

            class AssetVersionResponseProto implements IAssetVersionResponseProto {
                constructor(properties?: POGOProtos.Rpc.AssetVersionOutProto.IAssetVersionResponseProto);
                public result: POGOProtos.Rpc.AssetVersionOutProto.Result;
                public digest?: (POGOProtos.Rpc.IAssetDigestEntryProto|null);
                public url: string;
                public static encode(message: POGOProtos.Rpc.AssetVersionOutProto.IAssetVersionResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetVersionOutProto.AssetVersionResponseProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetVersionOutProto.AssetVersionResponseProto;
                public static toObject(message: POGOProtos.Rpc.AssetVersionOutProto.AssetVersionResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IAssetVersionProto {
            app_version?: (number|null);
            request?: (POGOProtos.Rpc.AssetVersionProto.IAssetVersionRequestProto[]|null);
        }

        class AssetVersionProto implements IAssetVersionProto {
            constructor(properties?: POGOProtos.Rpc.IAssetVersionProto);
            public app_version: number;
            public request: POGOProtos.Rpc.AssetVersionProto.IAssetVersionRequestProto[];
            public static encode(message: POGOProtos.Rpc.IAssetVersionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetVersionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetVersionProto;
            public static toObject(message: POGOProtos.Rpc.AssetVersionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AssetVersionProto {

            interface IAssetVersionRequestProto {
                asset_id?: (string|null);
                checksum?: (number|null);
            }

            class AssetVersionRequestProto implements IAssetVersionRequestProto {
                constructor(properties?: POGOProtos.Rpc.AssetVersionProto.IAssetVersionRequestProto);
                public asset_id: string;
                public checksum: number;
                public static encode(message: POGOProtos.Rpc.AssetVersionProto.IAssetVersionRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AssetVersionProto.AssetVersionRequestProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AssetVersionProto.AssetVersionRequestProto;
                public static toObject(message: POGOProtos.Rpc.AssetVersionProto.AssetVersionRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IAttackDefenseBonusAttributeSettingsProto {
            combat_types?: (POGOProtos.Rpc.CombatType[]|null);
            attack_multiplier?: (number|null);
            defense_multiplier?: (number|null);
        }

        class AttackDefenseBonusAttributeSettingsProto implements IAttackDefenseBonusAttributeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAttackDefenseBonusAttributeSettingsProto);
            public combat_types: POGOProtos.Rpc.CombatType[];
            public attack_multiplier: number;
            public defense_multiplier: number;
            public static encode(message: POGOProtos.Rpc.IAttackDefenseBonusAttributeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackDefenseBonusAttributeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackDefenseBonusAttributeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AttackDefenseBonusAttributeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttackDefenseBonusSettingsProto {
            attributes?: (POGOProtos.Rpc.IAttackDefenseBonusAttributeSettingsProto[]|null);
        }

        class AttackDefenseBonusSettingsProto implements IAttackDefenseBonusSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAttackDefenseBonusSettingsProto);
            public attributes: POGOProtos.Rpc.IAttackDefenseBonusAttributeSettingsProto[];
            public static encode(message: POGOProtos.Rpc.IAttackDefenseBonusSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackDefenseBonusSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackDefenseBonusSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AttackDefenseBonusSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttackGymOutProto {
            result?: (POGOProtos.Rpc.AttackGymOutProto.Result|null);
            battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            battle_id?: (string|null);
            active_defender?: (POGOProtos.Rpc.IPokemonInfo|null);
            active_attacker?: (POGOProtos.Rpc.IPokemonInfo|null);
            battle_update?: (POGOProtos.Rpc.IBattleUpdateProto|null);
        }

        class AttackGymOutProto implements IAttackGymOutProto {
            constructor(properties?: POGOProtos.Rpc.IAttackGymOutProto);
            public result: POGOProtos.Rpc.AttackGymOutProto.Result;
            public battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            public battle_id: string;
            public active_defender?: (POGOProtos.Rpc.IPokemonInfo|null);
            public active_attacker?: (POGOProtos.Rpc.IPokemonInfo|null);
            public battle_update?: (POGOProtos.Rpc.IBattleUpdateProto|null);
            public static encode(message: POGOProtos.Rpc.IAttackGymOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackGymOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackGymOutProto;
            public static toObject(message: POGOProtos.Rpc.AttackGymOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AttackGymOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_ATTACK_ACTIONS = 2,
                ERROR_NOT_IN_RANGE = 3
            }
        }

        interface IAttackGymProto {
            gym_id?: (string|null);
            battle_id?: (string|null);
            attacker_actions?: (POGOProtos.Rpc.IBattleActionProto[]|null);
            last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProto|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class AttackGymProto implements IAttackGymProto {
            constructor(properties?: POGOProtos.Rpc.IAttackGymProto);
            public gym_id: string;
            public battle_id: string;
            public attacker_actions: POGOProtos.Rpc.IBattleActionProto[];
            public last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProto|null);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IAttackGymProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackGymProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackGymProto;
            public static toObject(message: POGOProtos.Rpc.AttackGymProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttackRaidBattleOutProto {
            result?: (POGOProtos.Rpc.AttackRaidBattleOutProto.Result|null);
            battle_update?: (POGOProtos.Rpc.IBattleUpdateProto|null);
            sponsored_gift?: (POGOProtos.Rpc.IAdDetails|null);
            ad?: (POGOProtos.Rpc.IAdProto|null);
        }

        class AttackRaidBattleOutProto implements IAttackRaidBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.IAttackRaidBattleOutProto);
            public result: POGOProtos.Rpc.AttackRaidBattleOutProto.Result;
            public battle_update?: (POGOProtos.Rpc.IBattleUpdateProto|null);
            public sponsored_gift?: (POGOProtos.Rpc.IAdDetails|null);
            public ad?: (POGOProtos.Rpc.IAdProto|null);
            public static encode(message: POGOProtos.Rpc.IAttackRaidBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackRaidBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackRaidBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.AttackRaidBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AttackRaidBattleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_GYM_NOT_FOUND = 2,
                ERROR_BATTLE_NOT_FOUND = 3,
                ERROR_INVALID_ATTACK_ACTIONS = 4,
                ERROR_NOT_PART_OF_BATTLE = 5,
                ERROR_BATTLE_ID_NOT_RAID = 6
            }
        }

        interface IAttackRaidBattleProto {
            gym_id?: (string|null);
            battle_id?: (string|null);
            attacker_actions?: (POGOProtos.Rpc.IBattleActionProto[]|null);
            last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProto|null);
            timestamp_ms?: (number|Long|null);
            ad_targeting_info?: (POGOProtos.Rpc.IAdTargetingInfoProto|null);
        }

        class AttackRaidBattleProto implements IAttackRaidBattleProto {
            constructor(properties?: POGOProtos.Rpc.IAttackRaidBattleProto);
            public gym_id: string;
            public battle_id: string;
            public attacker_actions: POGOProtos.Rpc.IBattleActionProto[];
            public last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProto|null);
            public timestamp_ms: (number|Long);
            public ad_targeting_info?: (POGOProtos.Rpc.IAdTargetingInfoProto|null);
            public static encode(message: POGOProtos.Rpc.IAttackRaidBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackRaidBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackRaidBattleProto;
            public static toObject(message: POGOProtos.Rpc.AttackRaidBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttackRaidData {
            attacker_actions?: (POGOProtos.Rpc.IBattleActionProtoLog[]|null);
            last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProtoLog|null);
            timestamp_offset_ms?: (number|null);
            rpc_id?: (number|null);
        }

        class AttackRaidData implements IAttackRaidData {
            constructor(properties?: POGOProtos.Rpc.IAttackRaidData);
            public attacker_actions: POGOProtos.Rpc.IBattleActionProtoLog[];
            public last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProtoLog|null);
            public timestamp_offset_ms: number;
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IAttackRaidData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackRaidData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackRaidData;
            public static toObject(message: POGOProtos.Rpc.AttackRaidData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttackRaidResponseData {
            result?: (POGOProtos.Rpc.AttackRaidBattleOutProto.Result|null);
            state?: (POGOProtos.Rpc.BattleLogProto.State|null);
            server_offset_ms?: (number|null);
            battle_actions?: (POGOProtos.Rpc.IBattleActionProtoLog[]|null);
            battle_start_offset_ms?: (number|null);
            battle_end_offset_ms?: (number|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class AttackRaidResponseData implements IAttackRaidResponseData {
            constructor(properties?: POGOProtos.Rpc.IAttackRaidResponseData);
            public result: POGOProtos.Rpc.AttackRaidBattleOutProto.Result;
            public state: POGOProtos.Rpc.BattleLogProto.State;
            public server_offset_ms: number;
            public battle_actions: POGOProtos.Rpc.IBattleActionProtoLog[];
            public battle_start_offset_ms: number;
            public battle_end_offset_ms: number;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.IAttackRaidResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttackRaidResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttackRaidResponseData;
            public static toObject(message: POGOProtos.Rpc.AttackRaidResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttractedPokemonClientProto {
            context?: (POGOProtos.Rpc.AttractedPokemonContext|null);
            pokemon_type_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            lat?: (number|null);
            lng?: (number|null);
            encounter_location?: (string|null);
            encounter_id?: (number|Long|null);
            disappear_time_ms?: (number|Long|null);
        }

        class AttractedPokemonClientProto implements IAttractedPokemonClientProto {
            constructor(properties?: POGOProtos.Rpc.IAttractedPokemonClientProto);
            public context: POGOProtos.Rpc.AttractedPokemonContext;
            public pokemon_type_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public lat: number;
            public lng: number;
            public encounter_location: string;
            public encounter_id: (number|Long);
            public disappear_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IAttractedPokemonClientProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttractedPokemonClientProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttractedPokemonClientProto;
            public static toObject(message: POGOProtos.Rpc.AttractedPokemonClientProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAttractedPokemonEncounterOutProto {
            result?: (POGOProtos.Rpc.AttractedPokemonEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class AttractedPokemonEncounterOutProto implements IAttractedPokemonEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IAttractedPokemonEncounterOutProto);
            public result: POGOProtos.Rpc.AttractedPokemonEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IAttractedPokemonEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttractedPokemonEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttractedPokemonEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.AttractedPokemonEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AttractedPokemonEncounterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ENCOUNTER_NOT_AVAILABLE = 2,
                ERROR_POKEMON_INVENTORY_FULL = 3
            }
        }

        interface IAttractedPokemonEncounterProto {
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
        }

        class AttractedPokemonEncounterProto implements IAttractedPokemonEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IAttractedPokemonEncounterProto);
            public encounter_id: (number|Long);
            public encounter_location: string;
            public static encode(message: POGOProtos.Rpc.IAttractedPokemonEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AttractedPokemonEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AttractedPokemonEncounterProto;
            public static toObject(message: POGOProtos.Rpc.AttractedPokemonEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAuthBackgroundToken {
            token?: (Uint8Array|null);
            expiration_time?: (number|Long|null);
            iv?: (Uint8Array|null);
        }

        class AuthBackgroundToken implements IAuthBackgroundToken {
            constructor(properties?: POGOProtos.Rpc.IAuthBackgroundToken);
            public token: Uint8Array;
            public expiration_time: (number|Long);
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAuthBackgroundToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AuthBackgroundToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AuthBackgroundToken;
            public static toObject(message: POGOProtos.Rpc.AuthBackgroundToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAuthRegisterBackgroundDeviceActionProto {
            device_type?: (string|null);
            device_id?: (string|null);
        }

        class AuthRegisterBackgroundDeviceActionProto implements IAuthRegisterBackgroundDeviceActionProto {
            constructor(properties?: POGOProtos.Rpc.IAuthRegisterBackgroundDeviceActionProto);
            public device_type: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IAuthRegisterBackgroundDeviceActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AuthRegisterBackgroundDeviceActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AuthRegisterBackgroundDeviceActionProto;
            public static toObject(message: POGOProtos.Rpc.AuthRegisterBackgroundDeviceActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAuthRegisterBackgroundDeviceResponseProto {
            status?: (POGOProtos.Rpc.AuthRegisterBackgroundDeviceResponseProto.Status|null);
            token?: (POGOProtos.Rpc.IAuthBackgroundToken|null);
        }

        class AuthRegisterBackgroundDeviceResponseProto implements IAuthRegisterBackgroundDeviceResponseProto {
            constructor(properties?: POGOProtos.Rpc.IAuthRegisterBackgroundDeviceResponseProto);
            public status: POGOProtos.Rpc.AuthRegisterBackgroundDeviceResponseProto.Status;
            public token?: (POGOProtos.Rpc.IAuthBackgroundToken|null);
            public static encode(message: POGOProtos.Rpc.IAuthRegisterBackgroundDeviceResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AuthRegisterBackgroundDeviceResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AuthRegisterBackgroundDeviceResponseProto;
            public static toObject(message: POGOProtos.Rpc.AuthRegisterBackgroundDeviceResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AuthRegisterBackgroundDeviceResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IAuthenticateAppleSignInRequestProto {
            apple_id_token?: (Uint8Array|null);
            auth_code?: (Uint8Array|null);
        }

        class AuthenticateAppleSignInRequestProto implements IAuthenticateAppleSignInRequestProto {
            constructor(properties?: POGOProtos.Rpc.IAuthenticateAppleSignInRequestProto);
            public apple_id_token: Uint8Array;
            public auth_code: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAuthenticateAppleSignInRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AuthenticateAppleSignInRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AuthenticateAppleSignInRequestProto;
            public static toObject(message: POGOProtos.Rpc.AuthenticateAppleSignInRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAuthenticateAppleSignInResponseProto {
            status?: (POGOProtos.Rpc.AuthenticateAppleSignInResponseProto.Status|null);
            nia_apple_auth_token?: (Uint8Array|null);
        }

        class AuthenticateAppleSignInResponseProto implements IAuthenticateAppleSignInResponseProto {
            constructor(properties?: POGOProtos.Rpc.IAuthenticateAppleSignInResponseProto);
            public status: POGOProtos.Rpc.AuthenticateAppleSignInResponseProto.Status;
            public nia_apple_auth_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IAuthenticateAppleSignInResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AuthenticateAppleSignInResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AuthenticateAppleSignInResponseProto;
            public static toObject(message: POGOProtos.Rpc.AuthenticateAppleSignInResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AuthenticateAppleSignInResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_AUTH = 2,
                SERVER_ERROR = 3
            }
        }

        interface IAvatarArticleProto {
            article_id?: (string|null);
            color?: (number|null);
            slot_id?: (number|null);
        }

        class AvatarArticleProto implements IAvatarArticleProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarArticleProto);
            public article_id: string;
            public color: number;
            public slot_id: number;
            public static encode(message: POGOProtos.Rpc.IAvatarArticleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarArticleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarArticleProto;
            public static toObject(message: POGOProtos.Rpc.AvatarArticleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarCustomizationProto {
            enabled?: (boolean|null);
            avatar_type?: (POGOProtos.Rpc.PlayerAvatarType|null);
            slot?: (POGOProtos.Rpc.AvatarCustomizationProto.Slot[]|null);
            bundle_name?: (string|null);
            asset_name?: (string|null);
            group_name?: (string|null);
            sort_order?: (number|null);
            unlock_type?: (POGOProtos.Rpc.AvatarCustomizationProto.AvatarCustomizationUnlockType|null);
            promo_type?: (POGOProtos.Rpc.AvatarCustomizationProto.AvatarCustomizationPromoType[]|null);
            unlock_badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            iap_sku?: (string|null);
            unlock_badge_level?: (number|null);
            icon_name?: (string|null);
            unlock_player_level?: (number|null);
            set_name?: (string|null);
            set_prime_item?: (boolean|null);
            incompatible_bundle_names?: (string[]|null);
            set_names?: (string[]|null);
        }

        class AvatarCustomizationProto implements IAvatarCustomizationProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarCustomizationProto);
            public enabled: boolean;
            public avatar_type: POGOProtos.Rpc.PlayerAvatarType;
            public slot: POGOProtos.Rpc.AvatarCustomizationProto.Slot[];
            public bundle_name: string;
            public asset_name: string;
            public group_name: string;
            public sort_order: number;
            public unlock_type: POGOProtos.Rpc.AvatarCustomizationProto.AvatarCustomizationUnlockType;
            public promo_type: POGOProtos.Rpc.AvatarCustomizationProto.AvatarCustomizationPromoType[];
            public unlock_badge_type: POGOProtos.Rpc.HoloBadgeType;
            public iap_sku: string;
            public unlock_badge_level: number;
            public icon_name: string;
            public unlock_player_level: number;
            public set_name: string;
            public set_prime_item: boolean;
            public incompatible_bundle_names: string[];
            public set_names: string[];
            public static encode(message: POGOProtos.Rpc.IAvatarCustomizationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarCustomizationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarCustomizationProto;
            public static toObject(message: POGOProtos.Rpc.AvatarCustomizationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AvatarCustomizationProto {

            enum AvatarCustomizationPromoType {
                UNSET_PROMO_TYPE = 0,
                SALE = 1,
                FEATURED = 2
            }

            enum AvatarCustomizationUnlockType {
                UNSET_UNLOCK_TYPE = 0,
                DEFAULT = 1,
                MEDAL_REWARD = 2,
                IAP_CLOTHING = 3,
                LEVEL_REWARD = 4,
                COMBAT_RANK_REWARD = 5
            }

            enum Slot {
                UNSET_SLOT = 0,
                HAIR = 1,
                SHIRT = 2,
                PANTS = 3,
                HAT = 4,
                SHOES = 5,
                EYES = 6,
                BACKPACK = 7,
                GLOVES = 8,
                SOCKS = 9,
                BELT = 10,
                GLASSES = 11,
                NECKLACE = 12,
                SKIN = 13,
                POSE = 14,
                FACE = 15,
                PROP = 16
            }
        }

        interface IAvatarCustomizationTelemetry {
            avatar_customization_click_id?: (POGOProtos.Rpc.AvatarCustomizationTelemetryIds|null);
            asset_name?: (string|null);
            sku?: (string|null);
            has_enough_coins?: (boolean|null);
            group_name?: (string|null);
            color_choice_id?: (string|null);
        }

        class AvatarCustomizationTelemetry implements IAvatarCustomizationTelemetry {
            constructor(properties?: POGOProtos.Rpc.IAvatarCustomizationTelemetry);
            public avatar_customization_click_id: POGOProtos.Rpc.AvatarCustomizationTelemetryIds;
            public asset_name: string;
            public sku: string;
            public has_enough_coins: boolean;
            public group_name: string;
            public color_choice_id: string;
            public static encode(message: POGOProtos.Rpc.IAvatarCustomizationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarCustomizationTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarCustomizationTelemetry;
            public static toObject(message: POGOProtos.Rpc.AvatarCustomizationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarGroupSettingsProto {
            group?: (POGOProtos.Rpc.AvatarGroupSettingsProto.IAvatarGroupProto[]|null);
        }

        class AvatarGroupSettingsProto implements IAvatarGroupSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarGroupSettingsProto);
            public group: POGOProtos.Rpc.AvatarGroupSettingsProto.IAvatarGroupProto[];
            public static encode(message: POGOProtos.Rpc.IAvatarGroupSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarGroupSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarGroupSettingsProto;
            public static toObject(message: POGOProtos.Rpc.AvatarGroupSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AvatarGroupSettingsProto {

            interface IAvatarGroupProto {
                name?: (string|null);
                order?: (number|null);
                new_tag_enabled?: (boolean|null);
            }

            class AvatarGroupProto implements IAvatarGroupProto {
                constructor(properties?: POGOProtos.Rpc.AvatarGroupSettingsProto.IAvatarGroupProto);
                public name: string;
                public order: number;
                public new_tag_enabled: boolean;
                public static encode(message: POGOProtos.Rpc.AvatarGroupSettingsProto.IAvatarGroupProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarGroupSettingsProto.AvatarGroupProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarGroupSettingsProto.AvatarGroupProto;
                public static toObject(message: POGOProtos.Rpc.AvatarGroupSettingsProto.AvatarGroupProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IAvatarItemBadgeRewardDisplayProto {
            display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            link?: (POGOProtos.Rpc.IAvatarStoreLinkProto|null);
            badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            badge_level?: (number|null);
        }

        class AvatarItemBadgeRewardDisplayProto implements IAvatarItemBadgeRewardDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarItemBadgeRewardDisplayProto);
            public display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            public link?: (POGOProtos.Rpc.IAvatarStoreLinkProto|null);
            public badge_type: POGOProtos.Rpc.HoloBadgeType;
            public badge_level: number;
            public static encode(message: POGOProtos.Rpc.IAvatarItemBadgeRewardDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarItemBadgeRewardDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarItemBadgeRewardDisplayProto;
            public static toObject(message: POGOProtos.Rpc.AvatarItemBadgeRewardDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarItemDisplayProto {
            icon_address?: (string|null);
            display_string_id?: (string|null);
        }

        class AvatarItemDisplayProto implements IAvatarItemDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarItemDisplayProto);
            public icon_address: string;
            public display_string_id: string;
            public static encode(message: POGOProtos.Rpc.IAvatarItemDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarItemDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarItemDisplayProto;
            public static toObject(message: POGOProtos.Rpc.AvatarItemDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarItemProto {
            avatar_template_id?: (string|null);
            new_timestamp_ms?: (number|Long|null);
            viewed?: (boolean|null);
        }

        class AvatarItemProto implements IAvatarItemProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarItemProto);
            public avatar_template_id: string;
            public new_timestamp_ms: (number|Long);
            public viewed: boolean;
            public static encode(message: POGOProtos.Rpc.IAvatarItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarItemProto;
            public static toObject(message: POGOProtos.Rpc.AvatarItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarLockProto {
            player_level_lock?: (POGOProtos.Rpc.IPlayerLevelAvatarLockProto|null);
            badge_level_lock?: (POGOProtos.Rpc.IBadgeLevelAvatarLockProto|null);
            is_locked?: (boolean|null);
        }

        class AvatarLockProto implements IAvatarLockProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarLockProto);
            public player_level_lock?: (POGOProtos.Rpc.IPlayerLevelAvatarLockProto|null);
            public badge_level_lock?: (POGOProtos.Rpc.IBadgeLevelAvatarLockProto|null);
            public is_locked: boolean;
            public Lock?: ("player_level_lock"|"badge_level_lock");
            public static encode(message: POGOProtos.Rpc.IAvatarLockProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarLockProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarLockProto;
            public static toObject(message: POGOProtos.Rpc.AvatarLockProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreFilterProto {
            host_category?: (string|null);
            filter_key?: (string|null);
            localization_key?: (string|null);
            icon?: (string|null);
            is_suggested?: (boolean|null);
        }

        class AvatarStoreFilterProto implements IAvatarStoreFilterProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreFilterProto);
            public host_category: string;
            public filter_key: string;
            public localization_key: string;
            public icon: string;
            public is_suggested: boolean;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreFilterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreFilterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreFilterProto;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreFilterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreFooter {
            icon_address?: (string|null);
            text_key?: (string|null);
        }

        class AvatarStoreFooter implements IAvatarStoreFooter {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreFooter);
            public icon_address: string;
            public text_key: string;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreFooter, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreFooter;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreFooter;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreFooter, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreFooterEnabledProto {
            enabled?: (boolean|null);
        }

        class AvatarStoreFooterEnabledProto implements IAvatarStoreFooterEnabledProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreFooterEnabledProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreFooterEnabledProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreFooterEnabledProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreFooterEnabledProto;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreFooterEnabledProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreItemProto {
            article_id?: (string|null);
            iap_sku?: (string|null);
            is_owned?: (boolean|null);
            is_purchasable?: (boolean|null);
            is_new?: (boolean|null);
            slot?: (POGOProtos.Rpc.AvatarSlot|null);
        }

        class AvatarStoreItemProto implements IAvatarStoreItemProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreItemProto);
            public article_id: string;
            public iap_sku: string;
            public is_owned: boolean;
            public is_purchasable: boolean;
            public is_new: boolean;
            public slot: POGOProtos.Rpc.AvatarSlot;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreItemProto;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreItemSubcategory {
            subcategory?: (string|null);
            sort_order?: (number|null);
        }

        class AvatarStoreItemSubcategory implements IAvatarStoreItemSubcategory {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreItemSubcategory);
            public subcategory: string;
            public sort_order: number;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreItemSubcategory, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreItemSubcategory;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreItemSubcategory;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreItemSubcategory, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreLinkProto {
            article_id?: (string|null);
            group_name?: (string|null);
        }

        class AvatarStoreLinkProto implements IAvatarStoreLinkProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreLinkProto);
            public article_id: string;
            public group_name: string;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreLinkProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreLinkProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreLinkProto;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreLinkProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreListingProto {
            items?: (POGOProtos.Rpc.IAvatarStoreItemProto[]|null);
            sort_order?: (number|null);
            icon_address?: (string|null);
            display_name_string_id?: (string|null);
            is_set?: (boolean|null);
            is_recommended?: (boolean|null);
            display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            subcategories?: (POGOProtos.Rpc.IAvatarStoreItemSubcategory[]|null);
            displays?: (POGOProtos.Rpc.IAvatarItemDisplayProto[]|null);
            footer?: (POGOProtos.Rpc.IAvatarStoreFooter|null);
            lock?: (POGOProtos.Rpc.IAvatarLockProto|null);
            group_name?: (string|null);
        }

        class AvatarStoreListingProto implements IAvatarStoreListingProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreListingProto);
            public items: POGOProtos.Rpc.IAvatarStoreItemProto[];
            public sort_order: number;
            public icon_address: string;
            public display_name_string_id: string;
            public is_set: boolean;
            public is_recommended: boolean;
            public display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            public subcategories: POGOProtos.Rpc.IAvatarStoreItemSubcategory[];
            public displays: POGOProtos.Rpc.IAvatarItemDisplayProto[];
            public footer?: (POGOProtos.Rpc.IAvatarStoreFooter|null);
            public lock?: (POGOProtos.Rpc.IAvatarLockProto|null);
            public group_name: string;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreListingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreListingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreListingProto;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreListingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAvatarStoreSubcategoryFilteringEnabledProto {
            enabled?: (boolean|null);
        }

        class AvatarStoreSubcategoryFilteringEnabledProto implements IAvatarStoreSubcategoryFilteringEnabledProto {
            constructor(properties?: POGOProtos.Rpc.IAvatarStoreSubcategoryFilteringEnabledProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IAvatarStoreSubcategoryFilteringEnabledProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AvatarStoreSubcategoryFilteringEnabledProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AvatarStoreSubcategoryFilteringEnabledProto;
            public static toObject(message: POGOProtos.Rpc.AvatarStoreSubcategoryFilteringEnabledProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAwardFreeRaidTicketOutProto {
            result?: (POGOProtos.Rpc.AwardFreeRaidTicketOutProto.Result|null);
        }

        class AwardFreeRaidTicketOutProto implements IAwardFreeRaidTicketOutProto {
            constructor(properties?: POGOProtos.Rpc.IAwardFreeRaidTicketOutProto);
            public result: POGOProtos.Rpc.AwardFreeRaidTicketOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IAwardFreeRaidTicketOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardFreeRaidTicketOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardFreeRaidTicketOutProto;
            public static toObject(message: POGOProtos.Rpc.AwardFreeRaidTicketOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AwardFreeRaidTicketOutProto {

            enum Result {
                NO_RESULT_SET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_DOES_NOT_MEET_MIN_LEVEL = 2,
                ERROR_DAILY_TICKET_ALREADY_AWARDED = 3,
                ERROR_PLAYER_OUT_OF_RANGE = 4
            }
        }

        interface IAwardFreeRaidTicketProto {
            gym_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class AwardFreeRaidTicketProto implements IAwardFreeRaidTicketProto {
            constructor(properties?: POGOProtos.Rpc.IAwardFreeRaidTicketProto);
            public gym_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IAwardFreeRaidTicketProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardFreeRaidTicketProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardFreeRaidTicketProto;
            public static toObject(message: POGOProtos.Rpc.AwardFreeRaidTicketProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAwardItemProto {
            item?: (POGOProtos.Rpc.Item|null);
            item_count?: (number|null);
            bonus_count?: (number|null);
        }

        class AwardItemProto implements IAwardItemProto {
            constructor(properties?: POGOProtos.Rpc.IAwardItemProto);
            public item: POGOProtos.Rpc.Item;
            public item_count: number;
            public bonus_count: number;
            public static encode(message: POGOProtos.Rpc.IAwardItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardItemProto;
            public static toObject(message: POGOProtos.Rpc.AwardItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAwardedGymBadge {
            fort_id?: (string|null);
            gym_badge_type?: (POGOProtos.Rpc.GymBadgeType|null);
            score?: (number|null);
            gym_badge_stats?: (POGOProtos.Rpc.IGymBadgeStats|null);
            last_update_timestamp_ms?: (number|Long|null);
            name?: (string|null);
            image_url?: (string|null);
            description?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            last_check_timestamp_ms?: (number|Long|null);
            earned_points?: (number|null);
            progress?: (number|null);
            level_up?: (boolean|null);
            raids?: (POGOProtos.Rpc.IPlayerRaidInfoProto|null);
        }

        class AwardedGymBadge implements IAwardedGymBadge {
            constructor(properties?: POGOProtos.Rpc.IAwardedGymBadge);
            public fort_id: string;
            public gym_badge_type: POGOProtos.Rpc.GymBadgeType;
            public score: number;
            public gym_badge_stats?: (POGOProtos.Rpc.IGymBadgeStats|null);
            public last_update_timestamp_ms: (number|Long);
            public name: string;
            public image_url: string;
            public description: string;
            public latitude: number;
            public longitude: number;
            public last_check_timestamp_ms: (number|Long);
            public earned_points: number;
            public progress: number;
            public level_up: boolean;
            public raids?: (POGOProtos.Rpc.IPlayerRaidInfoProto|null);
            public static encode(message: POGOProtos.Rpc.IAwardedGymBadge, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardedGymBadge;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardedGymBadge;
            public static toObject(message: POGOProtos.Rpc.AwardedGymBadge, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAwardedRouteBadge {
            route_id?: (string|null);
            route_type?: (POGOProtos.Rpc.RouteType|null);
            num_completions?: (number|null);
            last_played_time?: (number|Long|null);
            unique_route_stamp?: (POGOProtos.Rpc.IRouteStamp[]|null);
            route_name?: (string|null);
            route_description?: (string|null);
            route_creator_codename?: (string|null);
            route_image_url?: (string|null);
            route_duration_seconds?: (number|Long|null);
            last_played_waypoints?: (POGOProtos.Rpc.AwardedRouteBadge.IRouteBadgeWaypoint[]|null);
            last_played_duration_seconds?: (number|Long|null);
            weather_condition_on_last_completed_session?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            route_badge_type?: (POGOProtos.Rpc.AwardedRouteBadge.RouteBadgeType|null);
            start_lat?: (number|null);
            start_lng?: (number|null);
            route_distance_meters?: (number|Long|null);
            badge_level?: (POGOProtos.Rpc.RouteBadgeLevel.BadgeLevel|null);
            rated?: (boolean|null);
            can_preview?: (boolean|null);
            hidden?: (boolean|null);
            route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            pins?: (POGOProtos.Rpc.IPinData[]|null);
            favorite?: (boolean|null);
            rating?: (number|null);
        }

        class AwardedRouteBadge implements IAwardedRouteBadge {
            constructor(properties?: POGOProtos.Rpc.IAwardedRouteBadge);
            public route_id: string;
            public route_type: POGOProtos.Rpc.RouteType;
            public num_completions: number;
            public last_played_time: (number|Long);
            public unique_route_stamp: POGOProtos.Rpc.IRouteStamp[];
            public route_name: string;
            public route_description: string;
            public route_creator_codename: string;
            public route_image_url: string;
            public route_duration_seconds: (number|Long);
            public last_played_waypoints: POGOProtos.Rpc.AwardedRouteBadge.IRouteBadgeWaypoint[];
            public last_played_duration_seconds: (number|Long);
            public weather_condition_on_last_completed_session: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public route_badge_type: POGOProtos.Rpc.AwardedRouteBadge.RouteBadgeType;
            public start_lat: number;
            public start_lng: number;
            public route_distance_meters: (number|Long);
            public badge_level: POGOProtos.Rpc.RouteBadgeLevel.BadgeLevel;
            public rated: boolean;
            public can_preview: boolean;
            public hidden: boolean;
            public route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public pins: POGOProtos.Rpc.IPinData[];
            public favorite?: (boolean|null);
            public rating: number;
            public IsFavorite?: "favorite";
            public static encode(message: POGOProtos.Rpc.IAwardedRouteBadge, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardedRouteBadge;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardedRouteBadge;
            public static toObject(message: POGOProtos.Rpc.AwardedRouteBadge, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace AwardedRouteBadge {

            enum RouteBadgeType {
                ROUTE_BADGE_UNSET = 0,
                ROUTE_BADGE_BRONZE = 1,
                ROUTE_BADGE_SILVER = 2,
                ROUTE_BADGE_GOLD = 3
            }

            interface IRouteBadgeWaypoint {
                fort_name?: (string|null);
                image_url?: (string|null);
                last_earned_stamp?: (POGOProtos.Rpc.IRouteStamp|null);
            }

            class RouteBadgeWaypoint implements IRouteBadgeWaypoint {
                constructor(properties?: POGOProtos.Rpc.AwardedRouteBadge.IRouteBadgeWaypoint);
                public fort_name: string;
                public image_url: string;
                public last_earned_stamp?: (POGOProtos.Rpc.IRouteStamp|null);
                public static encode(message: POGOProtos.Rpc.AwardedRouteBadge.IRouteBadgeWaypoint, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardedRouteBadge.RouteBadgeWaypoint;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardedRouteBadge.RouteBadgeWaypoint;
                public static toObject(message: POGOProtos.Rpc.AwardedRouteBadge.RouteBadgeWaypoint, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IAwardedRouteStamp {
            route_stamp?: (POGOProtos.Rpc.IRouteStamp|null);
            acquire_time_ms?: (number|Long|null);
            route_id?: (string|null);
            fort_id?: (string|null);
            stamp_id?: (string|null);
        }

        class AwardedRouteStamp implements IAwardedRouteStamp {
            constructor(properties?: POGOProtos.Rpc.IAwardedRouteStamp);
            public route_stamp?: (POGOProtos.Rpc.IRouteStamp|null);
            public acquire_time_ms: (number|Long);
            public route_id: string;
            public fort_id: string;
            public stamp_id: string;
            public static encode(message: POGOProtos.Rpc.IAwardedRouteStamp, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.AwardedRouteStamp;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.AwardedRouteStamp;
            public static toObject(message: POGOProtos.Rpc.AwardedRouteStamp, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBackgroundModeClientSettingsProto {
            maximum_sample_age_ms?: (number|Long|null);
            accept_manual_fitness_samples?: (boolean|null);
            minimum_location_accuracy_meters?: (number|null);
            background_wake_up_interval_minutes?: (number|null);
            max_upload_size_in_bytes?: (number|null);
            min_enclosing_geofence_radius_m?: (number|null);
            background_token_refresh_interval_s?: (number|Long|null);
            max_session_duration_m?: (number|null);
            min_distance_delta_m?: (number|null);
            min_update_interval_s?: (number|null);
            min_session_reporting_interval_s?: (number|null);
            min_persistent_reporting_interval_s?: (number|null);
            enable_progress_request?: (boolean|null);
            enable_foreground_notification?: (boolean|null);
            proximity_settings?: (POGOProtos.Rpc.BackgroundModeClientSettingsProto.IProximitySettingsProto|null);
        }

        class BackgroundModeClientSettingsProto implements IBackgroundModeClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBackgroundModeClientSettingsProto);
            public maximum_sample_age_ms: (number|Long);
            public accept_manual_fitness_samples: boolean;
            public minimum_location_accuracy_meters: number;
            public background_wake_up_interval_minutes: number;
            public max_upload_size_in_bytes: number;
            public min_enclosing_geofence_radius_m: number;
            public background_token_refresh_interval_s: (number|Long);
            public max_session_duration_m: number;
            public min_distance_delta_m: number;
            public min_update_interval_s: number;
            public min_session_reporting_interval_s: number;
            public min_persistent_reporting_interval_s: number;
            public enable_progress_request: boolean;
            public enable_foreground_notification: boolean;
            public proximity_settings?: (POGOProtos.Rpc.BackgroundModeClientSettingsProto.IProximitySettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IBackgroundModeClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BackgroundModeClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BackgroundModeClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BackgroundModeClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BackgroundModeClientSettingsProto {

            interface IProximitySettingsProto {
                maximum_contact_age_ms?: (number|Long|null);
            }

            class ProximitySettingsProto implements IProximitySettingsProto {
                constructor(properties?: POGOProtos.Rpc.BackgroundModeClientSettingsProto.IProximitySettingsProto);
                public maximum_contact_age_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.BackgroundModeClientSettingsProto.IProximitySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BackgroundModeClientSettingsProto.ProximitySettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BackgroundModeClientSettingsProto.ProximitySettingsProto;
                public static toObject(message: POGOProtos.Rpc.BackgroundModeClientSettingsProto.ProximitySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBackgroundModeGlobalSettingsProto {
            min_player_level_fitness?: (number|null);
            service_prompt_timestamp_ms?: (number|Long|null);
        }

        class BackgroundModeGlobalSettingsProto implements IBackgroundModeGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBackgroundModeGlobalSettingsProto);
            public min_player_level_fitness: number;
            public service_prompt_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBackgroundModeGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BackgroundModeGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BackgroundModeGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BackgroundModeGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBackgroundModeSettingsProto {
            weekly_fitness_goal_level1_distance_km?: (number|null);
            weekly_fitness_goal_level2_distance_km?: (number|null);
            weekly_fitness_goal_level3_distance_km?: (number|null);
            weekly_fitness_goal_level4_distance_km?: (number|null);
            weekly_fitness_goal_reminder_km?: (number|null);
        }

        class BackgroundModeSettingsProto implements IBackgroundModeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBackgroundModeSettingsProto);
            public weekly_fitness_goal_level1_distance_km: number;
            public weekly_fitness_goal_level2_distance_km: number;
            public weekly_fitness_goal_level3_distance_km: number;
            public weekly_fitness_goal_level4_distance_km: number;
            public weekly_fitness_goal_reminder_km: number;
            public static encode(message: POGOProtos.Rpc.IBackgroundModeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BackgroundModeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BackgroundModeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BackgroundModeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBackgroundToken {
            token?: (Uint8Array|null);
            expiration_time?: (number|Long|null);
            iv?: (Uint8Array|null);
        }

        class BackgroundToken implements IBackgroundToken {
            constructor(properties?: POGOProtos.Rpc.IBackgroundToken);
            public token: Uint8Array;
            public expiration_time: (number|Long);
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IBackgroundToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BackgroundToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BackgroundToken;
            public static toObject(message: POGOProtos.Rpc.BackgroundToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBadgeData {
            mini_collection?: (POGOProtos.Rpc.IMiniCollectionBadgeData|null);
            butterfly_collector_data?: (POGOProtos.Rpc.IButterflyCollectorBadgeData|null);
            contest_data?: (POGOProtos.Rpc.IContestBadgeData|null);
            stamp_rally?: (POGOProtos.Rpc.IStampRallyBadgeData|null);
            badge?: (POGOProtos.Rpc.HoloBadgeType|null);
            player_badge_tiers?: (POGOProtos.Rpc.IPlayerBadgeTierProto[]|null);
        }

        class BadgeData implements IBadgeData {
            constructor(properties?: POGOProtos.Rpc.IBadgeData);
            public mini_collection?: (POGOProtos.Rpc.IMiniCollectionBadgeData|null);
            public butterfly_collector_data?: (POGOProtos.Rpc.IButterflyCollectorBadgeData|null);
            public contest_data?: (POGOProtos.Rpc.IContestBadgeData|null);
            public stamp_rally?: (POGOProtos.Rpc.IStampRallyBadgeData|null);
            public badge: POGOProtos.Rpc.HoloBadgeType;
            public player_badge_tiers: POGOProtos.Rpc.IPlayerBadgeTierProto[];
            public Data?: ("mini_collection"|"butterfly_collector_data"|"contest_data"|"stamp_rally");
            public static encode(message: POGOProtos.Rpc.IBadgeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeData;
            public static toObject(message: POGOProtos.Rpc.BadgeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBadgeLevelAvatarLockProto {
            badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            badge_level?: (number|null);
        }

        class BadgeLevelAvatarLockProto implements IBadgeLevelAvatarLockProto {
            constructor(properties?: POGOProtos.Rpc.IBadgeLevelAvatarLockProto);
            public badge_type: POGOProtos.Rpc.HoloBadgeType;
            public badge_level: number;
            public static encode(message: POGOProtos.Rpc.IBadgeLevelAvatarLockProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeLevelAvatarLockProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeLevelAvatarLockProto;
            public static toObject(message: POGOProtos.Rpc.BadgeLevelAvatarLockProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBadgeRewardEncounterRequestProto {
            badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            badge_tier?: (number|null);
        }

        class BadgeRewardEncounterRequestProto implements IBadgeRewardEncounterRequestProto {
            constructor(properties?: POGOProtos.Rpc.IBadgeRewardEncounterRequestProto);
            public badge_type: POGOProtos.Rpc.HoloBadgeType;
            public badge_tier: number;
            public static encode(message: POGOProtos.Rpc.IBadgeRewardEncounterRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeRewardEncounterRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeRewardEncounterRequestProto;
            public static toObject(message: POGOProtos.Rpc.BadgeRewardEncounterRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBadgeRewardEncounterResponseProto {
            status?: (POGOProtos.Rpc.BadgeRewardEncounterResponseProto.Status|null);
            encounter?: (POGOProtos.Rpc.BadgeRewardEncounterResponseProto.IEncounterInfoProto|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class BadgeRewardEncounterResponseProto implements IBadgeRewardEncounterResponseProto {
            constructor(properties?: POGOProtos.Rpc.IBadgeRewardEncounterResponseProto);
            public status: POGOProtos.Rpc.BadgeRewardEncounterResponseProto.Status;
            public encounter?: (POGOProtos.Rpc.BadgeRewardEncounterResponseProto.IEncounterInfoProto|null);
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IBadgeRewardEncounterResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeRewardEncounterResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeRewardEncounterResponseProto;
            public static toObject(message: POGOProtos.Rpc.BadgeRewardEncounterResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BadgeRewardEncounterResponseProto {

            enum Status {
                UNKNOWN = 0,
                SUCCESS_ENCOUNTER = 1,
                SUCCESS_POKEMON_INVENTORY_FULL = 2,
                ERROR_REQUIRES_PROGRESS = 3,
                ERROR_ENCOUNTER_COMPLETE = 4,
                ERROR = 5
            }

            interface IEncounterInfoProto {
                pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
                active_item?: (POGOProtos.Rpc.Item|null);
                encounter_id?: (number|Long|null);
            }

            class EncounterInfoProto implements IEncounterInfoProto {
                constructor(properties?: POGOProtos.Rpc.BadgeRewardEncounterResponseProto.IEncounterInfoProto);
                public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
                public active_item: POGOProtos.Rpc.Item;
                public encounter_id: (number|Long);
                public static encode(message: POGOProtos.Rpc.BadgeRewardEncounterResponseProto.IEncounterInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeRewardEncounterResponseProto.EncounterInfoProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeRewardEncounterResponseProto.EncounterInfoProto;
                public static toObject(message: POGOProtos.Rpc.BadgeRewardEncounterResponseProto.EncounterInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBadgeSettingsProto {
            badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            badge_ranks?: (number|null);
            targets?: (number[]|null);
            tier_rewards?: (POGOProtos.Rpc.IBadgeTierRewardProto[]|null);
            event_badge?: (boolean|null);
            event_badge_settings?: (POGOProtos.Rpc.IEventBadgeSettingsProto|null);
            combat_league_template_id?: (string|null);
            use_stat_as_medal_level?: (boolean|null);
            max_tracked_entries?: (number|null);
        }

        class BadgeSettingsProto implements IBadgeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBadgeSettingsProto);
            public badge_type: POGOProtos.Rpc.HoloBadgeType;
            public badge_ranks: number;
            public targets: number[];
            public tier_rewards: POGOProtos.Rpc.IBadgeTierRewardProto[];
            public event_badge: boolean;
            public event_badge_settings?: (POGOProtos.Rpc.IEventBadgeSettingsProto|null);
            public combat_league_template_id: string;
            public use_stat_as_medal_level: boolean;
            public max_tracked_entries: number;
            public static encode(message: POGOProtos.Rpc.IBadgeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BadgeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBadgeSystemSettingsProto {
            badge_reward_encounter_enabled?: (boolean|null);
            badge_reward_encounter_hash_player_id_enabled?: (boolean|null);
        }

        class BadgeSystemSettingsProto implements IBadgeSystemSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBadgeSystemSettingsProto);
            public badge_reward_encounter_enabled: boolean;
            public badge_reward_encounter_hash_player_id_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IBadgeSystemSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeSystemSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeSystemSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BadgeSystemSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBadgeTierRewardProto {
            capture_reward_multiplier?: (number|null);
            avatar_template_ids?: (string[]|null);
            reward_pokemon?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IPokemonUnlockProto[]|null);
            tier_index?: (number|null);
            reward_description_key?: (string|null);
            reward_types?: (POGOProtos.Rpc.BadgeTierRewardProto.BadgeRewardType[]|null);
            neutral_avatar_template_ids?: (string[]|null);
        }

        class BadgeTierRewardProto implements IBadgeTierRewardProto {
            constructor(properties?: POGOProtos.Rpc.IBadgeTierRewardProto);
            public capture_reward_multiplier: number;
            public avatar_template_ids: string[];
            public reward_pokemon: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IPokemonUnlockProto[];
            public tier_index: number;
            public reward_description_key: string;
            public reward_types: POGOProtos.Rpc.BadgeTierRewardProto.BadgeRewardType[];
            public neutral_avatar_template_ids: string[];
            public static encode(message: POGOProtos.Rpc.IBadgeTierRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BadgeTierRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BadgeTierRewardProto;
            public static toObject(message: POGOProtos.Rpc.BadgeTierRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BadgeTierRewardProto {

            enum BadgeRewardType {
                NONE = 0,
                AVATAR_ITEM = 1,
                POKEMON_ENCOUNTER = 2
            }
        }

        interface IBatchSetValueRequest {
            key_value_pairs?: (POGOProtos.Rpc.IKeyValuePair[]|null);
        }

        class BatchSetValueRequest implements IBatchSetValueRequest {
            constructor(properties?: POGOProtos.Rpc.IBatchSetValueRequest);
            public key_value_pairs: POGOProtos.Rpc.IKeyValuePair[];
            public static encode(message: POGOProtos.Rpc.IBatchSetValueRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BatchSetValueRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BatchSetValueRequest;
            public static toObject(message: POGOProtos.Rpc.BatchSetValueRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBatchSetValueResponse {
            updated_keys?: (POGOProtos.Rpc.IVersionedKey[]|null);
        }

        class BatchSetValueResponse implements IBatchSetValueResponse {
            constructor(properties?: POGOProtos.Rpc.IBatchSetValueResponse);
            public updated_keys: POGOProtos.Rpc.IVersionedKey[];
            public static encode(message: POGOProtos.Rpc.IBatchSetValueResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BatchSetValueResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BatchSetValueResponse;
            public static toObject(message: POGOProtos.Rpc.BatchSetValueResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleActionProto {
            type?: (POGOProtos.Rpc.BattleActionProto.ActionType|null);
            action_start_ms?: (number|Long|null);
            duration_ms?: (number|null);
            energy_delta?: (number|null);
            attacker_index?: (number|null);
            target_index?: (number|null);
            active_pokemon_id?: (number|Long|null);
            joined_player?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            battle_results?: (POGOProtos.Rpc.IBattleResultsProto|null);
            damage_window_start_ms?: (number|Long|null);
            damage_window_end_ms?: (number|Long|null);
            quit_player?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            target_pokemon_id?: (number|Long|null);
            leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            item?: (POGOProtos.Rpc.Item[]|null);
            trainer_ability?: (POGOProtos.Rpc.TrainerAbility|null);
        }

        class BattleActionProto implements IBattleActionProto {
            constructor(properties?: POGOProtos.Rpc.IBattleActionProto);
            public type: POGOProtos.Rpc.BattleActionProto.ActionType;
            public action_start_ms: (number|Long);
            public duration_ms: number;
            public energy_delta: number;
            public attacker_index: number;
            public target_index: number;
            public active_pokemon_id: (number|Long);
            public joined_player?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            public battle_results?: (POGOProtos.Rpc.IBattleResultsProto|null);
            public damage_window_start_ms: (number|Long);
            public damage_window_end_ms: (number|Long);
            public quit_player?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            public target_pokemon_id: (number|Long);
            public leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            public item: POGOProtos.Rpc.Item[];
            public trainer_ability: POGOProtos.Rpc.TrainerAbility;
            public static encode(message: POGOProtos.Rpc.IBattleActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleActionProto;
            public static toObject(message: POGOProtos.Rpc.BattleActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleActionProto {

            enum ActionType {
                UNSET = 0,
                ATTACK = 1,
                DODGE = 2,
                SPECIAL_ATTACK = 3,
                SWAP_POKEMON = 4,
                FAINT = 5,
                PLAYER_JOIN = 6,
                PLAYER_QUIT = 7,
                VICTORY = 8,
                DEFEAT = 9,
                TIMED_OUT = 10,
                SPECIAL_ATTACK_2 = 11,
                USE_ITEM = 12,
                DISPLAY_CHANGE = 13,
                ACTIVATE_ABILITY = 14
            }
        }

        interface IBattleActionProtoLog {
            type?: (POGOProtos.Rpc.BattleActionProto.ActionType|null);
            action_start_offset_ms?: (number|null);
            duration_ms?: (number|null);
            energy_delta?: (number|null);
            attacker_index?: (number|null);
            target_index?: (number|null);
            active_pokemon_id?: (number|Long|null);
            damage_window_start_offset_ms?: (number|null);
            damage_window_end_offset_ms?: (number|null);
        }

        class BattleActionProtoLog implements IBattleActionProtoLog {
            constructor(properties?: POGOProtos.Rpc.IBattleActionProtoLog);
            public type: POGOProtos.Rpc.BattleActionProto.ActionType;
            public action_start_offset_ms: number;
            public duration_ms: number;
            public energy_delta: number;
            public attacker_index: number;
            public target_index: number;
            public active_pokemon_id: (number|Long);
            public damage_window_start_offset_ms: number;
            public damage_window_end_offset_ms: number;
            public static encode(message: POGOProtos.Rpc.IBattleActionProtoLog, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleActionProtoLog;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleActionProtoLog;
            public static toObject(message: POGOProtos.Rpc.BattleActionProtoLog, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleActorProto {
            field_actor_metadata?: (POGOProtos.Rpc.BattleActorProto.IFieldActorMetadata|null);
            id?: (string|null);
            type?: (POGOProtos.Rpc.BattleActorProto.ActorType|null);
            position_x?: (number|null);
            position_y?: (number|null);
            active_pokemon_id?: (number|Long|null);
            team?: (POGOProtos.Rpc.Team|null);
            swap_available_turn?: (number|Long|null);
            party_id?: (string|null);
            pokemon_roster?: ((number|Long)[]|null);
            resources?: ({ [k: string]: POGOProtos.Rpc.IBattleResourceProto }|null);
            item_resources?: ({ [k: string]: POGOProtos.Rpc.IBattleResourceProto }|null);
            active_abilities?: (POGOProtos.Rpc.AbilityProto.AbilityType[]|null);
        }

        class BattleActorProto implements IBattleActorProto {
            constructor(properties?: POGOProtos.Rpc.IBattleActorProto);
            public field_actor_metadata?: (POGOProtos.Rpc.BattleActorProto.IFieldActorMetadata|null);
            public id: string;
            public type: POGOProtos.Rpc.BattleActorProto.ActorType;
            public position_x: number;
            public position_y: number;
            public active_pokemon_id: (number|Long);
            public team: POGOProtos.Rpc.Team;
            public swap_available_turn: (number|Long);
            public party_id: string;
            public pokemon_roster: (number|Long)[];
            public resources: { [k: string]: POGOProtos.Rpc.IBattleResourceProto };
            public item_resources: { [k: string]: POGOProtos.Rpc.IBattleResourceProto };
            public active_abilities: POGOProtos.Rpc.AbilityProto.AbilityType[];
            public FieldMetadata?: "field_actor_metadata";
            public static encode(message: POGOProtos.Rpc.IBattleActorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleActorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleActorProto;
            public static toObject(message: POGOProtos.Rpc.BattleActorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleActorProto {

            enum ActorType {
                UNSET_ACTOR_TYPE = 0,
                PLAYER = 1,
                PLAYER_BOSS = 2,
                PLAYER_OBSERVER = 3,
                NPC = 4,
                NPC_BOSS = 5,
                NPC_OBSERVER = 6,
                FIELD_DIRECTOR = 7,
                SIDELINE = 8,
                FIELD_ACTOR = 9
            }

            interface IFieldActorMetadata {
                attack_field_actor_data?: (POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.IAttackFieldActorData|null);
                collectible_orb_field_actor_data?: (POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.ICollectibleOrbFieldActorData|null);
                type?: (POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.FieldActorType|null);
            }

            class FieldActorMetadata implements IFieldActorMetadata {
                constructor(properties?: POGOProtos.Rpc.BattleActorProto.IFieldActorMetadata);
                public attack_field_actor_data?: (POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.IAttackFieldActorData|null);
                public collectible_orb_field_actor_data?: (POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.ICollectibleOrbFieldActorData|null);
                public type: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.FieldActorType;
                public FieldActor?: ("attack_field_actor_data"|"collectible_orb_field_actor_data");
                public static encode(message: POGOProtos.Rpc.BattleActorProto.IFieldActorMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleActorProto.FieldActorMetadata;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleActorProto.FieldActorMetadata;
                public static toObject(message: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FieldActorMetadata {

                enum FieldActorType {
                    UNSET_FIELD_ACTOR_TYPE = 0,
                    ATTACK_INDICATOR = 1,
                    COLLECTIBLE_ORB = 2
                }

                interface IAttackFieldActorData {
                    attack_type?: (POGOProtos.Rpc.BattlePokemonProto.AttackType|null);
                    begin_turn?: (number|Long|null);
                    end_turn?: (number|Long|null);
                    dodged?: (boolean|null);
                    target_actor_id?: (string|null);
                }

                class AttackFieldActorData implements IAttackFieldActorData {
                    constructor(properties?: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.IAttackFieldActorData);
                    public attack_type: POGOProtos.Rpc.BattlePokemonProto.AttackType;
                    public begin_turn: (number|Long);
                    public end_turn: (number|Long);
                    public dodged: boolean;
                    public target_actor_id: string;
                    public static encode(message: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.IAttackFieldActorData, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.AttackFieldActorData;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.AttackFieldActorData;
                    public static toObject(message: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.AttackFieldActorData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ICollectibleOrbFieldActorData {
                    state?: (POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.CollectibleOrbFieldActorData.OrbState|null);
                }

                class CollectibleOrbFieldActorData implements ICollectibleOrbFieldActorData {
                    constructor(properties?: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.ICollectibleOrbFieldActorData);
                    public state: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.CollectibleOrbFieldActorData.OrbState;
                    public static encode(message: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.ICollectibleOrbFieldActorData, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.CollectibleOrbFieldActorData;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.CollectibleOrbFieldActorData;
                    public static toObject(message: POGOProtos.Rpc.BattleActorProto.FieldActorMetadata.CollectibleOrbFieldActorData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace CollectibleOrbFieldActorData {

                    enum OrbState {
                        ORB_STATE_UNSET = 0,
                        ORB_STATE_IDLE = 1,
                        ORB_STATE_COLLECTED = 2,
                        ORB_STATE_EXPIRED = 3
                    }
                }
            }
        }

        interface IBattleAttributesProto {
            sta_percent?: (number|null);
            atk_percent?: (number|null);
            def_percent?: (number|null);
            duration_s?: (number|null);
            damage_multiplier?: (number|null);
        }

        class BattleAttributesProto implements IBattleAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IBattleAttributesProto);
            public sta_percent: number;
            public atk_percent: number;
            public def_percent: number;
            public duration_s: number;
            public damage_multiplier: number;
            public static encode(message: POGOProtos.Rpc.IBattleAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleAttributesProto;
            public static toObject(message: POGOProtos.Rpc.BattleAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleClockSyncOutProto {
            server_time_ms?: (number|Long|null);
            result?: (POGOProtos.Rpc.BattleClockSyncOutProto.Result|null);
        }

        class BattleClockSyncOutProto implements IBattleClockSyncOutProto {
            constructor(properties?: POGOProtos.Rpc.IBattleClockSyncOutProto);
            public server_time_ms: (number|Long);
            public result: POGOProtos.Rpc.BattleClockSyncOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IBattleClockSyncOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleClockSyncOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleClockSyncOutProto;
            public static toObject(message: POGOProtos.Rpc.BattleClockSyncOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleClockSyncOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IBattleClockSyncProto {
            battle_id?: (string|null);
            player_id?: (string|null);
        }

        class BattleClockSyncProto implements IBattleClockSyncProto {
            constructor(properties?: POGOProtos.Rpc.IBattleClockSyncProto);
            public battle_id: string;
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.IBattleClockSyncProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleClockSyncProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleClockSyncProto;
            public static toObject(message: POGOProtos.Rpc.BattleClockSyncProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleEventProto {
            battle_join?: (POGOProtos.Rpc.BattleEventProto.IBattleJoin|null);
            battle_quit?: (POGOProtos.Rpc.BattleEventProto.IBattleQuit|null);
            attack?: (POGOProtos.Rpc.BattleEventProto.IAttack|null);
            dodge?: (POGOProtos.Rpc.BattleEventProto.IDodge|null);
            shield?: (POGOProtos.Rpc.BattleEventProto.IShield|null);
            swap_pokemon?: (POGOProtos.Rpc.BattleEventProto.ISwapPokemon|null);
            item?: (POGOProtos.Rpc.BattleEventProto.IBattleItem|null);
            trainer_ability?: (POGOProtos.Rpc.BattleEventProto.ITrainerAbility|null);
            stat_change?: (POGOProtos.Rpc.BattleEventProto.IStatChange|null);
            start_battle?: (POGOProtos.Rpc.BattleEventProto.IStartBattle|null);
            transform?: (POGOProtos.Rpc.BattleEventProto.ITransform|null);
            ability_trigger?: (POGOProtos.Rpc.BattleEventProto.IAbilityTrigger|null);
            battle_end?: (POGOProtos.Rpc.BattleEventProto.IBattleEnd|null);
            countdown?: (POGOProtos.Rpc.BattleEventProto.ICountdown|null);
            dodge_success?: (POGOProtos.Rpc.BattleEventProto.IDodgeSuccess|null);
            flinch?: (POGOProtos.Rpc.BattleEventProto.IFlinch|null);
            bread_move?: (POGOProtos.Rpc.BattleEventProto.IBreadMove|null);
            sideline_action?: (POGOProtos.Rpc.BattleEventProto.ISidelineAction|null);
            attack_telegraph?: (POGOProtos.Rpc.BattleEventProto.IAttackTelegraph|null);
            cinematic?: (POGOProtos.Rpc.BattleEventProto.ICinematic|null);
            consensus?: (POGOProtos.Rpc.BattleEventProto.IConsensus|null);
            attack_boost?: (POGOProtos.Rpc.BattleEventProto.IAttackBoost|null);
            type?: (POGOProtos.Rpc.BattleEventProto.EventType|null);
            actor_id?: (string|null);
            turn?: (number|Long|null);
        }

        class BattleEventProto implements IBattleEventProto {
            constructor(properties?: POGOProtos.Rpc.IBattleEventProto);
            public battle_join?: (POGOProtos.Rpc.BattleEventProto.IBattleJoin|null);
            public battle_quit?: (POGOProtos.Rpc.BattleEventProto.IBattleQuit|null);
            public attack?: (POGOProtos.Rpc.BattleEventProto.IAttack|null);
            public dodge?: (POGOProtos.Rpc.BattleEventProto.IDodge|null);
            public shield?: (POGOProtos.Rpc.BattleEventProto.IShield|null);
            public swap_pokemon?: (POGOProtos.Rpc.BattleEventProto.ISwapPokemon|null);
            public item?: (POGOProtos.Rpc.BattleEventProto.IBattleItem|null);
            public trainer_ability?: (POGOProtos.Rpc.BattleEventProto.ITrainerAbility|null);
            public stat_change?: (POGOProtos.Rpc.BattleEventProto.IStatChange|null);
            public start_battle?: (POGOProtos.Rpc.BattleEventProto.IStartBattle|null);
            public transform?: (POGOProtos.Rpc.BattleEventProto.ITransform|null);
            public ability_trigger?: (POGOProtos.Rpc.BattleEventProto.IAbilityTrigger|null);
            public battle_end?: (POGOProtos.Rpc.BattleEventProto.IBattleEnd|null);
            public countdown?: (POGOProtos.Rpc.BattleEventProto.ICountdown|null);
            public dodge_success?: (POGOProtos.Rpc.BattleEventProto.IDodgeSuccess|null);
            public flinch?: (POGOProtos.Rpc.BattleEventProto.IFlinch|null);
            public bread_move?: (POGOProtos.Rpc.BattleEventProto.IBreadMove|null);
            public sideline_action?: (POGOProtos.Rpc.BattleEventProto.ISidelineAction|null);
            public attack_telegraph?: (POGOProtos.Rpc.BattleEventProto.IAttackTelegraph|null);
            public cinematic?: (POGOProtos.Rpc.BattleEventProto.ICinematic|null);
            public consensus?: (POGOProtos.Rpc.BattleEventProto.IConsensus|null);
            public attack_boost?: (POGOProtos.Rpc.BattleEventProto.IAttackBoost|null);
            public type: POGOProtos.Rpc.BattleEventProto.EventType;
            public actor_id: string;
            public turn: (number|Long);
            public BattleEvent?: ("battle_join"|"battle_quit"|"attack"|"dodge"|"shield"|"swap_pokemon"|"item"|"trainer_ability"|"stat_change"|"start_battle"|"transform"|"ability_trigger"|"battle_end"|"countdown"|"dodge_success"|"flinch"|"bread_move"|"sideline_action"|"attack_telegraph"|"cinematic"|"consensus"|"attack_boost");
            public static encode(message: POGOProtos.Rpc.IBattleEventProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto;
            public static toObject(message: POGOProtos.Rpc.BattleEventProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleEventProto {

            enum EventType {
                UNSET_EVENT_TYPE = 0,
                EVENT_TYPE_START_BATTLE = 1,
                EVENT_TYPE_BATTLE_JOIN = 2,
                EVENT_TYPE_BATTLE_QUIT = 3,
                EVENT_TYPE_ATTACK = 4,
                EVENT_TYPE_DODGE = 5,
                EVENT_TYPE_SHIELD = 6,
                EVENT_TYPE_SWAP_POKEMON = 7,
                EVENT_TYPE_ITEM = 8,
                EVENT_TYPE_ACTOR_ABILITY = 9,
                EVENT_TYPE_STAT_CHANGE = 10,
                EVENT_TYPE_ATTACK_TELEGRAPH = 11,
                EVENT_TYPE_MINIGAME = 12,
                EVENT_TYPE_TRANSFORM = 15,
                EVENT_TYPE_ABILITY_TRIGGER = 16,
                EVENT_TYPE_ACTOR_MOVE = 17,
                EVENT_TYPE_BATTLE_END = 18,
                EVENT_TYPE_COUNTDOWN = 19,
                EVENT_TYPE_DODGE_SUCCESS = 21,
                EVENT_TYPE_FLINCH = 22,
                EVENT_TYPE_BREAD_MODE = 23,
                EVENT_TYPE_BREAD_MOVE = 24,
                EVENT_TYPE_SIDELINE_ACTION = 25,
                EVENT_TYPE_ADD_FIELD_ACTOR = 26,
                EVENT_TYPE_REMOVE_FIELD_ACTOR = 27,
                EVENT_TYPE_ENRAGE = 28,
                EVENT_TYPE_ENRAGE_TELEGRAPH = 29,
                EVENT_TYPE_MODIFY_ACTOR_AURA = 30,
                EVENT_TYPE_CINEMATIC = 31,
                EVENT_TYPE_CONSENSUS = 32,
                EVENT_TYPE_BREAD_MODE_REVERT = 33,
                EVENT_TYPE_ATTACK_BOOST = 34
            }

            interface IAbilityTrigger {
                vfx_key?: (POGOProtos.Rpc.AbilityProto.AbilityType|null);
                stop_vfx?: (boolean|null);
            }

            class AbilityTrigger implements IAbilityTrigger {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IAbilityTrigger);
                public vfx_key: POGOProtos.Rpc.AbilityProto.AbilityType;
                public stop_vfx: boolean;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IAbilityTrigger, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.AbilityTrigger;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.AbilityTrigger;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.AbilityTrigger, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAttack {
                attack_type?: (POGOProtos.Rpc.BattlePokemonProto.AttackType|null);
                score?: (number|null);
                move?: (POGOProtos.Rpc.HoloPokemonMove|null);
                type?: (POGOProtos.Rpc.HoloPokemonType|null);
                target_id?: (string|null);
            }

            class Attack implements IAttack {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IAttack);
                public attack_type: POGOProtos.Rpc.BattlePokemonProto.AttackType;
                public score: number;
                public move: POGOProtos.Rpc.HoloPokemonMove;
                public type: POGOProtos.Rpc.HoloPokemonType;
                public target_id: string;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IAttack, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Attack;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Attack;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Attack, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAttackBoost {
                magnitude?: (number|null);
            }

            class AttackBoost implements IAttackBoost {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IAttackBoost);
                public magnitude: number;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IAttackBoost, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.AttackBoost;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.AttackBoost;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.AttackBoost, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAttackTelegraph {
                type?: (POGOProtos.Rpc.BattleEventProto.AttackTelegraph.AttackTelegraphType|null);
            }

            class AttackTelegraph implements IAttackTelegraph {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IAttackTelegraph);
                public type: POGOProtos.Rpc.BattleEventProto.AttackTelegraph.AttackTelegraphType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IAttackTelegraph, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.AttackTelegraph;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.AttackTelegraph;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.AttackTelegraph, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AttackTelegraph {

                enum AttackTelegraphType {
                    UNSET = 0,
                    ALL = 1,
                    SINGLE = 2
                }
            }

            interface IBattleEnd {
                reason?: (POGOProtos.Rpc.BattleEventProto.BattleEnd.Reason|null);
            }

            class BattleEnd implements IBattleEnd {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IBattleEnd);
                public reason: POGOProtos.Rpc.BattleEventProto.BattleEnd.Reason;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IBattleEnd, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.BattleEnd;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.BattleEnd;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.BattleEnd, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BattleEnd {

                enum Reason {
                    UNSET_REASON = 0,
                    ELIMINATION = 1,
                    TIME_OUT = 2,
                    SIDELINE_ELIMINATION = 3
                }
            }

            interface IBattleItem {
                item?: (POGOProtos.Rpc.Item|null);
            }

            class BattleItem implements IBattleItem {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IBattleItem);
                public item: POGOProtos.Rpc.Item;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IBattleItem, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.BattleItem;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.BattleItem;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.BattleItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattleJoin {
                roster?: (POGOProtos.Rpc.BattleEventProto.IPositionalRosterEntry[]|null);
                extra_resources?: (POGOProtos.Rpc.IBattleResourceProto[]|null);
                player_metadata?: (POGOProtos.Rpc.BattleEventProto.BattleJoin.IPlayerMetadata|null);
            }

            class BattleJoin implements IBattleJoin {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IBattleJoin);
                public roster: POGOProtos.Rpc.BattleEventProto.IPositionalRosterEntry[];
                public extra_resources: POGOProtos.Rpc.IBattleResourceProto[];
                public player_metadata?: (POGOProtos.Rpc.BattleEventProto.BattleJoin.IPlayerMetadata|null);
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IBattleJoin, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.BattleJoin;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.BattleJoin;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.BattleJoin, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BattleJoin {

                interface IPlayerMetadata {
                    trainer_name?: (string|null);
                    trainer_party_id?: (string|null);
                    max_friendship_level?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
                    remote?: (boolean|null);
                    num_local_friends?: (number|null);
                    num_remote_friends?: (number|null);
                    origin_id?: (string|null);
                    player_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                    mvt_avatar_customization_score?: (number|null);
                    distance_from_raid_meters?: (number|null);
                    buddy_pokemon_id?: (number|Long|null);
                    recent_distance_walked_km?: (number|null);
                    buddy_on_map?: (boolean|null);
                    buddy_level?: (POGOProtos.Rpc.BuddyLevel|null);
                    player_number?: (number|null);
                }

                class PlayerMetadata implements IPlayerMetadata {
                    constructor(properties?: POGOProtos.Rpc.BattleEventProto.BattleJoin.IPlayerMetadata);
                    public trainer_name: string;
                    public trainer_party_id: string;
                    public max_friendship_level: POGOProtos.Rpc.FriendshipLevelMilestone;
                    public remote: boolean;
                    public num_local_friends: number;
                    public num_remote_friends: number;
                    public origin_id: string;
                    public player_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                    public mvt_avatar_customization_score: number;
                    public distance_from_raid_meters: number;
                    public buddy_pokemon_id: (number|Long);
                    public recent_distance_walked_km: number;
                    public buddy_on_map: boolean;
                    public buddy_level: POGOProtos.Rpc.BuddyLevel;
                    public player_number: number;
                    public static encode(message: POGOProtos.Rpc.BattleEventProto.BattleJoin.IPlayerMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.BattleJoin.PlayerMetadata;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.BattleJoin.PlayerMetadata;
                    public static toObject(message: POGOProtos.Rpc.BattleEventProto.BattleJoin.PlayerMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IBattleQuit {
                type?: (POGOProtos.Rpc.BattleEventProto.BattleQuit.QuitType|null);
            }

            class BattleQuit implements IBattleQuit {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IBattleQuit);
                public type: POGOProtos.Rpc.BattleEventProto.BattleQuit.QuitType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IBattleQuit, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.BattleQuit;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.BattleQuit;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.BattleQuit, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BattleQuit {

                enum QuitType {
                    UNSET_QUIT_TYPE = 0,
                    PLAYER_QUIT = 1,
                    DISCONNECT = 2
                }
            }

            interface IBreadMove {
                type?: (POGOProtos.Rpc.BattleEventProto.BreadMove.MoveType|null);
            }

            class BreadMove implements IBreadMove {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IBreadMove);
                public type: POGOProtos.Rpc.BattleEventProto.BreadMove.MoveType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IBreadMove, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.BreadMove;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.BreadMove;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.BreadMove, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BreadMove {

                enum MoveType {
                    UNSET = 0,
                    BREAD_ATTACK = 1,
                    BREAD_GUARD = 2,
                    BREAD_HEAL = 3
                }
            }

            interface ICinematic {
                bread_move_metadata?: (POGOProtos.Rpc.BattleEventProto.Cinematic.IBreadMoveMetadata|null);
                event_type?: (POGOProtos.Rpc.BattleEventProto.Cinematic.CinematicEventType|null);
                begin_turn?: (number|Long|null);
                end_turn?: (number|Long|null);
            }

            class Cinematic implements ICinematic {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.ICinematic);
                public bread_move_metadata?: (POGOProtos.Rpc.BattleEventProto.Cinematic.IBreadMoveMetadata|null);
                public event_type: POGOProtos.Rpc.BattleEventProto.Cinematic.CinematicEventType;
                public begin_turn: (number|Long);
                public end_turn: (number|Long);
                public MetaData?: "bread_move_metadata";
                public static encode(message: POGOProtos.Rpc.BattleEventProto.ICinematic, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Cinematic;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Cinematic;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Cinematic, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Cinematic {

                enum CinematicEventType {
                    UNSET = 0,
                    PREBREAD = 1,
                    BREAD = 2,
                    BREAD_MOVE = 3,
                    REVERT_BREAD = 4,
                    SWAP = 5,
                    FLY_IN_CM_MINIGAME = 6,
                    FLY_OUT_CM_MINIGAME = 7,
                    MORPEKO_FULL_BELLY_TO_HANGRY = 50,
                    MORPEKO_HANGRY_TO_FULL_BELLY = 51,
                    AEGISLASH_SHIELD_TO_BLADE = 52,
                    AEGISLASH_BLADE_TO_SHIELD = 53
                }

                interface IBreadMoveMetadata {
                    move_type?: (POGOProtos.Rpc.BattlePokemonProto.AttackType|null);
                }

                class BreadMoveMetadata implements IBreadMoveMetadata {
                    constructor(properties?: POGOProtos.Rpc.BattleEventProto.Cinematic.IBreadMoveMetadata);
                    public move_type: POGOProtos.Rpc.BattlePokemonProto.AttackType;
                    public static encode(message: POGOProtos.Rpc.BattleEventProto.Cinematic.IBreadMoveMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Cinematic.BreadMoveMetadata;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Cinematic.BreadMoveMetadata;
                    public static toObject(message: POGOProtos.Rpc.BattleEventProto.Cinematic.BreadMoveMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IConsensus {
                begin_turn?: (number|Long|null);
                end_turn?: (number|Long|null);
                unblocked_event_type?: (POGOProtos.Rpc.BattleEventProto.EventType|null);
                consensus_event_subtype?: (POGOProtos.Rpc.BattleEventProto.Consensus.ConsensusEventSubType|null);
                vote_end_turn?: (number|Long|null);
                unblocked_event_types?: (POGOProtos.Rpc.BattleEventProto.EventType[]|null);
            }

            class Consensus implements IConsensus {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IConsensus);
                public begin_turn: (number|Long);
                public end_turn: (number|Long);
                public unblocked_event_type: POGOProtos.Rpc.BattleEventProto.EventType;
                public consensus_event_subtype: POGOProtos.Rpc.BattleEventProto.Consensus.ConsensusEventSubType;
                public vote_end_turn: (number|Long);
                public unblocked_event_types: POGOProtos.Rpc.BattleEventProto.EventType[];
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IConsensus, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Consensus;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Consensus;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Consensus, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Consensus {

                enum ConsensusEventSubType {
                    UNSET = 0,
                    PENDING_SWAP = 1,
                    PENDING_BREAD_MOVE_SELECT = 2,
                    PENDING_MINIGAME = 3,
                    PENDING_POKEMON_SELECT = 4
                }
            }

            interface ICountdown {
                countdown?: (number|null);
            }

            class Countdown implements ICountdown {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.ICountdown);
                public countdown: number;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.ICountdown, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Countdown;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Countdown;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Countdown, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDodge {
                direction?: (POGOProtos.Rpc.BattleEventProto.Dodge.DodgeDirectionType|null);
            }

            class Dodge implements IDodge {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IDodge);
                public direction: POGOProtos.Rpc.BattleEventProto.Dodge.DodgeDirectionType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IDodge, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Dodge;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Dodge;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Dodge, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Dodge {

                enum DodgeDirectionType {
                    UNSET_DIRECTION = 0,
                    LEFT = 1,
                    RIGHT = 2,
                    FORWARD = 3,
                    BACKWARD = 4
                }
            }

            interface IDodgeSuccess {
            }

            class DodgeSuccess implements IDodgeSuccess {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IDodgeSuccess);
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IDodgeSuccess, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.DodgeSuccess;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.DodgeSuccess;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.DodgeSuccess, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFlinch {
                effectiveness?: (POGOProtos.Rpc.BattleEventProto.Flinch.EffectienessType|null);
            }

            class Flinch implements IFlinch {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IFlinch);
                public effectiveness: POGOProtos.Rpc.BattleEventProto.Flinch.EffectienessType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IFlinch, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Flinch;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Flinch;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Flinch, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Flinch {

                enum EffectienessType {
                    UNSET = 0,
                    NOT_VERY_EFFECTIVE = 1,
                    SUPER_EFFECTIVE = 2
                }
            }

            interface IPositionalRosterEntry {
                pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                position_x?: (number|null);
                position_y?: (number|null);
                start_energy?: (number|null);
                max_moves?: (POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.IMaxMoves[]|null);
            }

            class PositionalRosterEntry implements IPositionalRosterEntry {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IPositionalRosterEntry);
                public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                public position_x: number;
                public position_y: number;
                public start_energy: number;
                public max_moves: POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.IMaxMoves[];
                public Entry?: "pokemon";
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IPositionalRosterEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PositionalRosterEntry {

                interface IMaxMoves {
                    move_type?: (POGOProtos.Rpc.BattleEventProto.BreadMove.MoveType|null);
                    max_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
                }

                class MaxMoves implements IMaxMoves {
                    constructor(properties?: POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.IMaxMoves);
                    public move_type: POGOProtos.Rpc.BattleEventProto.BreadMove.MoveType;
                    public max_move: POGOProtos.Rpc.HoloPokemonMove;
                    public static encode(message: POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.IMaxMoves, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.MaxMoves;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.MaxMoves;
                    public static toObject(message: POGOProtos.Rpc.BattleEventProto.PositionalRosterEntry.MaxMoves, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IShield {
            }

            class Shield implements IShield {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IShield);
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IShield, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Shield;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Shield;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Shield, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISidelineAction {
                type?: (POGOProtos.Rpc.BattleEventProto.SidelineAction.SideLineType|null);
            }

            class SidelineAction implements ISidelineAction {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.ISidelineAction);
                public type: POGOProtos.Rpc.BattleEventProto.SidelineAction.SideLineType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.ISidelineAction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.SidelineAction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.SidelineAction;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.SidelineAction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SidelineAction {

                enum SideLineType {
                    UNSET = 0,
                    FAST = 1,
                    CHARGE = 2
                }
            }

            interface IStartBattle {
            }

            class StartBattle implements IStartBattle {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IStartBattle);
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IStartBattle, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.StartBattle;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.StartBattle;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.StartBattle, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IStatChange {
                stat_stage?: (POGOProtos.Rpc.BattleEventProto.StatChange.IStatStage[]|null);
            }

            class StatChange implements IStatChange {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.IStatChange);
                public stat_stage: POGOProtos.Rpc.BattleEventProto.StatChange.IStatStage[];
                public static encode(message: POGOProtos.Rpc.BattleEventProto.IStatChange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.StatChange;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.StatChange;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.StatChange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace StatChange {

                interface IStatStage {
                    type?: (POGOProtos.Rpc.BattleEventProto.StatChange.StatStage.StatStageType|null);
                    delta?: (number|null);
                }

                class StatStage implements IStatStage {
                    constructor(properties?: POGOProtos.Rpc.BattleEventProto.StatChange.IStatStage);
                    public type: POGOProtos.Rpc.BattleEventProto.StatChange.StatStage.StatStageType;
                    public delta: number;
                    public static encode(message: POGOProtos.Rpc.BattleEventProto.StatChange.IStatStage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.StatChange.StatStage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.StatChange.StatStage;
                    public static toObject(message: POGOProtos.Rpc.BattleEventProto.StatChange.StatStage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace StatStage {

                    enum StatStageType {
                        UNSET_STAT_CHANGE = 0,
                        ATTACK = 1,
                        DEFENSE = 2,
                        STAMINA = 3
                    }
                }
            }

            interface ISwapPokemon {
                outgoing_pokemon_id?: (number|Long|null);
                incoming_pokemon_id?: (number|Long|null);
            }

            class SwapPokemon implements ISwapPokemon {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.ISwapPokemon);
                public outgoing_pokemon_id: (number|Long);
                public incoming_pokemon_id: (number|Long);
                public static encode(message: POGOProtos.Rpc.BattleEventProto.ISwapPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.SwapPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.SwapPokemon;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.SwapPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITrainerAbility {
                ability?: (POGOProtos.Rpc.BattleEventProto.TrainerAbility.Ability|null);
            }

            class TrainerAbility implements ITrainerAbility {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.ITrainerAbility);
                public ability: POGOProtos.Rpc.BattleEventProto.TrainerAbility.Ability;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.ITrainerAbility, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.TrainerAbility;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.TrainerAbility;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.TrainerAbility, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace TrainerAbility {

                enum Ability {
                    UNSET_TRAINER_ABILITY_TYPE = 0,
                    PARTY_POWER = 1
                }
            }

            interface ITransform {
                vfx_key?: (POGOProtos.Rpc.AbilityProto.AbilityType|null);
            }

            class Transform implements ITransform {
                constructor(properties?: POGOProtos.Rpc.BattleEventProto.ITransform);
                public vfx_key: POGOProtos.Rpc.AbilityProto.AbilityType;
                public static encode(message: POGOProtos.Rpc.BattleEventProto.ITransform, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventProto.Transform;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventProto.Transform;
                public static toObject(message: POGOProtos.Rpc.BattleEventProto.Transform, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBattleEventRequestProto {
            battle_id?: (string|null);
            player_id?: (string|null);
            sequence_id?: (number|Long|null);
            turn?: (number|Long|null);
            time_ms?: (number|Long|null);
            full_state?: (boolean|null);
            event?: (POGOProtos.Rpc.IBattleEventProto|null);
        }

        class BattleEventRequestProto implements IBattleEventRequestProto {
            constructor(properties?: POGOProtos.Rpc.IBattleEventRequestProto);
            public battle_id: string;
            public player_id: string;
            public sequence_id: (number|Long);
            public turn: (number|Long);
            public time_ms: (number|Long);
            public full_state: boolean;
            public event?: (POGOProtos.Rpc.IBattleEventProto|null);
            public static encode(message: POGOProtos.Rpc.IBattleEventRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleEventRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleEventRequestProto;
            public static toObject(message: POGOProtos.Rpc.BattleEventRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleHubBadgeSettings {
            combat_hub_displayed_badges?: (POGOProtos.Rpc.HoloBadgeType[]|null);
        }

        class BattleHubBadgeSettings implements IBattleHubBadgeSettings {
            constructor(properties?: POGOProtos.Rpc.IBattleHubBadgeSettings);
            public combat_hub_displayed_badges: POGOProtos.Rpc.HoloBadgeType[];
            public static encode(message: POGOProtos.Rpc.IBattleHubBadgeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleHubBadgeSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleHubBadgeSettings;
            public static toObject(message: POGOProtos.Rpc.BattleHubBadgeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleHubOrderSettings {
            section?: (POGOProtos.Rpc.BattleHubOrderSettings.ISectionSettings[]|null);
            section_group?: (POGOProtos.Rpc.BattleHubOrderSettings.ISectionGroup[]|null);
        }

        class BattleHubOrderSettings implements IBattleHubOrderSettings {
            constructor(properties?: POGOProtos.Rpc.IBattleHubOrderSettings);
            public section: POGOProtos.Rpc.BattleHubOrderSettings.ISectionSettings[];
            public section_group: POGOProtos.Rpc.BattleHubOrderSettings.ISectionGroup[];
            public static encode(message: POGOProtos.Rpc.IBattleHubOrderSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleHubOrderSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleHubOrderSettings;
            public static toObject(message: POGOProtos.Rpc.BattleHubOrderSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleHubOrderSettings {

            interface ISectionGroup {
                section?: (POGOProtos.Rpc.BattleHubSection[]|null);
            }

            class SectionGroup implements ISectionGroup {
                constructor(properties?: POGOProtos.Rpc.BattleHubOrderSettings.ISectionGroup);
                public section: POGOProtos.Rpc.BattleHubSection[];
                public static encode(message: POGOProtos.Rpc.BattleHubOrderSettings.ISectionGroup, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleHubOrderSettings.SectionGroup;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleHubOrderSettings.SectionGroup;
                public static toObject(message: POGOProtos.Rpc.BattleHubOrderSettings.SectionGroup, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISectionSettings {
                main_section?: (POGOProtos.Rpc.BattleHubSection|null);
                section_group?: (POGOProtos.Rpc.BattleHubSubsection[]|null);
            }

            class SectionSettings implements ISectionSettings {
                constructor(properties?: POGOProtos.Rpc.BattleHubOrderSettings.ISectionSettings);
                public main_section: POGOProtos.Rpc.BattleHubSection;
                public section_group: POGOProtos.Rpc.BattleHubSubsection[];
                public static encode(message: POGOProtos.Rpc.BattleHubOrderSettings.ISectionSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleHubOrderSettings.SectionSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleHubOrderSettings.SectionSettings;
                public static toObject(message: POGOProtos.Rpc.BattleHubOrderSettings.SectionSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBattleInputBufferPriorityList {
            event_priority?: (POGOProtos.Rpc.BattleEventProto.EventType[]|null);
        }

        class BattleInputBufferPriorityList implements IBattleInputBufferPriorityList {
            constructor(properties?: POGOProtos.Rpc.IBattleInputBufferPriorityList);
            public event_priority: POGOProtos.Rpc.BattleEventProto.EventType[];
            public static encode(message: POGOProtos.Rpc.IBattleInputBufferPriorityList, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleInputBufferPriorityList;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleInputBufferPriorityList;
            public static toObject(message: POGOProtos.Rpc.BattleInputBufferPriorityList, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleInputBufferSettingsProto {
            raids_input_buffer_priority_list?: (POGOProtos.Rpc.IBattleInputBufferPriorityList|null);
            bread_input_buffer_priority_list?: (POGOProtos.Rpc.IBattleInputBufferPriorityList|null);
            combat_input_buffer_priority_list?: (POGOProtos.Rpc.IBattleInputBufferPriorityList|null);
        }

        class BattleInputBufferSettingsProto implements IBattleInputBufferSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBattleInputBufferSettingsProto);
            public raids_input_buffer_priority_list?: (POGOProtos.Rpc.IBattleInputBufferPriorityList|null);
            public bread_input_buffer_priority_list?: (POGOProtos.Rpc.IBattleInputBufferPriorityList|null);
            public combat_input_buffer_priority_list?: (POGOProtos.Rpc.IBattleInputBufferPriorityList|null);
            public static encode(message: POGOProtos.Rpc.IBattleInputBufferSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleInputBufferSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleInputBufferSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BattleInputBufferSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleLogProto {
            state?: (POGOProtos.Rpc.BattleLogProto.State|null);
            battle_type?: (POGOProtos.Rpc.BattleLogProto.BattleType|null);
            server_ms?: (number|Long|null);
            battle_actions?: (POGOProtos.Rpc.IBattleActionProto[]|null);
            battle_start_ms?: (number|Long|null);
            battle_end_ms?: (number|Long|null);
        }

        class BattleLogProto implements IBattleLogProto {
            constructor(properties?: POGOProtos.Rpc.IBattleLogProto);
            public state: POGOProtos.Rpc.BattleLogProto.State;
            public battle_type: POGOProtos.Rpc.BattleLogProto.BattleType;
            public server_ms: (number|Long);
            public battle_actions: POGOProtos.Rpc.IBattleActionProto[];
            public battle_start_ms: (number|Long);
            public battle_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBattleLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleLogProto;
            public static toObject(message: POGOProtos.Rpc.BattleLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleLogProto {

            enum BattleType {
                BATTLE_TYPE_UNSET = 0,
                NORMAL = 1,
                TRAINING = 2,
                RAID = 3
            }

            enum State {
                STATE_UNSET = 0,
                ACTIVE = 1,
                VICTORY = 2,
                DEFEATED = 3,
                TIMED_OUT = 4
            }
        }

        interface IBattleParticipantProto {
            active_pokemon?: (POGOProtos.Rpc.IPokemonInfo|null);
            trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            reserve_pokemon?: (POGOProtos.Rpc.IPokemonInfo[]|null);
            defeated_pokemon?: (POGOProtos.Rpc.IPokemonInfo[]|null);
            lobby_pokemon?: (POGOProtos.Rpc.ILobbyPokemonProto[]|null);
            damage_dealt?: (number|null);
            super_effective_charge_move?: (boolean|null);
            weather_boosted?: (boolean|null);
            highest_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            friend_codename?: (string[]|null);
            is_remote?: (boolean|null);
            is_social_invite?: (boolean|null);
            has_active_mega_evolved_pokemon?: (boolean|null);
            lobby_join_time_ms?: (number|Long|null);
            super_effective_charge_attacks_used?: (number|null);
            pokemon_survival?: (POGOProtos.Rpc.IPokemonSurvivalTimeInfo|null);
            battle_mega_pokemon_id?: (number|Long|null);
            tall_pokemon_id?: (number|Long|null);
            number_of_charge_attacks_used?: (number|null);
            last_player_join_time_ms?: (number|Long|null);
            last_player_quit_time_ms?: (number|Long|null);
            player_id?: (string|null);
            referenced_pokemon?: (POGOProtos.Rpc.IPokemonInfo[]|null);
            join_buddy_pokemon_id?: (number|Long|null);
            battle_buddy_pokemon_id?: (number|Long|null);
            remote_friends?: (number|null);
            local_friends?: (number|null);
            last_update_time_ms?: (number|Long|null);
            boot_raid_state?: (boolean|null);
            enabled_raid_friend_requests?: (boolean|null);
            notable_action_history?: (POGOProtos.Rpc.IVsActionHistory[]|null);
            active_pokemon_stat_modifiers?: ({ [k: string]: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer }|null);
            ability_energy?: ({ [k: string]: POGOProtos.Rpc.IAbilityEnergyMetadata }|null);
            ability_activation_count?: ({ [k: string]: number }|null);
            used_pokemon?: (POGOProtos.Rpc.IPokemonProto[]|null);
            is_self_invite?: (boolean|null);
        }

        class BattleParticipantProto implements IBattleParticipantProto {
            constructor(properties?: POGOProtos.Rpc.IBattleParticipantProto);
            public active_pokemon?: (POGOProtos.Rpc.IPokemonInfo|null);
            public trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public reserve_pokemon: POGOProtos.Rpc.IPokemonInfo[];
            public defeated_pokemon: POGOProtos.Rpc.IPokemonInfo[];
            public lobby_pokemon: POGOProtos.Rpc.ILobbyPokemonProto[];
            public damage_dealt: number;
            public super_effective_charge_move: boolean;
            public weather_boosted: boolean;
            public highest_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public friend_codename: string[];
            public is_remote: boolean;
            public is_social_invite: boolean;
            public has_active_mega_evolved_pokemon: boolean;
            public lobby_join_time_ms: (number|Long);
            public super_effective_charge_attacks_used: number;
            public pokemon_survival?: (POGOProtos.Rpc.IPokemonSurvivalTimeInfo|null);
            public battle_mega_pokemon_id: (number|Long);
            public tall_pokemon_id: (number|Long);
            public number_of_charge_attacks_used: number;
            public last_player_join_time_ms: (number|Long);
            public last_player_quit_time_ms: (number|Long);
            public player_id: string;
            public referenced_pokemon: POGOProtos.Rpc.IPokemonInfo[];
            public join_buddy_pokemon_id: (number|Long);
            public battle_buddy_pokemon_id: (number|Long);
            public remote_friends: number;
            public local_friends: number;
            public last_update_time_ms: (number|Long);
            public boot_raid_state: boolean;
            public enabled_raid_friend_requests: boolean;
            public notable_action_history: POGOProtos.Rpc.IVsActionHistory[];
            public active_pokemon_stat_modifiers: { [k: string]: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer };
            public ability_energy: { [k: string]: POGOProtos.Rpc.IAbilityEnergyMetadata };
            public ability_activation_count: { [k: string]: number };
            public used_pokemon: POGOProtos.Rpc.IPokemonProto[];
            public is_self_invite: boolean;
            public static encode(message: POGOProtos.Rpc.IBattleParticipantProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleParticipantProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleParticipantProto;
            public static toObject(message: POGOProtos.Rpc.BattleParticipantProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattlePartiesProto {
            battle_parties?: (POGOProtos.Rpc.IBattlePartyProto[]|null);
        }

        class BattlePartiesProto implements IBattlePartiesProto {
            constructor(properties?: POGOProtos.Rpc.IBattlePartiesProto);
            public battle_parties: POGOProtos.Rpc.IBattlePartyProto[];
            public static encode(message: POGOProtos.Rpc.IBattlePartiesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePartiesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePartiesProto;
            public static toObject(message: POGOProtos.Rpc.BattlePartiesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattlePartyProto {
            name?: (string|null);
            team_number?: (number|null);
            ids?: ((number|Long)[]|null);
            combat_league_id?: (string|null);
        }

        class BattlePartyProto implements IBattlePartyProto {
            constructor(properties?: POGOProtos.Rpc.IBattlePartyProto);
            public name: string;
            public team_number: number;
            public ids: (number|Long)[];
            public combat_league_id: string;
            public static encode(message: POGOProtos.Rpc.IBattlePartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePartyProto;
            public static toObject(message: POGOProtos.Rpc.BattlePartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattlePartySettingsProto {
            enable_battle_party_saving?: (boolean|null);
            max_battle_parties?: (number|null);
            overall_parties_cap?: (number|null);
            gym_and_raid_battle_party_size?: (number|null);
            max_party_name_length?: (number|null);
        }

        class BattlePartySettingsProto implements IBattlePartySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBattlePartySettingsProto);
            public enable_battle_party_saving: boolean;
            public max_battle_parties: number;
            public overall_parties_cap: number;
            public gym_and_raid_battle_party_size: number;
            public max_party_name_length: number;
            public static encode(message: POGOProtos.Rpc.IBattlePartySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePartySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePartySettingsProto;
            public static toObject(message: POGOProtos.Rpc.BattlePartySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattlePartyTelemetry {
            battle_party_click_id?: (POGOProtos.Rpc.BattlePartyTelemetryIds|null);
            battle_party_count?: (number|null);
            battle_party_number?: (number|null);
        }

        class BattlePartyTelemetry implements IBattlePartyTelemetry {
            constructor(properties?: POGOProtos.Rpc.IBattlePartyTelemetry);
            public battle_party_click_id: POGOProtos.Rpc.BattlePartyTelemetryIds;
            public battle_party_count: number;
            public battle_party_number: number;
            public static encode(message: POGOProtos.Rpc.IBattlePartyTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePartyTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePartyTelemetry;
            public static toObject(message: POGOProtos.Rpc.BattlePartyTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattlePokemonProto {
            id?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            cp?: (number|null);
            resources?: ({ [k: string]: POGOProtos.Rpc.IBattleResourceProto }|null);
            item_resources?: ({ [k: string]: POGOProtos.Rpc.IBattleResourceProto }|null);
            moves?: ({ [k: string]: POGOProtos.Rpc.BattlePokemonProto.IMoveData }|null);
            modifiers?: ({ [k: string]: POGOProtos.Rpc.BattlePokemonProto.IModifier }|null);
            active_abilities?: (POGOProtos.Rpc.AbilityProto.AbilityType[]|null);
            pokeball?: (POGOProtos.Rpc.Item|null);
            size?: (POGOProtos.Rpc.HoloPokemonSize|null);
            nickname?: (string|null);
        }

        class BattlePokemonProto implements IBattlePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IBattlePokemonProto);
            public id: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public cp: number;
            public resources: { [k: string]: POGOProtos.Rpc.IBattleResourceProto };
            public item_resources: { [k: string]: POGOProtos.Rpc.IBattleResourceProto };
            public moves: { [k: string]: POGOProtos.Rpc.BattlePokemonProto.IMoveData };
            public modifiers: { [k: string]: POGOProtos.Rpc.BattlePokemonProto.IModifier };
            public active_abilities: POGOProtos.Rpc.AbilityProto.AbilityType[];
            public pokeball: POGOProtos.Rpc.Item;
            public size: POGOProtos.Rpc.HoloPokemonSize;
            public nickname: string;
            public static encode(message: POGOProtos.Rpc.IBattlePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePokemonProto;
            public static toObject(message: POGOProtos.Rpc.BattlePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattlePokemonProto {

            enum AttackType {
                UNSET_MOVE_TYPE = 0,
                FAST = 1,
                CHARGE = 2,
                CHARGE2 = 3,
                SHIELD = 4,
                BREAD_ATTACK = 5,
                BREAD_GUARD = 6,
                BREAD_HEAL = 7
            }

            interface IModifier {
                type?: (POGOProtos.Rpc.BattlePokemonProto.Modifier.ModifierType|null);
                value?: (number|null);
            }

            class Modifier implements IModifier {
                constructor(properties?: POGOProtos.Rpc.BattlePokemonProto.IModifier);
                public type: POGOProtos.Rpc.BattlePokemonProto.Modifier.ModifierType;
                public value: number;
                public static encode(message: POGOProtos.Rpc.BattlePokemonProto.IModifier, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePokemonProto.Modifier;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePokemonProto.Modifier;
                public static toObject(message: POGOProtos.Rpc.BattlePokemonProto.Modifier, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Modifier {

                enum ModifierType {
                    UNSET_MODIFIER_TYPE = 0,
                    ATTACK = 1,
                    DEFENSE = 2
                }
            }

            interface IMoveData {
                move?: (POGOProtos.Rpc.HoloPokemonMove|null);
                type?: (POGOProtos.Rpc.HoloPokemonType|null);
                duration_turns?: (number|null);
                level?: (number|null);
            }

            class MoveData implements IMoveData {
                constructor(properties?: POGOProtos.Rpc.BattlePokemonProto.IMoveData);
                public move: POGOProtos.Rpc.HoloPokemonMove;
                public type: POGOProtos.Rpc.HoloPokemonType;
                public duration_turns: number;
                public level: number;
                public static encode(message: POGOProtos.Rpc.BattlePokemonProto.IMoveData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattlePokemonProto.MoveData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattlePokemonProto.MoveData;
                public static toObject(message: POGOProtos.Rpc.BattlePokemonProto.MoveData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBattleProto {
            battle_start_ms?: (number|Long|null);
            battle_end_ms?: (number|Long|null);
            battle_id?: (string|null);
            defender?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            attacker?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            weather_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            highest_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            battle_experiment?: (POGOProtos.Rpc.BattleExperiment[]|null);
            ability_result_location?: ({ [k: string]: POGOProtos.Rpc.IAbilityLookupMap }|null);
        }

        class BattleProto implements IBattleProto {
            constructor(properties?: POGOProtos.Rpc.IBattleProto);
            public battle_start_ms: (number|Long);
            public battle_end_ms: (number|Long);
            public battle_id: string;
            public defender?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            public battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            public attacker?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            public weather_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public highest_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public battle_experiment: POGOProtos.Rpc.BattleExperiment[];
            public ability_result_location: { [k: string]: POGOProtos.Rpc.IAbilityLookupMap };
            public static encode(message: POGOProtos.Rpc.IBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleProto;
            public static toObject(message: POGOProtos.Rpc.BattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleQuestProto {
            battle_id?: (string[]|null);
        }

        class BattleQuestProto implements IBattleQuestProto {
            constructor(properties?: POGOProtos.Rpc.IBattleQuestProto);
            public battle_id: string[];
            public static encode(message: POGOProtos.Rpc.IBattleQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleQuestProto;
            public static toObject(message: POGOProtos.Rpc.BattleQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleResourceProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            type?: (POGOProtos.Rpc.BattleResourceProto.ResourceType|null);
            quantity?: (number|null);
            max_quantity?: (number|null);
            disabled?: (boolean|null);
            cooldown_metadata?: (POGOProtos.Rpc.BattleResourceProto.ICooldownMetadata|null);
        }

        class BattleResourceProto implements IBattleResourceProto {
            constructor(properties?: POGOProtos.Rpc.IBattleResourceProto);
            public item?: (POGOProtos.Rpc.Item|null);
            public pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            public type: POGOProtos.Rpc.BattleResourceProto.ResourceType;
            public quantity: number;
            public max_quantity: number;
            public disabled: boolean;
            public cooldown_metadata?: (POGOProtos.Rpc.BattleResourceProto.ICooldownMetadata|null);
            public Resource?: ("item"|"pokemon_id");
            public static encode(message: POGOProtos.Rpc.IBattleResourceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleResourceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleResourceProto;
            public static toObject(message: POGOProtos.Rpc.BattleResourceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleResourceProto {

            enum ResourceType {
                UNSET_RESOURCE_TYPE = 0,
                RESOURCE_TYPE_HEALTH = 1,
                RESOURCE_TYPE_ENERGY = 2,
                RESOURCE_TYPE_SHIELD = 3,
                RESOURCE_TYPE_ITEM = 4,
                RESOURCE_TYPE_PARTY_ENERGY = 5,
                RESOURCE_TYPE_BREAD_POWER = 6,
                RESOURCE_TYPE_BREAD_MOVE = 7,
                RESOURCE_TYPE_BREAD_GUARD = 8,
                RESOURCE_TYPE_SIDELINE_POWER = 9
            }

            interface ICooldownMetadata {
                last_used_turn?: (number|Long|null);
                next_available_turn?: (number|Long|null);
            }

            class CooldownMetadata implements ICooldownMetadata {
                constructor(properties?: POGOProtos.Rpc.BattleResourceProto.ICooldownMetadata);
                public last_used_turn: (number|Long);
                public next_available_turn: (number|Long);
                public static encode(message: POGOProtos.Rpc.BattleResourceProto.ICooldownMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleResourceProto.CooldownMetadata;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleResourceProto.CooldownMetadata;
                public static toObject(message: POGOProtos.Rpc.BattleResourceProto.CooldownMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBattleResultsProto {
            gym_state?: (POGOProtos.Rpc.IGymStateProto|null);
            attackers?: (POGOProtos.Rpc.IBattleParticipantProto[]|null);
            player_xp_awarded?: (number[]|null);
            next_defender_pokemon_id?: (number|Long|null);
            gym_points_delta?: (number|null);
            gym_status?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            participation?: (POGOProtos.Rpc.IParticipationProto[]|null);
            raid_item_rewards?: (POGOProtos.Rpc.ILootProto[]|null);
            post_raid_encounter?: (POGOProtos.Rpc.IRaidEncounterProto[]|null);
            gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge[]|null);
            default_raid_item_rewards?: (POGOProtos.Rpc.ILootProto[]|null);
            battle_duration_ms?: (number|Long|null);
            raid_player_stats?: (POGOProtos.Rpc.IRaidPlayerStatsProto|null);
            xl_candy_awarded?: (number[]|null);
            xl_candy_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            candy_awarded?: (number[]|null);
            leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            player_results?: (POGOProtos.Rpc.BattleResultsProto.IPlayerResultsProto[]|null);
            raid_item_rewards_from_player_activity?: (POGOProtos.Rpc.ILootProto[]|null);
        }

        class BattleResultsProto implements IBattleResultsProto {
            constructor(properties?: POGOProtos.Rpc.IBattleResultsProto);
            public gym_state?: (POGOProtos.Rpc.IGymStateProto|null);
            public attackers: POGOProtos.Rpc.IBattleParticipantProto[];
            public player_xp_awarded: number[];
            public next_defender_pokemon_id: (number|Long);
            public gym_points_delta: number;
            public gym_status?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            public participation: POGOProtos.Rpc.IParticipationProto[];
            public raid_item_rewards: POGOProtos.Rpc.ILootProto[];
            public post_raid_encounter: POGOProtos.Rpc.IRaidEncounterProto[];
            public gym_badge: POGOProtos.Rpc.IAwardedGymBadge[];
            public default_raid_item_rewards: POGOProtos.Rpc.ILootProto[];
            public battle_duration_ms: (number|Long);
            public raid_player_stats?: (POGOProtos.Rpc.IRaidPlayerStatsProto|null);
            public xl_candy_awarded: number[];
            public xl_candy_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public candy_awarded: number[];
            public leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            public player_results: POGOProtos.Rpc.BattleResultsProto.IPlayerResultsProto[];
            public raid_item_rewards_from_player_activity: POGOProtos.Rpc.ILootProto[];
            public static encode(message: POGOProtos.Rpc.IBattleResultsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleResultsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleResultsProto;
            public static toObject(message: POGOProtos.Rpc.BattleResultsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleResultsProto {

            interface IPlayerResultsProto {
                attacker?: (POGOProtos.Rpc.IBattleParticipantProto|null);
                participation?: (POGOProtos.Rpc.IParticipationProto|null);
                raid_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
                post_raid_encounter?: (POGOProtos.Rpc.IRaidEncounterProto|null);
                gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
                default_raid_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
                stats?: (POGOProtos.Rpc.IRaidPlayerStatProto|null);
                player_xp_awarded?: (number|null);
                candy_awarded?: (number|null);
                xl_candy_awarded?: (number|null);
                leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            }

            class PlayerResultsProto implements IPlayerResultsProto {
                constructor(properties?: POGOProtos.Rpc.BattleResultsProto.IPlayerResultsProto);
                public attacker?: (POGOProtos.Rpc.IBattleParticipantProto|null);
                public participation?: (POGOProtos.Rpc.IParticipationProto|null);
                public raid_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
                public post_raid_encounter?: (POGOProtos.Rpc.IRaidEncounterProto|null);
                public gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
                public default_raid_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
                public stats?: (POGOProtos.Rpc.IRaidPlayerStatProto|null);
                public player_xp_awarded: number;
                public candy_awarded: number;
                public xl_candy_awarded: number;
                public leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
                public static encode(message: POGOProtos.Rpc.BattleResultsProto.IPlayerResultsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleResultsProto.PlayerResultsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleResultsProto.PlayerResultsProto;
                public static toObject(message: POGOProtos.Rpc.BattleResultsProto.PlayerResultsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBattleStateOutProto {
            battle_state?: (POGOProtos.Rpc.IBattleStateProto|null);
            turn?: (number|Long|null);
            time_ms?: (number|Long|null);
            full_state?: (boolean|null);
            serial?: (number|Long|null);
            error?: (string|null);
        }

        class BattleStateOutProto implements IBattleStateOutProto {
            constructor(properties?: POGOProtos.Rpc.IBattleStateOutProto);
            public battle_state?: (POGOProtos.Rpc.IBattleStateProto|null);
            public turn: (number|Long);
            public time_ms: (number|Long);
            public full_state: boolean;
            public serial: (number|Long);
            public error: string;
            public static encode(message: POGOProtos.Rpc.IBattleStateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleStateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleStateOutProto;
            public static toObject(message: POGOProtos.Rpc.BattleStateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBattleStateProto {
            actors?: ({ [k: string]: POGOProtos.Rpc.IBattleActorProto }|null);
            turn_start_ms?: (number|Long|null);
            turn?: (number|Long|null);
            ms_per_turn?: (number|null);
            current_actor_id?: (string|null);
            state?: (POGOProtos.Rpc.BattleStateProto.State|null);
            active_actor_count?: (number|null);
            team_actor_count?: ({ [k: string]: number }|null);
            pokemon?: ({ [k: string]: POGOProtos.Rpc.IBattlePokemonProto }|null);
            party_member_count?: ({ [k: string]: number }|null);
            events?: (POGOProtos.Rpc.IBattleEventProto[]|null);
            battle_end_turn?: (number|Long|null);
            battle_start_turn?: (number|Long|null);
            ui_mode?: (POGOProtos.Rpc.BattleStateProto.UIMode|null);
            allied_pokemon_remaining?: (number|null);
        }

        class BattleStateProto implements IBattleStateProto {
            constructor(properties?: POGOProtos.Rpc.IBattleStateProto);
            public actors: { [k: string]: POGOProtos.Rpc.IBattleActorProto };
            public turn_start_ms: (number|Long);
            public turn: (number|Long);
            public ms_per_turn: number;
            public current_actor_id: string;
            public state: POGOProtos.Rpc.BattleStateProto.State;
            public active_actor_count: number;
            public team_actor_count: { [k: string]: number };
            public pokemon: { [k: string]: POGOProtos.Rpc.IBattlePokemonProto };
            public party_member_count: { [k: string]: number };
            public events: POGOProtos.Rpc.IBattleEventProto[];
            public battle_end_turn: (number|Long);
            public battle_start_turn: (number|Long);
            public ui_mode: POGOProtos.Rpc.BattleStateProto.UIMode;
            public allied_pokemon_remaining: number;
            public static encode(message: POGOProtos.Rpc.IBattleStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleStateProto;
            public static toObject(message: POGOProtos.Rpc.BattleStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleStateProto {

            enum State {
                UNSET_STATE = 0,
                STATE_ACCEPTED = 1,
                STATE_ERROR = 2,
                STATE_DEFAULT = 3,
                STATE_UPDATE = 4,
                STATE_BATTLE_END = 5,
                STATE_ERROR_BATTLE_END = 6,
                STATE_ERROR_PAUSED = 7,
                STATE_ERROR_UNAVAILABLE_BATTLE = 8,
                STATE_ERROR_UNAVAILABLE_TURN = 9,
                STATE_ERROR_UNAVAILABLE_ITEM = 10,
                STATE_ERROR_UNAVAILABLE_POKEMON = 11,
                STATE_ERROR_UNAVAILABLE_RESOURCE = 12
            }

            enum UIMode {
                MODE_DEFAULT = 0,
                MODE_PREBREAD = 1,
                MODE_BREADMODE = 2,
                MODE_SIDELINE = 3,
                MODE_SIDELINE_BREADMODE = 4,
                MODE_CM_OFFENSIVE_MINIGAME = 5,
                MODE_CM_DEFENSIVE_MINIGAME = 6,
                MODE_FLY_OUT_CM_MINIGAME = 7
            }
        }

        interface IBattleUpdateProto {
            battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            battle_id?: (string|null);
            active_defender?: (POGOProtos.Rpc.IPokemonInfo|null);
            active_attacker?: (POGOProtos.Rpc.IPokemonInfo|null);
            highest_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            render_effects?: (POGOProtos.Rpc.IFormRenderModifier[]|null);
            remaining_item?: (POGOProtos.Rpc.BattleUpdateProto.IAvailableItem[]|null);
            active_item?: (POGOProtos.Rpc.BattleUpdateProto.IActiveItem[]|null);
            ability_energy?: ({ [k: string]: POGOProtos.Rpc.IAbilityEnergyMetadata }|null);
            active_pokemon_stat_modifiers?: ({ [k: string]: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer }|null);
            party_member_count?: (number|null);
        }

        class BattleUpdateProto implements IBattleUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IBattleUpdateProto);
            public battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            public battle_id: string;
            public active_defender?: (POGOProtos.Rpc.IPokemonInfo|null);
            public active_attacker?: (POGOProtos.Rpc.IPokemonInfo|null);
            public highest_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public render_effects: POGOProtos.Rpc.IFormRenderModifier[];
            public remaining_item: POGOProtos.Rpc.BattleUpdateProto.IAvailableItem[];
            public active_item: POGOProtos.Rpc.BattleUpdateProto.IActiveItem[];
            public ability_energy: { [k: string]: POGOProtos.Rpc.IAbilityEnergyMetadata };
            public active_pokemon_stat_modifiers: { [k: string]: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer };
            public party_member_count: number;
            public static encode(message: POGOProtos.Rpc.IBattleUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleUpdateProto;
            public static toObject(message: POGOProtos.Rpc.BattleUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BattleUpdateProto {

            interface IActiveItem {
                item?: (POGOProtos.Rpc.IItemProto|null);
                user?: (string|null);
                usage_time_ms?: (number|Long|null);
                expiry_time_ms?: (number|Long|null);
            }

            class ActiveItem implements IActiveItem {
                constructor(properties?: POGOProtos.Rpc.BattleUpdateProto.IActiveItem);
                public item?: (POGOProtos.Rpc.IItemProto|null);
                public user: string;
                public usage_time_ms: (number|Long);
                public expiry_time_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.BattleUpdateProto.IActiveItem, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleUpdateProto.ActiveItem;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleUpdateProto.ActiveItem;
                public static toObject(message: POGOProtos.Rpc.BattleUpdateProto.ActiveItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAvailableItem {
                item?: (POGOProtos.Rpc.Item|null);
                quantity?: (number|null);
                next_available_ms?: (number|Long|null);
            }

            class AvailableItem implements IAvailableItem {
                constructor(properties?: POGOProtos.Rpc.BattleUpdateProto.IAvailableItem);
                public item: POGOProtos.Rpc.Item;
                public quantity: number;
                public next_available_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.BattleUpdateProto.IAvailableItem, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleUpdateProto.AvailableItem;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleUpdateProto.AvailableItem;
                public static toObject(message: POGOProtos.Rpc.BattleUpdateProto.AvailableItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBattleVisualSettingsProto {
            enhancements_enabled?: (boolean|null);
            crowd_texture_asset?: (string|null);
            banner_texture_asset?: (string|null);
        }

        class BattleVisualSettingsProto implements IBattleVisualSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBattleVisualSettingsProto);
            public enhancements_enabled: boolean;
            public crowd_texture_asset: string;
            public banner_texture_asset: string;
            public static encode(message: POGOProtos.Rpc.IBattleVisualSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BattleVisualSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BattleVisualSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BattleVisualSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaBleCompleteTransferRequestProto {
            transaction_id?: (number|Long|null);
            beluga_requested_item_id?: (number|null);
            nonce?: (string|null);
        }

        class BelugaBleCompleteTransferRequestProto implements IBelugaBleCompleteTransferRequestProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaBleCompleteTransferRequestProto);
            public transaction_id: (number|Long);
            public beluga_requested_item_id: number;
            public nonce: string;
            public static encode(message: POGOProtos.Rpc.IBelugaBleCompleteTransferRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaBleCompleteTransferRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaBleCompleteTransferRequestProto;
            public static toObject(message: POGOProtos.Rpc.BelugaBleCompleteTransferRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaBleFinalizeTransfer {
            beluga_transfer_complete?: (POGOProtos.Rpc.IBelugaBleTransferCompleteProto|null);
            server_signature?: (Uint8Array|null);
        }

        class BelugaBleFinalizeTransfer implements IBelugaBleFinalizeTransfer {
            constructor(properties?: POGOProtos.Rpc.IBelugaBleFinalizeTransfer);
            public beluga_transfer_complete?: (POGOProtos.Rpc.IBelugaBleTransferCompleteProto|null);
            public server_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IBelugaBleFinalizeTransfer, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaBleFinalizeTransfer;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaBleFinalizeTransfer;
            public static toObject(message: POGOProtos.Rpc.BelugaBleFinalizeTransfer, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaBleTransferCompleteProto {
            nonce?: (string|null);
            beluga_id?: (string|null);
        }

        class BelugaBleTransferCompleteProto implements IBelugaBleTransferCompleteProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaBleTransferCompleteProto);
            public nonce: string;
            public beluga_id: string;
            public static encode(message: POGOProtos.Rpc.IBelugaBleTransferCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaBleTransferCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaBleTransferCompleteProto;
            public static toObject(message: POGOProtos.Rpc.BelugaBleTransferCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaBleTransferPrepProto {
            pokemon_list?: (POGOProtos.Rpc.IBelugaPokemonProto[]|null);
            eligble_for_item?: (boolean|null);
            transaction_id?: (number|Long|null);
            beluga_id?: (string|null);
            nonce?: (string|null);
        }

        class BelugaBleTransferPrepProto implements IBelugaBleTransferPrepProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaBleTransferPrepProto);
            public pokemon_list: POGOProtos.Rpc.IBelugaPokemonProto[];
            public eligble_for_item: boolean;
            public transaction_id: (number|Long);
            public beluga_id: string;
            public nonce: string;
            public static encode(message: POGOProtos.Rpc.IBelugaBleTransferPrepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaBleTransferPrepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaBleTransferPrepProto;
            public static toObject(message: POGOProtos.Rpc.BelugaBleTransferPrepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaBleTransferProto {
            server_response?: (POGOProtos.Rpc.IBelugaBleTransferPrepProto|null);
            server_signature?: (Uint8Array|null);
            localized_origins?: (string[]|null);
            language?: (string|null);
        }

        class BelugaBleTransferProto implements IBelugaBleTransferProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaBleTransferProto);
            public server_response?: (POGOProtos.Rpc.IBelugaBleTransferPrepProto|null);
            public server_signature: Uint8Array;
            public localized_origins: string[];
            public language: string;
            public static encode(message: POGOProtos.Rpc.IBelugaBleTransferProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaBleTransferProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaBleTransferProto;
            public static toObject(message: POGOProtos.Rpc.BelugaBleTransferProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaDailyTransferLogEntry {
            result?: (POGOProtos.Rpc.BelugaDailyTransferLogEntry.Result|null);
            includes_weekly_bonus?: (boolean|null);
            items_awarded?: (POGOProtos.Rpc.ILootProto|null);
        }

        class BelugaDailyTransferLogEntry implements IBelugaDailyTransferLogEntry {
            constructor(properties?: POGOProtos.Rpc.IBelugaDailyTransferLogEntry);
            public result: POGOProtos.Rpc.BelugaDailyTransferLogEntry.Result;
            public includes_weekly_bonus: boolean;
            public items_awarded?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IBelugaDailyTransferLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaDailyTransferLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaDailyTransferLogEntry;
            public static toObject(message: POGOProtos.Rpc.BelugaDailyTransferLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BelugaDailyTransferLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IBelugaGlobalSettingsProto {
            enable_beluga_transfer?: (boolean|null);
            max_num_pokemon_per_transfer?: (number|null);
        }

        class BelugaGlobalSettingsProto implements IBelugaGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaGlobalSettingsProto);
            public enable_beluga_transfer: boolean;
            public max_num_pokemon_per_transfer: number;
            public static encode(message: POGOProtos.Rpc.IBelugaGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BelugaGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaIncenseBoxProto {
            is_usable?: (boolean|null);
            cool_down_finished_timestamp_ms?: (number|Long|null);
            sparkly_limit?: (POGOProtos.Rpc.IDailyCounterProto|null);
            sparkly_counter?: (number|null);
        }

        class BelugaIncenseBoxProto implements IBelugaIncenseBoxProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaIncenseBoxProto);
            public is_usable: boolean;
            public cool_down_finished_timestamp_ms: (number|Long);
            public sparkly_limit?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public sparkly_counter: number;
            public static encode(message: POGOProtos.Rpc.IBelugaIncenseBoxProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaIncenseBoxProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaIncenseBoxProto;
            public static toObject(message: POGOProtos.Rpc.BelugaIncenseBoxProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaPokemonProto {
            trainer_name?: (string|null);
            trainer_gender?: (POGOProtos.Rpc.BelugaPokemonProto.TrainerGender|null);
            trainer_team?: (POGOProtos.Rpc.BelugaPokemonProto.Team|null);
            trainer_level?: (number|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            pokemon_level?: (number|null);
            max_hp?: (number|null);
            origin_lat?: (number|null);
            origin_lng?: (number|null);
            height?: (number|null);
            weight?: (number|null);
            individual_attack?: (number|null);
            individual_defense?: (number|null);
            individual_stamina?: (number|null);
            creation_day?: (number|null);
            creation_month?: (number|null);
            creation_year?: (number|null);
            nickname?: (string|null);
            gender?: (POGOProtos.Rpc.BelugaPokemonProto.PokemonGender|null);
            costume?: (POGOProtos.Rpc.BelugaPokemonProto.PokemonCostume|null);
            form?: (POGOProtos.Rpc.BelugaPokemonProto.PokemonForm|null);
            shiny?: (boolean|null);
            move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
            move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class BelugaPokemonProto implements IBelugaPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaPokemonProto);
            public trainer_name: string;
            public trainer_gender: POGOProtos.Rpc.BelugaPokemonProto.TrainerGender;
            public trainer_team: POGOProtos.Rpc.BelugaPokemonProto.Team;
            public trainer_level: number;
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public pokemon_level: number;
            public max_hp: number;
            public origin_lat: number;
            public origin_lng: number;
            public height: number;
            public weight: number;
            public individual_attack: number;
            public individual_defense: number;
            public individual_stamina: number;
            public creation_day: number;
            public creation_month: number;
            public creation_year: number;
            public nickname: string;
            public gender: POGOProtos.Rpc.BelugaPokemonProto.PokemonGender;
            public costume: POGOProtos.Rpc.BelugaPokemonProto.PokemonCostume;
            public form: POGOProtos.Rpc.BelugaPokemonProto.PokemonForm;
            public shiny: boolean;
            public move1: POGOProtos.Rpc.HoloPokemonMove;
            public move2: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IBelugaPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaPokemonProto;
            public static toObject(message: POGOProtos.Rpc.BelugaPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BelugaPokemonProto {

            enum PokemonCostume {
                UNSET = 0,
                HOLIDAY_2016 = 1,
                ANNIVERSARY = 2,
                ONE_YEAR_ANNIVERSARY = 3,
                HALLOWEEN_2017 = 4
            }

            enum PokemonForm {
                FORM_UNSET = 0,
                ALOLA = 1
            }

            enum PokemonGender {
                GENDER_UNSET = 0,
                MALE = 1,
                FEMALE = 2,
                GENDERLESS = 3
            }

            enum Team {
                NONE = 0,
                TEAM_BLUE = 1,
                TEAM_RED = 2,
                TEAM_YELLOW = 3
            }

            enum TrainerGender {
                TRAINER_MALE = 0,
                TRAINER_FEMALE = 1
            }
        }

        interface IBelugaPokemonWhitelist {
            max_allowed_pokemon_pokedex_number?: (number|null);
            additional_pokemon_allowed?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            forms_allowed?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            costumes_allowed?: (POGOProtos.Rpc.PokemonDisplayProto.Costume[]|null);
        }

        class BelugaPokemonWhitelist implements IBelugaPokemonWhitelist {
            constructor(properties?: POGOProtos.Rpc.IBelugaPokemonWhitelist);
            public max_allowed_pokemon_pokedex_number: number;
            public additional_pokemon_allowed: POGOProtos.Rpc.HoloPokemonId[];
            public forms_allowed: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public costumes_allowed: POGOProtos.Rpc.PokemonDisplayProto.Costume[];
            public static encode(message: POGOProtos.Rpc.IBelugaPokemonWhitelist, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaPokemonWhitelist;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaPokemonWhitelist;
            public static toObject(message: POGOProtos.Rpc.BelugaPokemonWhitelist, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaTransactionCompleteOutProto {
            status?: (POGOProtos.Rpc.BelugaTransactionCompleteOutProto.Status|null);
            candy_awarded?: (number|null);
            loot_awarded?: (POGOProtos.Rpc.ILootProto|null);
            beluga_finalize_response?: (POGOProtos.Rpc.IBelugaBleFinalizeTransfer|null);
            buckets_until_weekly_award?: (number|null);
            xl_candy_awarded_per_id?: ({ [k: string]: number }|null);
        }

        class BelugaTransactionCompleteOutProto implements IBelugaTransactionCompleteOutProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaTransactionCompleteOutProto);
            public status: POGOProtos.Rpc.BelugaTransactionCompleteOutProto.Status;
            public candy_awarded: number;
            public loot_awarded?: (POGOProtos.Rpc.ILootProto|null);
            public beluga_finalize_response?: (POGOProtos.Rpc.IBelugaBleFinalizeTransfer|null);
            public buckets_until_weekly_award: number;
            public xl_candy_awarded_per_id: { [k: string]: number };
            public static encode(message: POGOProtos.Rpc.IBelugaTransactionCompleteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaTransactionCompleteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaTransactionCompleteOutProto;
            public static toObject(message: POGOProtos.Rpc.BelugaTransactionCompleteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BelugaTransactionCompleteOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILED = 2,
                ERROR_INVALID_POKEMON_ID = 3,
                ERROR_POKEMON_DEPLOYED = 4,
                ERROR_POKEMON_NOT_ALLOWED = 5,
                ERROR_POKEMON_IS_BUDDY = 6,
                ERROR_INVALID_TRANSACTION_ID = 7,
                ERROR_MISSING_TRANSACTION_ID = 8,
                ERROR_FUSION_POKEMON = 9,
                ERROR_FUSION_COMPONENT_POKEMON = 10
            }
        }

        interface IBelugaTransactionCompleteProto {
            beluga_transfer?: (POGOProtos.Rpc.IBelugaBleCompleteTransferRequestProto|null);
            app_signature?: (Uint8Array|null);
            firmware_signature?: (Uint8Array|null);
        }

        class BelugaTransactionCompleteProto implements IBelugaTransactionCompleteProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaTransactionCompleteProto);
            public beluga_transfer?: (POGOProtos.Rpc.IBelugaBleCompleteTransferRequestProto|null);
            public app_signature: Uint8Array;
            public firmware_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IBelugaTransactionCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaTransactionCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaTransactionCompleteProto;
            public static toObject(message: POGOProtos.Rpc.BelugaTransactionCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBelugaTransactionStartOutProto {
            status?: (POGOProtos.Rpc.BelugaTransactionStartOutProto.Status|null);
            beluga_transfer_prep?: (POGOProtos.Rpc.IBelugaBleTransferPrepProto|null);
            server_signature?: (Uint8Array|null);
        }

        class BelugaTransactionStartOutProto implements IBelugaTransactionStartOutProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaTransactionStartOutProto);
            public status: POGOProtos.Rpc.BelugaTransactionStartOutProto.Status;
            public beluga_transfer_prep?: (POGOProtos.Rpc.IBelugaBleTransferPrepProto|null);
            public server_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IBelugaTransactionStartOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaTransactionStartOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaTransactionStartOutProto;
            public static toObject(message: POGOProtos.Rpc.BelugaTransactionStartOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BelugaTransactionStartOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILED = 2,
                ERROR_INVALID_POKEMON_ID = 3,
                ERROR_POKEMON_DEPLOYED = 4,
                ERROR_POKEMON_IS_EGG = 5,
                ERROR_POKEMON_IS_BUDDY = 6,
                ERROR_POKEMON_NOT_ALLOWED = 7,
                ERROR_INVALID_NONCE = 8,
                ERROR_TOO_MANY_POKEMON = 9,
                ERROR_NO_POKEMON_SPECIFIED = 10,
                ERROR_FUSION_POKEMON = 11,
                ERROR_FUSION_COMPONENT_POKEMON = 12
            }
        }

        interface IBelugaTransactionStartProto {
            pokemon_id?: ((number|Long)[]|null);
            nonce?: (string|null);
            beluga_id?: (string|null);
        }

        class BelugaTransactionStartProto implements IBelugaTransactionStartProto {
            constructor(properties?: POGOProtos.Rpc.IBelugaTransactionStartProto);
            public pokemon_id: (number|Long)[];
            public nonce: string;
            public beluga_id: string;
            public static encode(message: POGOProtos.Rpc.IBelugaTransactionStartProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BelugaTransactionStartProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BelugaTransactionStartProto;
            public static toObject(message: POGOProtos.Rpc.BelugaTransactionStartProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBonusBoxProto {
            text?: (string|null);
            icon_type?: (POGOProtos.Rpc.BonusBoxProto.IconType|null);
            additional_display?: (POGOProtos.Rpc.BonusBoxProto.AdditionalDisplay|null);
            quantity?: (number|null);
        }

        class BonusBoxProto implements IBonusBoxProto {
            constructor(properties?: POGOProtos.Rpc.IBonusBoxProto);
            public text: string;
            public icon_type: POGOProtos.Rpc.BonusBoxProto.IconType;
            public additional_display: POGOProtos.Rpc.BonusBoxProto.AdditionalDisplay;
            public quantity: number;
            public static encode(message: POGOProtos.Rpc.IBonusBoxProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BonusBoxProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BonusBoxProto;
            public static toObject(message: POGOProtos.Rpc.BonusBoxProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BonusBoxProto {

            enum AdditionalDisplay {
                NONE = 0,
                PARTY_PLAY = 1,
                EVENT_PASS = 2
            }

            enum IconType {
                UNSET = 0,
                ADVENTURE_SYNC = 1,
                BUDDY = 2,
                CANDY_GENERAL = 3,
                EGG = 4,
                EGG_INCUBATOR = 5,
                EVENT_MOVE = 6,
                EVOLUTION = 7,
                FIELD_RESEARCH = 8,
                FRIENDSHIP = 9,
                GIFT = 10,
                INCENSE = 11,
                LUCKY_EGG = 12,
                LURE_MODULE = 13,
                PHOTOBOMB = 14,
                POKESTOP = 15,
                RAID = 16,
                RAID_PASS = 17,
                SPAWN_UNKNOWN = 18,
                STAR_PIECE = 19,
                STARDUST = 20,
                TEAM_ROCKET = 21,
                TRADE = 22,
                TRANSFER_CANDY = 23,
                BATTLE = 24,
                XP = 25,
                SHOP = 26,
                LOCATION = 27,
                EVENT = 28,
                MYSTERY_BOX = 29,
                TRADE_BALL = 30,
                CANDY_XL = 31,
                HEART = 32,
                TIMER = 33,
                POSTCARD = 34,
                STICKER = 35,
                ADVENTURE_EFFECT = 36,
                BREAD = 37,
                MAX_PARTICLE = 38,
                LEGENDARY = 39,
                POWER_UP_POKEMON = 40
            }
        }

        interface IBonusEffectSettingsProto {
            time_bonus?: (POGOProtos.Rpc.ITimeBonusSettingsProto|null);
            space_bonus?: (POGOProtos.Rpc.ISpaceBonusSettingsProto|null);
            day_night_bonus?: (POGOProtos.Rpc.IDayNightBonusSettingsProto|null);
            slow_freeze_bonus?: (POGOProtos.Rpc.ISlowFreezePlayerBonusSettingsProto|null);
            attack_defense_bonus?: (POGOProtos.Rpc.IAttackDefenseBonusSettingsProto|null);
        }

        class BonusEffectSettingsProto implements IBonusEffectSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBonusEffectSettingsProto);
            public time_bonus?: (POGOProtos.Rpc.ITimeBonusSettingsProto|null);
            public space_bonus?: (POGOProtos.Rpc.ISpaceBonusSettingsProto|null);
            public day_night_bonus?: (POGOProtos.Rpc.IDayNightBonusSettingsProto|null);
            public slow_freeze_bonus?: (POGOProtos.Rpc.ISlowFreezePlayerBonusSettingsProto|null);
            public attack_defense_bonus?: (POGOProtos.Rpc.IAttackDefenseBonusSettingsProto|null);
            public Bonus?: ("time_bonus"|"space_bonus"|"day_night_bonus"|"slow_freeze_bonus"|"attack_defense_bonus");
            public static encode(message: POGOProtos.Rpc.IBonusEffectSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BonusEffectSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BonusEffectSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BonusEffectSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBoolValue {
            value?: (boolean|null);
        }

        class BoolValue implements IBoolValue {
            constructor(properties?: POGOProtos.Rpc.IBoolValue);
            public value: boolean;
            public static encode(message: POGOProtos.Rpc.IBoolValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BoolValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BoolValue;
            public static toObject(message: POGOProtos.Rpc.BoolValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBootRaidOutProto {
            result?: (POGOProtos.Rpc.BootRaidOutProto.Result|null);
            lobby?: (POGOProtos.Rpc.ILobbyProto|null);
        }

        class BootRaidOutProto implements IBootRaidOutProto {
            constructor(properties?: POGOProtos.Rpc.IBootRaidOutProto);
            public result: POGOProtos.Rpc.BootRaidOutProto.Result;
            public lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            public static encode(message: POGOProtos.Rpc.IBootRaidOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BootRaidOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BootRaidOutProto;
            public static toObject(message: POGOProtos.Rpc.BootRaidOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BootRaidOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_FEATURE_DISABLED = 2,
                ERROR_LOBBY_NOT_FOUND = 3,
                ERROR_RAID_UNAVAILABLE = 4,
                ERROR_NOT_ENOUGH_TIME = 5
            }
        }

        interface IBootRaidProto {
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
        }

        class BootRaidProto implements IBootRaidProto {
            constructor(properties?: POGOProtos.Rpc.IBootRaidProto);
            public gym_id: string;
            public lobby_id: number[];
            public static encode(message: POGOProtos.Rpc.IBootRaidProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BootRaidProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BootRaidProto;
            public static toObject(message: POGOProtos.Rpc.BootRaidProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBootTelemetry {
            nearest_poi_distance?: (number|null);
            poi_within_one_km_count?: (number|null);
        }

        class BootTelemetry implements IBootTelemetry {
            constructor(properties?: POGOProtos.Rpc.IBootTelemetry);
            public nearest_poi_distance: number;
            public poi_within_one_km_count: number;
            public static encode(message: POGOProtos.Rpc.IBootTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BootTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BootTelemetry;
            public static toObject(message: POGOProtos.Rpc.BootTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBootTime {
            duration?: (POGOProtos.Rpc.IPlatformMetricData|null);
            boot_phase?: (POGOProtos.Rpc.BootTime.BootPhase|null);
            auth_provider?: (POGOProtos.Rpc.BootTime.AuthProvider|null);
            cached_login?: (boolean|null);
            adventure_sync_enabled?: (boolean|null);
            time_since_start_s?: (POGOProtos.Rpc.IPlatformMetricData|null);
        }

        class BootTime implements IBootTime {
            constructor(properties?: POGOProtos.Rpc.IBootTime);
            public duration?: (POGOProtos.Rpc.IPlatformMetricData|null);
            public boot_phase: POGOProtos.Rpc.BootTime.BootPhase;
            public auth_provider: POGOProtos.Rpc.BootTime.AuthProvider;
            public cached_login: boolean;
            public adventure_sync_enabled: boolean;
            public time_since_start_s?: (POGOProtos.Rpc.IPlatformMetricData|null);
            public static encode(message: POGOProtos.Rpc.IBootTime, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BootTime;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BootTime;
            public static toObject(message: POGOProtos.Rpc.BootTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BootTime {

            enum AuthProvider {
                UNKNOWN = 0,
                GOOGLE = 1,
                PTC = 2,
                FACEBOOK = 3,
                SUPER_AWESOME = 4,
                APPLE = 5,
                GUEST = 6,
                PTC_OAUTH = 7
            }

            enum BootPhase {
                UNDEFINED = 0,
                TIME_TO_MAP = 1,
                LOGO_SCREEN_TIME = 2,
                MAIN_SCENE_LOAD_TIME = 3,
                WAIT_FOR_AUTH = 4,
                INIT_REMOTE_CONFIG_VERSIONS = 5,
                INIT_BUNDLE_DIGEST = 6,
                INIT_GMT = 7,
                DOWNLOAD_I18N = 8,
                DOWNLOAD_GLOBAL_ASSETS = 9,
                REGISTER_PUSH_NOTIFICATION = 10,
                INITIALIZE_UPSIGHT = 11,
                INITIALIZE_CRITTERCISM = 12,
                LOGIN_VERSION_CHECK = 13,
                LOGIN_GET_PLAYER = 14,
                LOGIN_AUTHENTICATION = 15,
                MODAL_TIME = 16,
                INITIALIZE_ADJUST = 17,
                INITIALIZE_FIREBASE = 20,
                INITIALIZE_CRASHLYTICS = 21,
                INITIALIZE_BRAZE = 22,
                DOWNLOAD_BOOT_ADDRESSABLES = 23,
                INITIALIZE_OMNI = 24,
                CONFIGURE_ARDK = 25,
                LOAD_BOOT_SEQUENCE_GUI = 26,
                WAIT_SERVER_SEQUENCE_DONE = 27,
                SET_MAIN_SCENE_ACTIVE = 28,
                INSTALL_SCENE_CONTEXT = 29,
                WAIT_SHOW_MAP = 30,
                INITIALIZE_INPUT_TRACKER = 31
            }
        }

        interface IBoundingRect {
            north?: (number|null);
            south?: (number|null);
            east?: (number|null);
            west?: (number|null);
        }

        class BoundingRect implements IBoundingRect {
            constructor(properties?: POGOProtos.Rpc.IBoundingRect);
            public north: number;
            public south: number;
            public east: number;
            public west: number;
            public static encode(message: POGOProtos.Rpc.IBoundingRect, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BoundingRect;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BoundingRect;
            public static toObject(message: POGOProtos.Rpc.BoundingRect, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBatteInvitationDetails {
            station_id?: (string|null);
            bread_lobby_id?: (number|Long|null);
            bread_battle_seed?: (number|Long|null);
            bread_battle_invitation_expire_ms?: (number|Long|null);
            bread_battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
            station_name?: (string|null);
            image_url?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            bread_battle_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            bread_battle_pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            inviter_id?: (string|null);
            inviter_nickname?: (string|null);
            inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            inviter_team?: (POGOProtos.Rpc.Team|null);
            bread_battle_pokemon_temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            bread_battle_pokemon_costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            bread_battle_visual_level?: (number|Long|null);
            inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class BreadBatteInvitationDetails implements IBreadBatteInvitationDetails {
            constructor(properties?: POGOProtos.Rpc.IBreadBatteInvitationDetails);
            public station_id: string;
            public bread_lobby_id: (number|Long);
            public bread_battle_seed: (number|Long);
            public bread_battle_invitation_expire_ms: (number|Long);
            public bread_battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public station_name: string;
            public image_url: string;
            public latitude: number;
            public longitude: number;
            public bread_battle_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public bread_battle_pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public inviter_id: string;
            public inviter_nickname: string;
            public inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public inviter_team: POGOProtos.Rpc.Team;
            public bread_battle_pokemon_temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public bread_battle_pokemon_costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public bread_battle_visual_level: (number|Long);
            public inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.IBreadBatteInvitationDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBatteInvitationDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBatteInvitationDetails;
            public static toObject(message: POGOProtos.Rpc.BreadBatteInvitationDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleClientSettingsProto {
            remote_bread_battle_enabled?: (boolean|null);
            max_power_crystal_allowed?: (number|null);
            bread_battle_min_player_level?: (number|null);
            remote_bread_battle_min_player_level?: (number|null);
            max_num_friend_invites?: (number|null);
            friend_invite_cutoff_time_sec?: (number|null);
            can_invite_friends_in_person?: (boolean|null);
            can_invite_friends_remotely?: (boolean|null);
            max_players_per_bread_lobby?: (number|null);
            max_remote_players_per_bread_lobby?: (number|null);
            max_players_per_bread_dough_lobby?: (number|null);
            max_remote_players_per_bread_dough_lobby?: (number|null);
            invite_cooldown_duration_millis?: (number|Long|null);
            max_num_friend_invites_per_action?: (number|null);
            prepare_bread_lobby_enabled?: (boolean|null);
            friend_requests_enabled?: (boolean|null);
            failed_friend_invite_info_enabled?: (boolean|null);
            min_players_to_prepare_bread_lobby?: (number|null);
            prepare_bread_lobby_cutoff_ms?: (number|null);
            prepare_bread_lobby_solo_ms?: (number|null);
            rvn_version?: (number|null);
            battle_rewards_version?: (number|null);
            min_players_to_prepare_bread_dough_lobby?: (number|null);
            max_remote_bread_battle_passes_allowed?: (number|null);
            unsupported_bread_battle_levels_for_friend_invites?: (POGOProtos.Rpc.BreadBattleLevel[]|null);
            remote_bread_battle_distance_validation?: (boolean|null);
            max_num_friend_invites_to_bread_dough_lobby_per_action?: (number|null);
        }

        class BreadBattleClientSettingsProto implements IBreadBattleClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleClientSettingsProto);
            public remote_bread_battle_enabled: boolean;
            public max_power_crystal_allowed: number;
            public bread_battle_min_player_level: number;
            public remote_bread_battle_min_player_level: number;
            public max_num_friend_invites: number;
            public friend_invite_cutoff_time_sec: number;
            public can_invite_friends_in_person: boolean;
            public can_invite_friends_remotely: boolean;
            public max_players_per_bread_lobby: number;
            public max_remote_players_per_bread_lobby: number;
            public max_players_per_bread_dough_lobby: number;
            public max_remote_players_per_bread_dough_lobby: number;
            public invite_cooldown_duration_millis: (number|Long);
            public max_num_friend_invites_per_action: number;
            public prepare_bread_lobby_enabled: boolean;
            public friend_requests_enabled: boolean;
            public failed_friend_invite_info_enabled: boolean;
            public min_players_to_prepare_bread_lobby: number;
            public prepare_bread_lobby_cutoff_ms: number;
            public prepare_bread_lobby_solo_ms: number;
            public rvn_version: number;
            public battle_rewards_version: number;
            public min_players_to_prepare_bread_dough_lobby: number;
            public max_remote_bread_battle_passes_allowed: number;
            public unsupported_bread_battle_levels_for_friend_invites: POGOProtos.Rpc.BreadBattleLevel[];
            public remote_bread_battle_distance_validation: boolean;
            public max_num_friend_invites_to_bread_dough_lobby_per_action: number;
            public static encode(message: POGOProtos.Rpc.IBreadBattleClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadBattleClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleCreateDetail {
            bread_battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
        }

        class BreadBattleCreateDetail implements IBreadBattleCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleCreateDetail);
            public bread_battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public static encode(message: POGOProtos.Rpc.IBreadBattleCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleCreateDetail;
            public static toObject(message: POGOProtos.Rpc.BreadBattleCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleDetailProto {
            bread_battle_seed?: (number|Long|null);
            battle_spawn_ms?: (number|Long|null);
            battle_window_start_ms?: (number|Long|null);
            battle_window_end_ms?: (number|Long|null);
            battle_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            complete?: (boolean|null);
            saved_for_later?: (boolean|null);
            battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
            min_recommended_player_count?: (number|null);
            max_recommended_player_count?: (number|null);
        }

        class BreadBattleDetailProto implements IBreadBattleDetailProto {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleDetailProto);
            public bread_battle_seed: (number|Long);
            public battle_spawn_ms: (number|Long);
            public battle_window_start_ms: (number|Long);
            public battle_window_end_ms: (number|Long);
            public battle_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public complete: boolean;
            public saved_for_later: boolean;
            public battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public min_recommended_player_count: number;
            public max_recommended_player_count: number;
            public static encode(message: POGOProtos.Rpc.IBreadBattleDetailProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleDetailProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleDetailProto;
            public static toObject(message: POGOProtos.Rpc.BreadBattleDetailProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleInvitationDetails {
            station_id?: (string|null);
            bread_lobby_id?: (number|Long|null);
            bread_battle_seed?: (number|Long|null);
            bread_battle_invitation_expire_ms?: (number|Long|null);
            bread_battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
            station_name?: (string|null);
            image_url?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            bread_battle_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            bread_battle_pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            inviter_id?: (string|null);
            inviter_nickname?: (string|null);
            inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            inviter_team?: (POGOProtos.Rpc.Team|null);
            bread_battle_pokemon_temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            bread_battle_pokemon_costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            bread_battle_visual_level?: (number|Long|null);
            inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            pokemon_display_data?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            bread_battle_pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
        }

        class BreadBattleInvitationDetails implements IBreadBattleInvitationDetails {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleInvitationDetails);
            public station_id: string;
            public bread_lobby_id: (number|Long);
            public bread_battle_seed: (number|Long);
            public bread_battle_invitation_expire_ms: (number|Long);
            public bread_battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public station_name: string;
            public image_url: string;
            public latitude: number;
            public longitude: number;
            public bread_battle_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public bread_battle_pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public inviter_id: string;
            public inviter_nickname: string;
            public inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public inviter_team: POGOProtos.Rpc.Team;
            public bread_battle_pokemon_temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public bread_battle_pokemon_costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public bread_battle_visual_level: (number|Long);
            public inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public pokemon_display_data?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public bread_battle_pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public static encode(message: POGOProtos.Rpc.IBreadBattleInvitationDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleInvitationDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleInvitationDetails;
            public static toObject(message: POGOProtos.Rpc.BreadBattleInvitationDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleParticipantProto {
            trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            bread_lobby_pokemon?: (POGOProtos.Rpc.IBreadLobbyPokemonProto[]|null);
            highest_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            friend_codename?: (string[]|null);
            is_remote?: (boolean|null);
            is_invited?: (boolean|null);
            bread_lobby_join_time_ms?: (number|Long|null);
            last_player_join_time_ms?: (number|Long|null);
            last_player_quit_time_ms?: (number|Long|null);
            player_id?: (string|null);
            remote_friends?: (number|null);
            local_friends?: (number|null);
            last_update_time_ms?: (number|Long|null);
            prepare_bread_battle_state?: (boolean|null);
            enabled_raid_friend_requests?: (boolean|null);
            player_number?: (number|null);
            active_battle_items?: (POGOProtos.Rpc.Item[]|null);
            inviter_id?: (string|null);
        }

        class BreadBattleParticipantProto implements IBreadBattleParticipantProto {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleParticipantProto);
            public trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public bread_lobby_pokemon: POGOProtos.Rpc.IBreadLobbyPokemonProto[];
            public highest_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public friend_codename: string[];
            public is_remote: boolean;
            public is_invited: boolean;
            public bread_lobby_join_time_ms: (number|Long);
            public last_player_join_time_ms: (number|Long);
            public last_player_quit_time_ms: (number|Long);
            public player_id: string;
            public remote_friends: number;
            public local_friends: number;
            public last_update_time_ms: (number|Long);
            public prepare_bread_battle_state: boolean;
            public enabled_raid_friend_requests: boolean;
            public player_number: number;
            public active_battle_items: POGOProtos.Rpc.Item[];
            public inviter_id: string;
            public static encode(message: POGOProtos.Rpc.IBreadBattleParticipantProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleParticipantProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleParticipantProto;
            public static toObject(message: POGOProtos.Rpc.BreadBattleParticipantProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleResultsProto {
            station_state?: (POGOProtos.Rpc.IStationProto|null);
            battle_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
            upgrade_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
            upgrade_cost?: (POGOProtos.Rpc.ICurrencyQuantityProto|null);
            post_battle_encounter?: (POGOProtos.Rpc.IRaidEncounterProto|null);
            battle_duration_ms?: (number|Long|null);
            leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            participant_pokemon_ids?: ((number|Long)[]|null);
            upgrade_ball_reward?: (number|null);
            upgrade_sku?: (string|null);
            rsvp_follow_through_pokeballs?: (number|null);
            battle_item_local_bonus_rewards?: (POGOProtos.Rpc.ILootProto|null);
            battle_item_rewards_from_player_activity?: (POGOProtos.Rpc.ILootProto|null);
        }

        class BreadBattleResultsProto implements IBreadBattleResultsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleResultsProto);
            public station_state?: (POGOProtos.Rpc.IStationProto|null);
            public battle_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
            public upgrade_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
            public upgrade_cost?: (POGOProtos.Rpc.ICurrencyQuantityProto|null);
            public post_battle_encounter?: (POGOProtos.Rpc.IRaidEncounterProto|null);
            public battle_duration_ms: (number|Long);
            public leveled_up_friends?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            public participant_pokemon_ids: (number|Long)[];
            public upgrade_ball_reward: number;
            public upgrade_sku: string;
            public rsvp_follow_through_pokeballs: number;
            public battle_item_local_bonus_rewards?: (POGOProtos.Rpc.ILootProto|null);
            public battle_item_rewards_from_player_activity?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IBreadBattleResultsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleResultsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleResultsProto;
            public static toObject(message: POGOProtos.Rpc.BreadBattleResultsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadBattleRewardsLogEntry {
            result?: (POGOProtos.Rpc.BreadBattleRewardsLogEntry.Result|null);
            items?: (POGOProtos.Rpc.IItemProto[]|null);
            stardust?: (number|null);
            stickers?: (POGOProtos.Rpc.ILootItemProto[]|null);
            candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
            xp?: (number|null);
        }

        class BreadBattleRewardsLogEntry implements IBreadBattleRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleRewardsLogEntry);
            public result: POGOProtos.Rpc.BreadBattleRewardsLogEntry.Result;
            public items: POGOProtos.Rpc.IItemProto[];
            public stardust: number;
            public stickers: POGOProtos.Rpc.ILootItemProto[];
            public candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public xp: number;
            public static encode(message: POGOProtos.Rpc.IBreadBattleRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.BreadBattleRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadBattleRewardsLogEntry {

            enum Result {
                FAIL = 0,
                SUCCESS = 1
            }
        }

        interface IBreadBattleUpgradeRewardsLogEntry {
            result?: (POGOProtos.Rpc.BreadBattleUpgradeRewardsLogEntry.Result|null);
            items?: (POGOProtos.Rpc.IItemProto[]|null);
            stardust?: (number|null);
            stickers?: (POGOProtos.Rpc.ILootItemProto[]|null);
            candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
        }

        class BreadBattleUpgradeRewardsLogEntry implements IBreadBattleUpgradeRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IBreadBattleUpgradeRewardsLogEntry);
            public result: POGOProtos.Rpc.BreadBattleUpgradeRewardsLogEntry.Result;
            public items: POGOProtos.Rpc.IItemProto[];
            public stardust: number;
            public stickers: POGOProtos.Rpc.ILootItemProto[];
            public candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public static encode(message: POGOProtos.Rpc.IBreadBattleUpgradeRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadBattleUpgradeRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadBattleUpgradeRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.BreadBattleUpgradeRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadBattleUpgradeRewardsLogEntry {

            enum Result {
                FAIL = 0,
                SUCCESS = 1
            }
        }

        interface IBreadClientLogProto {
            header?: (POGOProtos.Rpc.IRaidLogHeader|null);
            entries?: (POGOProtos.Rpc.BreadClientLogProto.IBreadLogEntryProto[]|null);
        }

        class BreadClientLogProto implements IBreadClientLogProto {
            constructor(properties?: POGOProtos.Rpc.IBreadClientLogProto);
            public header?: (POGOProtos.Rpc.IRaidLogHeader|null);
            public entries: POGOProtos.Rpc.BreadClientLogProto.IBreadLogEntryProto[];
            public static encode(message: POGOProtos.Rpc.IBreadClientLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadClientLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadClientLogProto;
            public static toObject(message: POGOProtos.Rpc.BreadClientLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadClientLogProto {

            interface IBreadLogEntryProto {
                header?: (POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.IBreadHeaderProto|null);
            }

            class BreadLogEntryProto implements IBreadLogEntryProto {
                constructor(properties?: POGOProtos.Rpc.BreadClientLogProto.IBreadLogEntryProto);
                public header?: (POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.IBreadHeaderProto|null);
                public static encode(message: POGOProtos.Rpc.BreadClientLogProto.IBreadLogEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto;
                public static toObject(message: POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BreadLogEntryProto {

                interface IBreadHeaderProto {
                    type?: (POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.BreadHeaderProto.HeaderType|null);
                    time_now_offset_ms?: (number|null);
                }

                class BreadHeaderProto implements IBreadHeaderProto {
                    constructor(properties?: POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.IBreadHeaderProto);
                    public type: POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.BreadHeaderProto.HeaderType;
                    public time_now_offset_ms: number;
                    public static encode(message: POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.IBreadHeaderProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.BreadHeaderProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.BreadHeaderProto;
                    public static toObject(message: POGOProtos.Rpc.BreadClientLogProto.BreadLogEntryProto.BreadHeaderProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace BreadHeaderProto {

                    enum HeaderType {
                        NO_TYPE = 0
                    }
                }
            }
        }

        interface IBreadFeatureFlagsProto {
            enabled?: (boolean|null);
            discovery_enabled?: (boolean|null);
            mp_enabled?: (boolean|null);
            save_for_later_enabled?: (boolean|null);
            station_discovery_mode?: (POGOProtos.Rpc.BreadFeatureFlagsProto.StationDiscoveryMode|null);
            battle_spawn_mode?: (POGOProtos.Rpc.BreadFeatureFlagsProto.SpawnMode|null);
            battle_enabled?: (boolean|null);
            nearby_lobby_counter_enabled?: (boolean|null);
            minimum_player_level?: (number|null);
            bread_post_battle_recovery_enabled?: (boolean|null);
            power_spot_edits_enabled?: (boolean|null);
            can_use_master_ball_post_battle?: (boolean|null);
            boost_item_enabled?: (boolean|null);
            lobby_push_update_enabled?: (boolean|null);
            debug_rpc_enabled?: (boolean|null);
        }

        class BreadFeatureFlagsProto implements IBreadFeatureFlagsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadFeatureFlagsProto);
            public enabled: boolean;
            public discovery_enabled: boolean;
            public mp_enabled: boolean;
            public save_for_later_enabled: boolean;
            public station_discovery_mode: POGOProtos.Rpc.BreadFeatureFlagsProto.StationDiscoveryMode;
            public battle_spawn_mode: POGOProtos.Rpc.BreadFeatureFlagsProto.SpawnMode;
            public battle_enabled: boolean;
            public nearby_lobby_counter_enabled: boolean;
            public minimum_player_level: number;
            public bread_post_battle_recovery_enabled: boolean;
            public power_spot_edits_enabled: boolean;
            public can_use_master_ball_post_battle: boolean;
            public boost_item_enabled: boolean;
            public lobby_push_update_enabled: boolean;
            public debug_rpc_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IBreadFeatureFlagsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadFeatureFlagsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadFeatureFlagsProto;
            public static toObject(message: POGOProtos.Rpc.BreadFeatureFlagsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadFeatureFlagsProto {

            enum StationDiscoveryMode {
                NONE = 0,
                STATIC_STATIONS = 1,
                DYNAMIC_STATIONS = 2
            }

            enum SpawnMode {
                NO_SPAWN = 0,
                STATIC_SPAWN = 1,
                GMT_SPAWN = 2
            }
        }

        interface IBreadGroupSettings {
        }

        class BreadGroupSettings implements IBreadGroupSettings {
            constructor(properties?: POGOProtos.Rpc.IBreadGroupSettings);
            public static encode(message: POGOProtos.Rpc.IBreadGroupSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadGroupSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadGroupSettings;
            public static toObject(message: POGOProtos.Rpc.BreadGroupSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadGroupSettings {

            enum BreadTierGroup {
                BREAD_TIER_GROUPS_UNSET = 0,
                GROUP_1 = 1,
                GROUP_2 = 2,
                GROUP_3 = 3,
                GROUP_4 = 4,
                GROUP_5 = 5,
                GROUP_6 = 6,
                GROUP_Z = 7
            }
        }

        interface IBreadLobbyCounterData {
            station_id?: (string|null);
            player_count?: (number|null);
            bread_lobby_join_end_ms?: (number|Long|null);
        }

        class BreadLobbyCounterData implements IBreadLobbyCounterData {
            constructor(properties?: POGOProtos.Rpc.IBreadLobbyCounterData);
            public station_id: string;
            public player_count: number;
            public bread_lobby_join_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBreadLobbyCounterData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadLobbyCounterData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadLobbyCounterData;
            public static toObject(message: POGOProtos.Rpc.BreadLobbyCounterData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadLobbyCounterSettingsProto {
            show_counter_radius_meters?: (number|null);
            subscribe_s2_level?: (number|null);
            subscription_namespace?: (string|null);
            publish_cutoff_time_ms?: (number|Long|null);
            server_publish_rate_limit_interval_ms?: (number|Long|null);
            bread_dough_lobby_max_count_to_update?: (number|null);
        }

        class BreadLobbyCounterSettingsProto implements IBreadLobbyCounterSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadLobbyCounterSettingsProto);
            public show_counter_radius_meters: number;
            public subscribe_s2_level: number;
            public subscription_namespace: string;
            public publish_cutoff_time_ms: (number|Long);
            public server_publish_rate_limit_interval_ms: (number|Long);
            public bread_dough_lobby_max_count_to_update: number;
            public static encode(message: POGOProtos.Rpc.IBreadLobbyCounterSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadLobbyCounterSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadLobbyCounterSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadLobbyCounterSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadLobbyPokemonProto {
            id?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            percent_health?: (number|null);
        }

        class BreadLobbyPokemonProto implements IBreadLobbyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IBreadLobbyPokemonProto);
            public id: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public percent_health: number;
            public static encode(message: POGOProtos.Rpc.IBreadLobbyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadLobbyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadLobbyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.BreadLobbyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadLobbyProto {
            bread_lobby_id?: (number|Long|null);
            players?: (POGOProtos.Rpc.IBreadBattleParticipantProto[]|null);
            player_join_end_ms?: (number|Long|null);
            pokemon_selection_end_ms?: (number|Long|null);
            bread_battle_start_ms?: (number|Long|null);
            bread_battle_end_ms?: (number|Long|null);
            bread_battle_id?: (string|null);
            owner_nickname?: (string|null);
            bread_dough_mode?: (boolean|null);
            creation_ms?: (number|Long|null);
            weather_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            invited_player_ids?: (string[]|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            rvn_version?: (number|null);
            is_private?: (boolean|null);
            station_boost_level?: (number|null);
        }

        class BreadLobbyProto implements IBreadLobbyProto {
            constructor(properties?: POGOProtos.Rpc.IBreadLobbyProto);
            public bread_lobby_id: (number|Long);
            public players: POGOProtos.Rpc.IBreadBattleParticipantProto[];
            public player_join_end_ms: (number|Long);
            public pokemon_selection_end_ms: (number|Long);
            public bread_battle_start_ms: (number|Long);
            public bread_battle_end_ms: (number|Long);
            public bread_battle_id: string;
            public owner_nickname: string;
            public bread_dough_mode: boolean;
            public creation_ms: (number|Long);
            public weather_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public invited_player_ids: string[];
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public rvn_version: number;
            public is_private: boolean;
            public station_boost_level: number;
            public static encode(message: POGOProtos.Rpc.IBreadLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadLobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadLobbyProto;
            public static toObject(message: POGOProtos.Rpc.BreadLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadLobbyUpdateSettingsProto {
            subscription_namespace?: (string|null);
            join_publish_cutoff_time_ms?: (number|Long|null);
            server_publish_rate_limit_interval_ms?: (number|Long|null);
        }

        class BreadLobbyUpdateSettingsProto implements IBreadLobbyUpdateSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadLobbyUpdateSettingsProto);
            public subscription_namespace: string;
            public join_publish_cutoff_time_ms: (number|Long);
            public server_publish_rate_limit_interval_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBreadLobbyUpdateSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadLobbyUpdateSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadLobbyUpdateSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadLobbyUpdateSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadModeEnum {
        }

        class BreadModeEnum implements IBreadModeEnum {
            constructor(properties?: POGOProtos.Rpc.IBreadModeEnum);
            public static encode(message: POGOProtos.Rpc.IBreadModeEnum, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadModeEnum;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadModeEnum;
            public static toObject(message: POGOProtos.Rpc.BreadModeEnum, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadModeEnum {

            enum Modifier {
                NONE = 0,
                BREAD_MODE = 1,
                BREAD_DOUGH_MODE = 2,
                BREAD_DOUGH_MODE_2 = 3,
                BREAD_SPECIAL_MODE = 4
            }
        }

        interface IBreadMoveLevelSettingsProto {
            group?: (POGOProtos.Rpc.BreadGroupSettings.BreadTierGroup|null);
            asettings?: (POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto[]|null);
            bsettings?: (POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto[]|null);
            csettings?: (POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto[]|null);
            xp_reward?: (number[]|null);
        }

        class BreadMoveLevelSettingsProto implements IBreadMoveLevelSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadMoveLevelSettingsProto);
            public group: POGOProtos.Rpc.BreadGroupSettings.BreadTierGroup;
            public asettings: POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto[];
            public bsettings: POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto[];
            public csettings: POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto[];
            public xp_reward: number[];
            public static encode(message: POGOProtos.Rpc.IBreadMoveLevelSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadMoveLevelSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadMoveLevelSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadMoveLevelSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadMoveLevelSettingsProto {

            interface IBreadMoveLevelProto {
                mp_cost?: (number|null);
                candy_cost?: (number|null);
                xl_candy_cost?: (number|null);
                multiplier?: (number|null);
                xp_reward?: (number|null);
                stardust_cost?: (number|null);
            }

            class BreadMoveLevelProto implements IBreadMoveLevelProto {
                constructor(properties?: POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto);
                public mp_cost: number;
                public candy_cost: number;
                public xl_candy_cost: number;
                public multiplier: number;
                public xp_reward: number;
                public stardust_cost: number;
                public static encode(message: POGOProtos.Rpc.BreadMoveLevelSettingsProto.IBreadMoveLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadMoveLevelSettingsProto.BreadMoveLevelProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadMoveLevelSettingsProto.BreadMoveLevelProto;
                public static toObject(message: POGOProtos.Rpc.BreadMoveLevelSettingsProto.BreadMoveLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBreadMoveMappingProto {
            type?: (POGOProtos.Rpc.HoloPokemonType|null);
            move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class BreadMoveMappingProto implements IBreadMoveMappingProto {
            constructor(properties?: POGOProtos.Rpc.IBreadMoveMappingProto);
            public type: POGOProtos.Rpc.HoloPokemonType;
            public move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IBreadMoveMappingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadMoveMappingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadMoveMappingProto;
            public static toObject(message: POGOProtos.Rpc.BreadMoveMappingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadMoveMappingSettingsProto {
            mappings?: (POGOProtos.Rpc.IBreadMoveMappingProto[]|null);
        }

        class BreadMoveMappingSettingsProto implements IBreadMoveMappingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadMoveMappingSettingsProto);
            public mappings: POGOProtos.Rpc.IBreadMoveMappingProto[];
            public static encode(message: POGOProtos.Rpc.IBreadMoveMappingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadMoveMappingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadMoveMappingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadMoveMappingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadMoveSlotProto {
            move_type?: (POGOProtos.Rpc.BreadMoveSlotProto.BreadMoveType|null);
            move_level?: (POGOProtos.Rpc.BreadMoveLevels|null);
        }

        class BreadMoveSlotProto implements IBreadMoveSlotProto {
            constructor(properties?: POGOProtos.Rpc.IBreadMoveSlotProto);
            public move_type: POGOProtos.Rpc.BreadMoveSlotProto.BreadMoveType;
            public move_level: POGOProtos.Rpc.BreadMoveLevels;
            public static encode(message: POGOProtos.Rpc.IBreadMoveSlotProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadMoveSlotProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadMoveSlotProto;
            public static toObject(message: POGOProtos.Rpc.BreadMoveSlotProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadMoveSlotProto {

            enum BreadMoveType {
                UNSET = 0,
                A = 1,
                B = 2,
                C = 3
            }
        }

        interface IBreadOverrideExtendedProto {
            bread_mode?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
            average_height_m?: (number|null);
            average_weight_kg?: (number|null);
            size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            camera?: (POGOProtos.Rpc.IPokemonCameraAttributesProto|null);
            model_scale_v2?: (number|null);
            model_height?: (number|null);
            catch_override_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IBreadCatchOverrideProto|null);
            max_encounter_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            max_battle_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            max_battle_trainer_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            max_station_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            max_powerspot_topper_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
        }

        class BreadOverrideExtendedProto implements IBreadOverrideExtendedProto {
            constructor(properties?: POGOProtos.Rpc.IBreadOverrideExtendedProto);
            public bread_mode: POGOProtos.Rpc.BreadModeEnum.Modifier;
            public average_height_m: number;
            public average_weight_kg: number;
            public size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            public camera?: (POGOProtos.Rpc.IPokemonCameraAttributesProto|null);
            public model_scale_v2: number;
            public model_height: number;
            public catch_override_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IBreadCatchOverrideProto|null);
            public max_encounter_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            public max_battle_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            public max_battle_trainer_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            public max_station_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            public max_powerspot_topper_visual_settings?: (POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IBreadOverrideExtendedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadOverrideExtendedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadOverrideExtendedProto;
            public static toObject(message: POGOProtos.Rpc.BreadOverrideExtendedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadOverrideExtendedProto {

            interface IBreadCatchOverrideProto {
                collision_radius_m?: (number|null);
                collision_height_m?: (number|null);
                collision_head_radius_m?: (number|null);
            }

            class BreadCatchOverrideProto implements IBreadCatchOverrideProto {
                constructor(properties?: POGOProtos.Rpc.BreadOverrideExtendedProto.IBreadCatchOverrideProto);
                public collision_radius_m: number;
                public collision_height_m: number;
                public collision_head_radius_m: number;
                public static encode(message: POGOProtos.Rpc.BreadOverrideExtendedProto.IBreadCatchOverrideProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadOverrideExtendedProto.BreadCatchOverrideProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadOverrideExtendedProto.BreadCatchOverrideProto;
                public static toObject(message: POGOProtos.Rpc.BreadOverrideExtendedProto.BreadCatchOverrideProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMaxPokemonVisualSettingsProto {
                scale?: (number|null);
                camera_distance?: (number|null);
                max_reticle_size?: (number|null);
                xoffset?: (number|null);
                yoffset?: (number|null);
            }

            class MaxPokemonVisualSettingsProto implements IMaxPokemonVisualSettingsProto {
                constructor(properties?: POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto);
                public scale: number;
                public camera_distance: number;
                public max_reticle_size: number;
                public xoffset: number;
                public yoffset: number;
                public static encode(message: POGOProtos.Rpc.BreadOverrideExtendedProto.IMaxPokemonVisualSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadOverrideExtendedProto.MaxPokemonVisualSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadOverrideExtendedProto.MaxPokemonVisualSettingsProto;
                public static toObject(message: POGOProtos.Rpc.BreadOverrideExtendedProto.MaxPokemonVisualSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBreadOverrideProto {
            bread_mode?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
            average_height_m?: (number|null);
            average_weight_kg?: (number|null);
        }

        class BreadOverrideProto implements IBreadOverrideProto {
            constructor(properties?: POGOProtos.Rpc.IBreadOverrideProto);
            public bread_mode: POGOProtos.Rpc.BreadModeEnum.Modifier;
            public average_height_m: number;
            public average_weight_kg: number;
            public static encode(message: POGOProtos.Rpc.IBreadOverrideProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadOverrideProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadOverrideProto;
            public static toObject(message: POGOProtos.Rpc.BreadOverrideProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadPokemonAllowlist {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            bread_mode?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
        }

        class BreadPokemonAllowlist implements IBreadPokemonAllowlist {
            constructor(properties?: POGOProtos.Rpc.IBreadPokemonAllowlist);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public bread_mode: POGOProtos.Rpc.BreadModeEnum.Modifier;
            public static encode(message: POGOProtos.Rpc.IBreadPokemonAllowlist, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadPokemonAllowlist;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadPokemonAllowlist;
            public static toObject(message: POGOProtos.Rpc.BreadPokemonAllowlist, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBreadPokemonScalingSettingsProto {
            visual_settings?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.IBreadPokemonVisualSettingsProto[]|null);
        }

        class BreadPokemonScalingSettingsProto implements IBreadPokemonScalingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadPokemonScalingSettingsProto);
            public visual_settings: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.IBreadPokemonVisualSettingsProto[];
            public static encode(message: POGOProtos.Rpc.IBreadPokemonScalingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadPokemonScalingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadPokemonScalingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadPokemonScalingSettingsProto {

            interface IBreadPokemonVisualSettingsProto {
                pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                pokemon_form_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.IBreadPokemonFormVisualDataProto[]|null);
            }

            class BreadPokemonVisualSettingsProto implements IBreadPokemonVisualSettingsProto {
                constructor(properties?: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.IBreadPokemonVisualSettingsProto);
                public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
                public pokemon_form_data: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.IBreadPokemonFormVisualDataProto[];
                public static encode(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.IBreadPokemonVisualSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto;
                public static toObject(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BreadPokemonVisualSettingsProto {

                interface IBreadPokemonFormVisualDataProto {
                    pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
                    visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.IBreadPokemonModeVisualDataProto[]|null);
                }

                class BreadPokemonFormVisualDataProto implements IBreadPokemonFormVisualDataProto {
                    constructor(properties?: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.IBreadPokemonFormVisualDataProto);
                    public pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
                    public visual_data: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.IBreadPokemonModeVisualDataProto[];
                    public static encode(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.IBreadPokemonFormVisualDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto;
                    public static toObject(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace BreadPokemonFormVisualDataProto {

                    interface IBreadPokemonModeVisualDataProto {
                        bread_mode?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
                        bread_encounter_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        bread_battle_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        bread_battle_boss_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        bread_battle_trainer_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        bread_station_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                    }

                    class BreadPokemonModeVisualDataProto implements IBreadPokemonModeVisualDataProto {
                        constructor(properties?: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.IBreadPokemonModeVisualDataProto);
                        public bread_mode: POGOProtos.Rpc.BreadModeEnum.Modifier;
                        public bread_encounter_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        public bread_battle_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        public bread_battle_boss_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        public bread_battle_trainer_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        public bread_station_visual_data?: (POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto|null);
                        public static encode(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.IBreadPokemonModeVisualDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto;
                        public static toObject(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }

                    namespace BreadPokemonModeVisualDataProto {

                        interface IBreadPokemonVisualDataProto {
                            scale?: (number|null);
                            camera_distance?: (number|null);
                            max_reticle_size?: (number|null);
                            xoffset?: (number|null);
                            yoffset?: (number|null);
                        }

                        class BreadPokemonVisualDataProto implements IBreadPokemonVisualDataProto {
                            constructor(properties?: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto);
                            public scale: number;
                            public camera_distance: number;
                            public max_reticle_size: number;
                            public xoffset: number;
                            public yoffset: number;
                            public static encode(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.IBreadPokemonVisualDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
                            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.BreadPokemonVisualDataProto;
                            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.BreadPokemonVisualDataProto;
                            public static toObject(message: POGOProtos.Rpc.BreadPokemonScalingSettingsProto.BreadPokemonVisualSettingsProto.BreadPokemonFormVisualDataProto.BreadPokemonModeVisualDataProto.BreadPokemonVisualDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                            public toJSON(): { [k: string]: any };
                        }
                    }
                }
            }
        }

        interface IBreadSharedSettingsProto {
            start_of_day_offset_duration_ms?: (number|Long|null);
            allowed_bread_pokemon?: (POGOProtos.Rpc.IBreadPokemonAllowlist[]|null);
            allowed_sourdough_pokemon?: (POGOProtos.Rpc.IBreadPokemonAllowlist[]|null);
            upgrade_cost_coin?: (number|null);
            max_stationed_pokemon?: (number|null);
            num_stationed_pokemon_to_return?: (number|null);
            max_stationed_pokemon_display_count?: (number|null);
            max_range_for_nearby_state_meters?: (number|null);
            show_timer_when_far?: (boolean|null);
            bread_battle_availability?: (POGOProtos.Rpc.BreadSharedSettingsProto.IBreadBattleAvailabilityProto|null);
            min_ms_to_receive_release_station_rewards?: (number|Long|null);
            max_stationed_pokemon_per_player?: (number|null);
            show_coin_for_upcoming_station?: (boolean|null);
            tutorial_max_boost_item_duration_s?: (number|null);
            min_tutorial_max_boost_item_request_tier?: (POGOProtos.Rpc.BreadBattleLevel|null);
        }

        class BreadSharedSettingsProto implements IBreadSharedSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBreadSharedSettingsProto);
            public start_of_day_offset_duration_ms: (number|Long);
            public allowed_bread_pokemon: POGOProtos.Rpc.IBreadPokemonAllowlist[];
            public allowed_sourdough_pokemon: POGOProtos.Rpc.IBreadPokemonAllowlist[];
            public upgrade_cost_coin: number;
            public max_stationed_pokemon: number;
            public num_stationed_pokemon_to_return: number;
            public max_stationed_pokemon_display_count: number;
            public max_range_for_nearby_state_meters: number;
            public show_timer_when_far: boolean;
            public bread_battle_availability?: (POGOProtos.Rpc.BreadSharedSettingsProto.IBreadBattleAvailabilityProto|null);
            public min_ms_to_receive_release_station_rewards: (number|Long);
            public max_stationed_pokemon_per_player: number;
            public show_coin_for_upcoming_station: boolean;
            public tutorial_max_boost_item_duration_s: number;
            public min_tutorial_max_boost_item_request_tier: POGOProtos.Rpc.BreadBattleLevel;
            public static encode(message: POGOProtos.Rpc.IBreadSharedSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadSharedSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadSharedSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BreadSharedSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BreadSharedSettingsProto {

            interface IBreadBattleAvailabilityProto {
                bread_battle_availability_start_minute?: (number|null);
                bread_battle_availability_end_minute?: (number|null);
            }

            class BreadBattleAvailabilityProto implements IBreadBattleAvailabilityProto {
                constructor(properties?: POGOProtos.Rpc.BreadSharedSettingsProto.IBreadBattleAvailabilityProto);
                public bread_battle_availability_start_minute: number;
                public bread_battle_availability_end_minute: number;
                public static encode(message: POGOProtos.Rpc.BreadSharedSettingsProto.IBreadBattleAvailabilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadSharedSettingsProto.BreadBattleAvailabilityProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadSharedSettingsProto.BreadBattleAvailabilityProto;
                public static toObject(message: POGOProtos.Rpc.BreadSharedSettingsProto.BreadBattleAvailabilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBreadcrumbRecordProto {
            timestamp_ms?: (number|Long|null);
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
            app_is_foregrounded?: (boolean|null);
            altitude_m?: (number|null);
            accuracy_m?: (number|null);
        }

        class BreadcrumbRecordProto implements IBreadcrumbRecordProto {
            constructor(properties?: POGOProtos.Rpc.IBreadcrumbRecordProto);
            public timestamp_ms: (number|Long);
            public latitude_deg: number;
            public longitude_deg: number;
            public app_is_foregrounded: boolean;
            public altitude_m: number;
            public accuracy_m: number;
            public static encode(message: POGOProtos.Rpc.IBreadcrumbRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BreadcrumbRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BreadcrumbRecordProto;
            public static toObject(message: POGOProtos.Rpc.BreadcrumbRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyActivityCategorySettings {
            activity_category?: (POGOProtos.Rpc.BuddyActivityCategory|null);
            max_points_per_day?: (number|null);
        }

        class BuddyActivityCategorySettings implements IBuddyActivityCategorySettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyActivityCategorySettings);
            public activity_category: POGOProtos.Rpc.BuddyActivityCategory;
            public max_points_per_day: number;
            public static encode(message: POGOProtos.Rpc.IBuddyActivityCategorySettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyActivityCategorySettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyActivityCategorySettings;
            public static toObject(message: POGOProtos.Rpc.BuddyActivityCategorySettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyActivitySettings {
            activity?: (POGOProtos.Rpc.BuddyActivity|null);
            activity_category?: (POGOProtos.Rpc.BuddyActivityCategory|null);
            max_times_per_day?: (number|null);
            num_points_per_action?: (number|null);
            num_emotion_points_per_action?: (number|null);
            emotion_cooldown_duration_ms?: (number|Long|null);
        }

        class BuddyActivitySettings implements IBuddyActivitySettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyActivitySettings);
            public activity: POGOProtos.Rpc.BuddyActivity;
            public activity_category: POGOProtos.Rpc.BuddyActivityCategory;
            public max_times_per_day: number;
            public num_points_per_action: number;
            public num_emotion_points_per_action: number;
            public emotion_cooldown_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBuddyActivitySettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyActivitySettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyActivitySettings;
            public static toObject(message: POGOProtos.Rpc.BuddyActivitySettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyConsumablesLogEntry {
            rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class BuddyConsumablesLogEntry implements IBuddyConsumablesLogEntry {
            constructor(properties?: POGOProtos.Rpc.IBuddyConsumablesLogEntry);
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IBuddyConsumablesLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyConsumablesLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyConsumablesLogEntry;
            public static toObject(message: POGOProtos.Rpc.BuddyConsumablesLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyDataProto {
            buddy_pokemon_id?: (number|Long|null);
            current_points_earned?: (number|null);
            highest_points_earned?: (number|null);
            last_reached_full_ms?: (number|Long|null);
            last_groomed_ms?: (number|Long|null);
            map_expiration_ms?: (number|Long|null);
            km_candy_pending?: (number|null);
            buddy_gift_picked_up?: (POGOProtos.Rpc.IBuddyGiftProto|null);
            current_emotion_points?: (number|null);
            daily_activity_counters?: ({ [k: string]: POGOProtos.Rpc.IDailyCounterProto }|null);
            daily_category_counters?: ({ [k: string]: POGOProtos.Rpc.IDailyCounterProto }|null);
            stats_today?: (POGOProtos.Rpc.BuddyDataProto.IBuddyStoredStats|null);
            stats_total?: (POGOProtos.Rpc.BuddyDataProto.IBuddyStoredStats|null);
            souvenirs_collected?: ({ [k: string]: POGOProtos.Rpc.ISouvenirProto }|null);
            current_hunger_points?: (number|null);
            interaction_expiration_ms?: (number|Long|null);
            poffin_feeding_expiration_ms?: (number|Long|null);
            last_affection_or_emotion_awarded_km?: (number|null);
            last_set_timestamp_ms?: (number|Long|null);
            last_unset_timestamp_ms?: (number|Long|null);
            ditched?: (boolean|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            hatched_from_egg?: (boolean|null);
            nickname?: (string|null);
            captured_s2_cell_id?: (number|Long|null);
            pokedex_entry_number?: (POGOProtos.Rpc.HoloPokemonId|null);
            creation_timestamp_ms?: (number|Long|null);
            pokeball?: (POGOProtos.Rpc.Item|null);
            num_days_spent_with_buddy?: (number|null);
            original_owner_nickname?: (string|null);
            traded_time_ms?: (number|Long|null);
            attractive_poi_id?: (string|null);
            attractive_poi_time_generated?: (number|Long|null);
            attractive_poi_cooldown_ms?: (number|Long|null);
            attractive_poi_visited?: (boolean|null);
            berry_cooldown_ms?: (number|Long|null);
            activity_emotion_last_increment_ms?: ({ [k: string]: (number|Long) }|null);
            window?: (number|Long|null);
            last_fed_ms?: (number|Long|null);
            last_window_buddy_on_map?: (number|null);
            last_window_fed_poffin?: (number|null);
            yatta_expiration_ms?: (number|Long|null);
            hunger_points?: (number|null);
            fort_spins?: ({ [k: string]: POGOProtos.Rpc.BuddyDataProto.IBuddySpinMetadata }|null);
        }

        class BuddyDataProto implements IBuddyDataProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyDataProto);
            public buddy_pokemon_id: (number|Long);
            public current_points_earned: number;
            public highest_points_earned: number;
            public last_reached_full_ms: (number|Long);
            public last_groomed_ms: (number|Long);
            public map_expiration_ms: (number|Long);
            public km_candy_pending: number;
            public buddy_gift_picked_up?: (POGOProtos.Rpc.IBuddyGiftProto|null);
            public current_emotion_points: number;
            public daily_activity_counters: { [k: string]: POGOProtos.Rpc.IDailyCounterProto };
            public daily_category_counters: { [k: string]: POGOProtos.Rpc.IDailyCounterProto };
            public stats_today?: (POGOProtos.Rpc.BuddyDataProto.IBuddyStoredStats|null);
            public stats_total?: (POGOProtos.Rpc.BuddyDataProto.IBuddyStoredStats|null);
            public souvenirs_collected: { [k: string]: POGOProtos.Rpc.ISouvenirProto };
            public current_hunger_points: number;
            public interaction_expiration_ms: (number|Long);
            public poffin_feeding_expiration_ms: (number|Long);
            public last_affection_or_emotion_awarded_km: number;
            public last_set_timestamp_ms: (number|Long);
            public last_unset_timestamp_ms: (number|Long);
            public ditched: boolean;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public hatched_from_egg: boolean;
            public nickname: string;
            public captured_s2_cell_id: (number|Long);
            public pokedex_entry_number: POGOProtos.Rpc.HoloPokemonId;
            public creation_timestamp_ms: (number|Long);
            public pokeball: POGOProtos.Rpc.Item;
            public num_days_spent_with_buddy: number;
            public original_owner_nickname: string;
            public traded_time_ms: (number|Long);
            public attractive_poi_id: string;
            public attractive_poi_time_generated: (number|Long);
            public attractive_poi_cooldown_ms: (number|Long);
            public attractive_poi_visited: boolean;
            public berry_cooldown_ms: (number|Long);
            public activity_emotion_last_increment_ms: { [k: string]: (number|Long) };
            public window: (number|Long);
            public last_fed_ms: (number|Long);
            public last_window_buddy_on_map: number;
            public last_window_fed_poffin: number;
            public yatta_expiration_ms: (number|Long);
            public hunger_points: number;
            public fort_spins: { [k: string]: POGOProtos.Rpc.BuddyDataProto.IBuddySpinMetadata };
            public static encode(message: POGOProtos.Rpc.IBuddyDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyDataProto;
            public static toObject(message: POGOProtos.Rpc.BuddyDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyDataProto {

            interface IBuddySpinMetadata {
                next_power_up_bonus_available_ms?: (number|Long|null);
            }

            class BuddySpinMetadata implements IBuddySpinMetadata {
                constructor(properties?: POGOProtos.Rpc.BuddyDataProto.IBuddySpinMetadata);
                public next_power_up_bonus_available_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.BuddyDataProto.IBuddySpinMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyDataProto.BuddySpinMetadata;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyDataProto.BuddySpinMetadata;
                public static toObject(message: POGOProtos.Rpc.BuddyDataProto.BuddySpinMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBuddyStoredStats {
                window?: (number|Long|null);
                buddy_stats?: ({ [k: string]: number }|null);
            }

            class BuddyStoredStats implements IBuddyStoredStats {
                constructor(properties?: POGOProtos.Rpc.BuddyDataProto.IBuddyStoredStats);
                public window: (number|Long);
                public buddy_stats: { [k: string]: number };
                public static encode(message: POGOProtos.Rpc.BuddyDataProto.IBuddyStoredStats, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyDataProto.BuddyStoredStats;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyDataProto.BuddyStoredStats;
                public static toObject(message: POGOProtos.Rpc.BuddyDataProto.BuddyStoredStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBuddyEmotionLevelSettings {
            emotion_level?: (POGOProtos.Rpc.BuddyEmotionLevel|null);
            min_emotion_points_required?: (number|null);
            emotion_animation?: (POGOProtos.Rpc.BuddyAnimation|null);
            decay_prevention_duration_ms?: (number|Long|null);
        }

        class BuddyEmotionLevelSettings implements IBuddyEmotionLevelSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyEmotionLevelSettings);
            public emotion_level: POGOProtos.Rpc.BuddyEmotionLevel;
            public min_emotion_points_required: number;
            public emotion_animation: POGOProtos.Rpc.BuddyAnimation;
            public decay_prevention_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBuddyEmotionLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyEmotionLevelSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyEmotionLevelSettings;
            public static toObject(message: POGOProtos.Rpc.BuddyEmotionLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyEncounterCameoSettings {
            buddy_wild_encounter_cameo_chance_percent?: (number|null);
            buddy_quest_encounter_cameo_chance_percent?: (number|null);
            buddy_raid_encounter_cameo_chance_percent?: (number|null);
            buddy_invasion_encounter_cameo_chance_percent?: (number|null);
            buddy_on_map_required?: (boolean|null);
        }

        class BuddyEncounterCameoSettings implements IBuddyEncounterCameoSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyEncounterCameoSettings);
            public buddy_wild_encounter_cameo_chance_percent: number;
            public buddy_quest_encounter_cameo_chance_percent: number;
            public buddy_raid_encounter_cameo_chance_percent: number;
            public buddy_invasion_encounter_cameo_chance_percent: number;
            public buddy_on_map_required: boolean;
            public static encode(message: POGOProtos.Rpc.IBuddyEncounterCameoSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyEncounterCameoSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyEncounterCameoSettings;
            public static toObject(message: POGOProtos.Rpc.BuddyEncounterCameoSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyEncounterHelpTelemetry {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            encounter_type?: (string|null);
            ar_classic_enabled?: (boolean|null);
            ar_plus_enabled?: (boolean|null);
            encounter?: (POGOProtos.Rpc.EncounterType|null);
        }

        class BuddyEncounterHelpTelemetry implements IBuddyEncounterHelpTelemetry {
            constructor(properties?: POGOProtos.Rpc.IBuddyEncounterHelpTelemetry);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public encounter_type: string;
            public ar_classic_enabled: boolean;
            public ar_plus_enabled: boolean;
            public encounter: POGOProtos.Rpc.EncounterType;
            public static encode(message: POGOProtos.Rpc.IBuddyEncounterHelpTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyEncounterHelpTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyEncounterHelpTelemetry;
            public static toObject(message: POGOProtos.Rpc.BuddyEncounterHelpTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyEvolutionWalkQuestProto {
            last_km_recorded?: (number|null);
        }

        class BuddyEvolutionWalkQuestProto implements IBuddyEvolutionWalkQuestProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyEvolutionWalkQuestProto);
            public last_km_recorded: number;
            public static encode(message: POGOProtos.Rpc.IBuddyEvolutionWalkQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyEvolutionWalkQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyEvolutionWalkQuestProto;
            public static toObject(message: POGOProtos.Rpc.BuddyEvolutionWalkQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyFeedingOutProto {
            result?: (POGOProtos.Rpc.BuddyFeedingOutProto.Result|null);
            observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            shown_hearts?: (POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType|null);
        }

        class BuddyFeedingOutProto implements IBuddyFeedingOutProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyFeedingOutProto);
            public result: POGOProtos.Rpc.BuddyFeedingOutProto.Result;
            public observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public shown_hearts: POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType;
            public static encode(message: POGOProtos.Rpc.IBuddyFeedingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyFeedingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyFeedingOutProto;
            public static toObject(message: POGOProtos.Rpc.BuddyFeedingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyFeedingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BUDDY_NOT_VALID = 2,
                FAILED_INSUFFICIENT_RESOURCES = 3,
                FAILED_INVALID_ITEM_REQUIREMENT = 4,
                FAILED_BUDDY_STILL_FULL_FROM_POFFIN = 5
            }
        }

        interface IBuddyFeedingProto {
            item?: (POGOProtos.Rpc.Item|null);
            count?: (number|null);
        }

        class BuddyFeedingProto implements IBuddyFeedingProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyFeedingProto);
            public item: POGOProtos.Rpc.Item;
            public count: number;
            public static encode(message: POGOProtos.Rpc.IBuddyFeedingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyFeedingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyFeedingProto;
            public static toObject(message: POGOProtos.Rpc.BuddyFeedingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyGiftProto {
            souvenir?: (POGOProtos.Rpc.ISouvenirProto|null);
            loot_proto?: (POGOProtos.Rpc.ILootProto|null);
        }

        class BuddyGiftProto implements IBuddyGiftProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyGiftProto);
            public souvenir?: (POGOProtos.Rpc.ISouvenirProto|null);
            public loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IBuddyGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyGiftProto;
            public static toObject(message: POGOProtos.Rpc.BuddyGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyGlobalSettingsProto {
            enable_monodepth?: (boolean|null);
            monodepth_devices?: (string[]|null);
            lobby_status_message_duration_ms?: (number|null);
            mapping_instruction_duration_ms?: (number|null);
            group_photo_leader_tracking_interval_ms?: (number|null);
            group_photo_countdown_ms?: (number|null);
            lobby_timeout_ms?: (number|null);
            enable_wallaby_telemetry?: (boolean|null);
            mapping_hint_timeout_ms?: (number|null);
            group_photo_simultaneous_shots?: (number|null);
            plfe_auth_tokens_enabled?: (boolean|null);
            group_photo_shot_interval_ms?: (number|null);
            arbe_endpoint_url?: (string|null);
            buddy_on_map_required_to_open_gifts?: (boolean|null);
        }

        class BuddyGlobalSettingsProto implements IBuddyGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyGlobalSettingsProto);
            public enable_monodepth: boolean;
            public monodepth_devices: string[];
            public lobby_status_message_duration_ms: number;
            public mapping_instruction_duration_ms: number;
            public group_photo_leader_tracking_interval_ms: number;
            public group_photo_countdown_ms: number;
            public lobby_timeout_ms: number;
            public enable_wallaby_telemetry: boolean;
            public mapping_hint_timeout_ms: number;
            public group_photo_simultaneous_shots: number;
            public plfe_auth_tokens_enabled: boolean;
            public group_photo_shot_interval_ms: number;
            public arbe_endpoint_url: string;
            public buddy_on_map_required_to_open_gifts: boolean;
            public static encode(message: POGOProtos.Rpc.IBuddyGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BuddyGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyHistoryData {
            pokemon_id?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            hatched_from_egg?: (boolean|null);
            nickname?: (string|null);
            captured_s2_cell_id?: (number|Long|null);
            creation_timestamp_ms?: (number|Long|null);
            pokeball?: (POGOProtos.Rpc.Item|null);
            total_stats?: (POGOProtos.Rpc.IBuddyStats|null);
            current_points_earned?: (number|null);
            last_set_timestamp_ms?: (number|Long|null);
            last_unset_timestamp_ms?: (number|Long|null);
            num_days_spent_with_buddy?: (number|null);
            ditched?: (boolean|null);
            original_owner_nickname?: (string|null);
            traded_time_ms?: (number|Long|null);
            souvenirs_collected?: ({ [k: string]: POGOProtos.Rpc.ISouvenirProto }|null);
            km_candy_progress?: (number|null);
        }

        class BuddyHistoryData implements IBuddyHistoryData {
            constructor(properties?: POGOProtos.Rpc.IBuddyHistoryData);
            public pokemon_id: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public hatched_from_egg: boolean;
            public nickname: string;
            public captured_s2_cell_id: (number|Long);
            public creation_timestamp_ms: (number|Long);
            public pokeball: POGOProtos.Rpc.Item;
            public total_stats?: (POGOProtos.Rpc.IBuddyStats|null);
            public current_points_earned: number;
            public last_set_timestamp_ms: (number|Long);
            public last_unset_timestamp_ms: (number|Long);
            public num_days_spent_with_buddy: number;
            public ditched: boolean;
            public original_owner_nickname: string;
            public traded_time_ms: (number|Long);
            public souvenirs_collected: { [k: string]: POGOProtos.Rpc.ISouvenirProto };
            public km_candy_progress: number;
            public static encode(message: POGOProtos.Rpc.IBuddyHistoryData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyHistoryData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyHistoryData;
            public static toObject(message: POGOProtos.Rpc.BuddyHistoryData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyHungerSettings {
            num_hunger_points_required_for_full?: (number|null);
            decay_points_per_bucket?: (number|null);
            milliseconds_per_bucket?: (number|Long|null);
            cooldown_duration_ms?: (number|Long|null);
            decay_duration_after_full_ms?: (number|Long|null);
        }

        class BuddyHungerSettings implements IBuddyHungerSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyHungerSettings);
            public num_hunger_points_required_for_full: number;
            public decay_points_per_bucket: number;
            public milliseconds_per_bucket: (number|Long);
            public cooldown_duration_ms: (number|Long);
            public decay_duration_after_full_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBuddyHungerSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyHungerSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyHungerSettings;
            public static toObject(message: POGOProtos.Rpc.BuddyHungerSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyInteractionSettings {
            feed_item_whitelist?: (POGOProtos.Rpc.Item[]|null);
            care_item_whitelist?: (POGOProtos.Rpc.Item[]|null);
        }

        class BuddyInteractionSettings implements IBuddyInteractionSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyInteractionSettings);
            public feed_item_whitelist: POGOProtos.Rpc.Item[];
            public care_item_whitelist: POGOProtos.Rpc.Item[];
            public static encode(message: POGOProtos.Rpc.IBuddyInteractionSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyInteractionSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyInteractionSettings;
            public static toObject(message: POGOProtos.Rpc.BuddyInteractionSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyLevelSettings {
            level?: (POGOProtos.Rpc.BuddyLevel|null);
            min_non_cumulative_points_required?: (number|null);
            unlocked_traits?: (POGOProtos.Rpc.BuddyLevelSettings.BuddyTrait[]|null);
        }

        class BuddyLevelSettings implements IBuddyLevelSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyLevelSettings);
            public level: POGOProtos.Rpc.BuddyLevel;
            public min_non_cumulative_points_required: number;
            public unlocked_traits: POGOProtos.Rpc.BuddyLevelSettings.BuddyTrait[];
            public static encode(message: POGOProtos.Rpc.IBuddyLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyLevelSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyLevelSettings;
            public static toObject(message: POGOProtos.Rpc.BuddyLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyLevelSettings {

            enum BuddyTrait {
                UNSET = 0,
                MAP_DEPLOY = 1,
                ENCOUNTER_CAMEO = 2,
                EMOTION_INDICATOR = 3,
                PICK_UP_CONSUMABLES = 4,
                PICK_UP_SOUVENIRS = 5,
                FIND_ATTRACTIVE_POIS = 6,
                BEST_BUDDY_ASSET = 7,
                CP_BOOST = 8,
                TRAINING = 9
            }
        }

        interface IBuddyMapEmotionCheckTelemetry {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            current_emotion_points?: (number|null);
            current_affection_points?: (number|null);
        }

        class BuddyMapEmotionCheckTelemetry implements IBuddyMapEmotionCheckTelemetry {
            constructor(properties?: POGOProtos.Rpc.IBuddyMapEmotionCheckTelemetry);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public current_emotion_points: number;
            public current_affection_points: number;
            public static encode(message: POGOProtos.Rpc.IBuddyMapEmotionCheckTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyMapEmotionCheckTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyMapEmotionCheckTelemetry;
            public static toObject(message: POGOProtos.Rpc.BuddyMapEmotionCheckTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyMapOutProto {
            result?: (POGOProtos.Rpc.BuddyMapOutProto.Result|null);
            expiration_ms?: (number|Long|null);
            applied_ms?: (number|Long|null);
            observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
        }

        class BuddyMapOutProto implements IBuddyMapOutProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyMapOutProto);
            public result: POGOProtos.Rpc.BuddyMapOutProto.Result;
            public expiration_ms: (number|Long);
            public applied_ms: (number|Long);
            public observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public static encode(message: POGOProtos.Rpc.IBuddyMapOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyMapOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyMapOutProto;
            public static toObject(message: POGOProtos.Rpc.BuddyMapOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyMapOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BUDDY_NOT_VALID = 2
            }
        }

        interface IBuddyMapProto {
            buddy_home_widget_active?: (boolean|null);
        }

        class BuddyMapProto implements IBuddyMapProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyMapProto);
            public buddy_home_widget_active: boolean;
            public static encode(message: POGOProtos.Rpc.IBuddyMapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyMapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyMapProto;
            public static toObject(message: POGOProtos.Rpc.BuddyMapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyMultiplayerConnectionFailedProto {
            test_number?: (number|null);
            response_time?: (number|Long|null);
        }

        class BuddyMultiplayerConnectionFailedProto implements IBuddyMultiplayerConnectionFailedProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyMultiplayerConnectionFailedProto);
            public test_number: number;
            public response_time: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBuddyMultiplayerConnectionFailedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyMultiplayerConnectionFailedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyMultiplayerConnectionFailedProto;
            public static toObject(message: POGOProtos.Rpc.BuddyMultiplayerConnectionFailedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyMultiplayerConnectionSucceededProto {
            test_number?: (number|null);
            response_time?: (number|Long|null);
        }

        class BuddyMultiplayerConnectionSucceededProto implements IBuddyMultiplayerConnectionSucceededProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyMultiplayerConnectionSucceededProto);
            public test_number: number;
            public response_time: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBuddyMultiplayerConnectionSucceededProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyMultiplayerConnectionSucceededProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyMultiplayerConnectionSucceededProto;
            public static toObject(message: POGOProtos.Rpc.BuddyMultiplayerConnectionSucceededProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyMultiplayerTimeToGetSessionProto {
            test_number?: (number|null);
            time_to_get_session?: (number|Long|null);
        }

        class BuddyMultiplayerTimeToGetSessionProto implements IBuddyMultiplayerTimeToGetSessionProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyMultiplayerTimeToGetSessionProto);
            public test_number: number;
            public time_to_get_session: (number|Long);
            public static encode(message: POGOProtos.Rpc.IBuddyMultiplayerTimeToGetSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyMultiplayerTimeToGetSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyMultiplayerTimeToGetSessionProto;
            public static toObject(message: POGOProtos.Rpc.BuddyMultiplayerTimeToGetSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyNotificationClickTelemetry {
            notification_category?: (number|null);
        }

        class BuddyNotificationClickTelemetry implements IBuddyNotificationClickTelemetry {
            constructor(properties?: POGOProtos.Rpc.IBuddyNotificationClickTelemetry);
            public notification_category: number;
            public static encode(message: POGOProtos.Rpc.IBuddyNotificationClickTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyNotificationClickTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyNotificationClickTelemetry;
            public static toObject(message: POGOProtos.Rpc.BuddyNotificationClickTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyObservedData {
            current_points_earned?: (number|null);
            total_stats?: (POGOProtos.Rpc.IBuddyStats|null);
            buddy_gift_picked_up?: (POGOProtos.Rpc.IBuddyGiftProto|null);
            current_emotion_points?: (number|null);
            buddy_validation_result?: (POGOProtos.Rpc.BuddyObservedData.BuddyValidationResult|null);
            souvenirs_collected?: ({ [k: string]: POGOProtos.Rpc.ISouvenirProto }|null);
            today_stats_shown_hearts?: (POGOProtos.Rpc.IBuddyStatsShownHearts|null);
            buddy_feed_stats?: (POGOProtos.Rpc.BuddyObservedData.IBuddyFeedStats|null);
            attractive_poi_id?: (string|null);
            attractive_poi_expiration_time_ms?: (number|Long|null);
            num_days_spent_with_buddy?: (number|null);
        }

        class BuddyObservedData implements IBuddyObservedData {
            constructor(properties?: POGOProtos.Rpc.IBuddyObservedData);
            public current_points_earned: number;
            public total_stats?: (POGOProtos.Rpc.IBuddyStats|null);
            public buddy_gift_picked_up?: (POGOProtos.Rpc.IBuddyGiftProto|null);
            public current_emotion_points: number;
            public buddy_validation_result: POGOProtos.Rpc.BuddyObservedData.BuddyValidationResult;
            public souvenirs_collected: { [k: string]: POGOProtos.Rpc.ISouvenirProto };
            public today_stats_shown_hearts?: (POGOProtos.Rpc.IBuddyStatsShownHearts|null);
            public buddy_feed_stats?: (POGOProtos.Rpc.BuddyObservedData.IBuddyFeedStats|null);
            public attractive_poi_id: string;
            public attractive_poi_expiration_time_ms: (number|Long);
            public num_days_spent_with_buddy: number;
            public static encode(message: POGOProtos.Rpc.IBuddyObservedData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyObservedData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyObservedData;
            public static toObject(message: POGOProtos.Rpc.BuddyObservedData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyObservedData {

            enum BuddyValidationResult {
                UNSET = 0,
                SUCCESS = 1,
                FAILED_BUDDY_NOT_SET = 2,
                FAILED_BUDDY_NOT_FOUND = 3,
                FAILED_BAD_BUDDY = 4,
                FAILED_BUDDY_V2_NOT_ENABLED = 5,
                FAILED_PLAYER_LEVEL_TOO_LOW = 6
            }

            interface IBuddyFeedStats {
                map_expiration_ms?: (number|Long|null);
                pre_map_fullness_percentage?: (number|null);
                fullness_expiration_ms?: (number|Long|null);
                poffin_expiration_ms?: (number|Long|null);
            }

            class BuddyFeedStats implements IBuddyFeedStats {
                constructor(properties?: POGOProtos.Rpc.BuddyObservedData.IBuddyFeedStats);
                public map_expiration_ms: (number|Long);
                public pre_map_fullness_percentage: number;
                public fullness_expiration_ms: (number|Long);
                public poffin_expiration_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.BuddyObservedData.IBuddyFeedStats, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyObservedData.BuddyFeedStats;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyObservedData.BuddyFeedStats;
                public static toObject(message: POGOProtos.Rpc.BuddyObservedData.BuddyFeedStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBuddyPettingOutProto {
            result?: (POGOProtos.Rpc.BuddyPettingOutProto.Result|null);
            observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            shown_hearts?: (POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType|null);
        }

        class BuddyPettingOutProto implements IBuddyPettingOutProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyPettingOutProto);
            public result: POGOProtos.Rpc.BuddyPettingOutProto.Result;
            public observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public shown_hearts: POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType;
            public static encode(message: POGOProtos.Rpc.IBuddyPettingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyPettingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyPettingOutProto;
            public static toObject(message: POGOProtos.Rpc.BuddyPettingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyPettingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BUDDY_NOT_VALID = 2
            }
        }

        interface IBuddyPettingProto {
        }

        class BuddyPettingProto implements IBuddyPettingProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyPettingProto);
            public static encode(message: POGOProtos.Rpc.IBuddyPettingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyPettingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyPettingProto;
            public static toObject(message: POGOProtos.Rpc.BuddyPettingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyPokemonLogEntry {
            result?: (POGOProtos.Rpc.BuddyPokemonLogEntry.Result|null);
            pokemon_type?: (POGOProtos.Rpc.HoloPokemonId|null);
            amount?: (number|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            pokemon_id?: (number|Long|null);
            amount_xl?: (number|null);
        }

        class BuddyPokemonLogEntry implements IBuddyPokemonLogEntry {
            constructor(properties?: POGOProtos.Rpc.IBuddyPokemonLogEntry);
            public result: POGOProtos.Rpc.BuddyPokemonLogEntry.Result;
            public pokemon_type: POGOProtos.Rpc.HoloPokemonId;
            public amount: number;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public pokemon_id: (number|Long);
            public amount_xl: number;
            public static encode(message: POGOProtos.Rpc.IBuddyPokemonLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyPokemonLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyPokemonLogEntry;
            public static toObject(message: POGOProtos.Rpc.BuddyPokemonLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyPokemonLogEntry {

            enum Result {
                UNSET = 0,
                CANDY_FOUND = 1
            }
        }

        interface IBuddyPokemonProto {
            buddy_pokemon_id?: (number|Long|null);
            start_km_walked?: (number|null);
            last_km_awarded?: (number|null);
            daily_buddy_swaps?: (POGOProtos.Rpc.IDailyCounterProto|null);
            last_km_awarded_ms?: (number|Long|null);
            best_buddies_backfilled?: (boolean|null);
            last_set_timestamp_ms?: (number|Long|null);
            pending_bonus_km?: (number|null);
        }

        class BuddyPokemonProto implements IBuddyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyPokemonProto);
            public buddy_pokemon_id: (number|Long);
            public start_km_walked: number;
            public last_km_awarded: number;
            public daily_buddy_swaps?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public last_km_awarded_ms: (number|Long);
            public best_buddies_backfilled: boolean;
            public last_set_timestamp_ms: (number|Long);
            public pending_bonus_km: number;
            public static encode(message: POGOProtos.Rpc.IBuddyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.BuddyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyStats {
            km_walked?: (number|null);
            berries_fed?: (number|null);
            communication?: (number|null);
            battles?: (number|null);
            photos?: (number|null);
            new_visits?: (number|null);
            routes_walked?: (number|null);
        }

        class BuddyStats implements IBuddyStats {
            constructor(properties?: POGOProtos.Rpc.IBuddyStats);
            public km_walked: number;
            public berries_fed: number;
            public communication: number;
            public battles: number;
            public photos: number;
            public new_visits: number;
            public routes_walked: number;
            public static encode(message: POGOProtos.Rpc.IBuddyStats, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyStats;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyStats;
            public static toObject(message: POGOProtos.Rpc.BuddyStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyStatsOutProto {
            result?: (POGOProtos.Rpc.BuddyStatsOutProto.Result|null);
            observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
        }

        class BuddyStatsOutProto implements IBuddyStatsOutProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyStatsOutProto);
            public result: POGOProtos.Rpc.BuddyStatsOutProto.Result;
            public observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public static encode(message: POGOProtos.Rpc.IBuddyStatsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyStatsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyStatsOutProto;
            public static toObject(message: POGOProtos.Rpc.BuddyStatsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyStatsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BUDDY_NOT_VALID = 2
            }
        }

        interface IBuddyStatsProto {
        }

        class BuddyStatsProto implements IBuddyStatsProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyStatsProto);
            public static encode(message: POGOProtos.Rpc.IBuddyStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyStatsProto;
            public static toObject(message: POGOProtos.Rpc.BuddyStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyStatsShownHearts {
            buddy_affection_km_in_progress?: (number|null);
            buddy_shown_hearts_per_category?: ({ [k: string]: POGOProtos.Rpc.BuddyStatsShownHearts.IBuddyShownHeartsList }|null);
        }

        class BuddyStatsShownHearts implements IBuddyStatsShownHearts {
            constructor(properties?: POGOProtos.Rpc.IBuddyStatsShownHearts);
            public buddy_affection_km_in_progress: number;
            public buddy_shown_hearts_per_category: { [k: string]: POGOProtos.Rpc.BuddyStatsShownHearts.IBuddyShownHeartsList };
            public static encode(message: POGOProtos.Rpc.IBuddyStatsShownHearts, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyStatsShownHearts;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyStatsShownHearts;
            public static toObject(message: POGOProtos.Rpc.BuddyStatsShownHearts, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace BuddyStatsShownHearts {

            enum BuddyShownHeartType {
                BUDDY_HEART_UNSET = 0,
                BUDDY_HEART_SINGLE = 1,
                BUDDY_HEART_DOUBLE = 2
            }

            interface IBuddyShownHeartsList {
                buddy_shown_heart_types?: (POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType[]|null);
            }

            class BuddyShownHeartsList implements IBuddyShownHeartsList {
                constructor(properties?: POGOProtos.Rpc.BuddyStatsShownHearts.IBuddyShownHeartsList);
                public buddy_shown_heart_types: POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType[];
                public static encode(message: POGOProtos.Rpc.BuddyStatsShownHearts.IBuddyShownHeartsList, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartsList;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartsList;
                public static toObject(message: POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartsList, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IBuddySwapSettings {
            max_swaps_per_day?: (number|null);
            enable_swap_free_evolution?: (boolean|null);
            enable_quick_swap?: (boolean|null);
        }

        class BuddySwapSettings implements IBuddySwapSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddySwapSettings);
            public max_swaps_per_day: number;
            public enable_swap_free_evolution: boolean;
            public enable_quick_swap: boolean;
            public static encode(message: POGOProtos.Rpc.IBuddySwapSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddySwapSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddySwapSettings;
            public static toObject(message: POGOProtos.Rpc.BuddySwapSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyWalkSettings {
            km_required_per_affection_point?: (number|null);
        }

        class BuddyWalkSettings implements IBuddyWalkSettings {
            constructor(properties?: POGOProtos.Rpc.IBuddyWalkSettings);
            public km_required_per_affection_point: number;
            public static encode(message: POGOProtos.Rpc.IBuddyWalkSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyWalkSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyWalkSettings;
            public static toObject(message: POGOProtos.Rpc.BuddyWalkSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuddyWalkedMegaEnergyProto {
            mega_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            mega_energy_award_amount?: (number|null);
            gender_requirement?: (POGOProtos.Rpc.PokemonDisplayProto.Gender|null);
        }

        class BuddyWalkedMegaEnergyProto implements IBuddyWalkedMegaEnergyProto {
            constructor(properties?: POGOProtos.Rpc.IBuddyWalkedMegaEnergyProto);
            public mega_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public mega_energy_award_amount: number;
            public gender_requirement: POGOProtos.Rpc.PokemonDisplayProto.Gender;
            public static encode(message: POGOProtos.Rpc.IBuddyWalkedMegaEnergyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuddyWalkedMegaEnergyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuddyWalkedMegaEnergyProto;
            public static toObject(message: POGOProtos.Rpc.BuddyWalkedMegaEnergyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBuildingMetadata {
            height_meters?: (number|null);
            is_underground?: (boolean|null);
        }

        class BuildingMetadata implements IBuildingMetadata {
            constructor(properties?: POGOProtos.Rpc.IBuildingMetadata);
            public height_meters: number;
            public is_underground: boolean;
            public static encode(message: POGOProtos.Rpc.IBuildingMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BuildingMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BuildingMetadata;
            public static toObject(message: POGOProtos.Rpc.BuildingMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBulkHealingSettingsProto {
            enabled?: (boolean|null);
            max_pokemons_per_heal?: (number|null);
        }

        class BulkHealingSettingsProto implements IBulkHealingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IBulkHealingSettingsProto);
            public enabled: boolean;
            public max_pokemons_per_heal: number;
            public static encode(message: POGOProtos.Rpc.IBulkHealingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BulkHealingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BulkHealingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.BulkHealingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IButterflyCollectorBadgeData {
            version?: (number|null);
            region?: (POGOProtos.Rpc.IButterflyCollectorRegionMedal[]|null);
            encounter?: (POGOProtos.Rpc.IQuestPokemonEncounterProto[]|null);
        }

        class ButterflyCollectorBadgeData implements IButterflyCollectorBadgeData {
            constructor(properties?: POGOProtos.Rpc.IButterflyCollectorBadgeData);
            public version: number;
            public region: POGOProtos.Rpc.IButterflyCollectorRegionMedal[];
            public encounter: POGOProtos.Rpc.IQuestPokemonEncounterProto[];
            public static encode(message: POGOProtos.Rpc.IButterflyCollectorBadgeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ButterflyCollectorBadgeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ButterflyCollectorBadgeData;
            public static toObject(message: POGOProtos.Rpc.ButterflyCollectorBadgeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IButterflyCollectorRegionMedal {
            region?: (POGOProtos.Rpc.VivillonRegion|null);
            rank?: (number|null);
            state?: (POGOProtos.Rpc.ButterflyCollectorRegionMedal.State|null);
            progress?: (number|null);
            goal?: (number|null);
            postcard_origin?: (number|Long|null);
            received_time_ms?: (number|Long|null);
        }

        class ButterflyCollectorRegionMedal implements IButterflyCollectorRegionMedal {
            constructor(properties?: POGOProtos.Rpc.IButterflyCollectorRegionMedal);
            public region: POGOProtos.Rpc.VivillonRegion;
            public rank: number;
            public state: POGOProtos.Rpc.ButterflyCollectorRegionMedal.State;
            public progress: number;
            public goal: number;
            public postcard_origin: (number|Long);
            public received_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IButterflyCollectorRegionMedal, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ButterflyCollectorRegionMedal;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ButterflyCollectorRegionMedal;
            public static toObject(message: POGOProtos.Rpc.ButterflyCollectorRegionMedal, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ButterflyCollectorRegionMedal {

            enum State {
                PROGRESS = 0,
                COMPLETE = 1
            }
        }

        interface IButterflyCollectorRewardEncounterProtoRequest {
            region?: (POGOProtos.Rpc.VivillonRegion|null);
        }

        class ButterflyCollectorRewardEncounterProtoRequest implements IButterflyCollectorRewardEncounterProtoRequest {
            constructor(properties?: POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoRequest);
            public region: POGOProtos.Rpc.VivillonRegion;
            public static encode(message: POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoRequest;
            public static toObject(message: POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IButterflyCollectorRewardEncounterProtoResponse {
            result?: (POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoResponse.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            encounter_id?: (number|Long|null);
        }

        class ButterflyCollectorRewardEncounterProtoResponse implements IButterflyCollectorRewardEncounterProtoResponse {
            constructor(properties?: POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoResponse);
            public result: POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoResponse.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IButterflyCollectorRewardEncounterProtoResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoResponse;
            public static toObject(message: POGOProtos.Rpc.ButterflyCollectorRewardEncounterProtoResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ButterflyCollectorRewardEncounterProtoResponse {

            enum Result {
                UNKNOWN = 0,
                SUCCESS_ENCOUNTER = 1,
                SUCCESS_POKEMON_INVENTORY_FULL = 2,
                ERROR_REQUIRES_PROGRESS = 3
            }
        }

        interface IButterflyCollectorRewardsLogEntry {
            result?: (POGOProtos.Rpc.ButterflyCollectorRewardsLogEntry.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            vivillon_region?: (POGOProtos.Rpc.VivillonRegion|null);
        }

        class ButterflyCollectorRewardsLogEntry implements IButterflyCollectorRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IButterflyCollectorRewardsLogEntry);
            public result: POGOProtos.Rpc.ButterflyCollectorRewardsLogEntry.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public vivillon_region: POGOProtos.Rpc.VivillonRegion;
            public static encode(message: POGOProtos.Rpc.IButterflyCollectorRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ButterflyCollectorRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ButterflyCollectorRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.ButterflyCollectorRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ButterflyCollectorRewardsLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IButterflyCollectorSettings {
            enabled?: (boolean|null);
            version?: (number|null);
            region?: (POGOProtos.Rpc.VivillonRegion[]|null);
            use_postcard_modifier?: (boolean|null);
            daily_progress_from_inventory?: (number|null);
            region_override?: (POGOProtos.Rpc.VivillonRegion|null);
        }

        class ButterflyCollectorSettings implements IButterflyCollectorSettings {
            constructor(properties?: POGOProtos.Rpc.IButterflyCollectorSettings);
            public enabled: boolean;
            public version: number;
            public region: POGOProtos.Rpc.VivillonRegion[];
            public use_postcard_modifier: boolean;
            public daily_progress_from_inventory: number;
            public region_override: POGOProtos.Rpc.VivillonRegion;
            public static encode(message: POGOProtos.Rpc.IButterflyCollectorSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ButterflyCollectorSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ButterflyCollectorSettings;
            public static toObject(message: POGOProtos.Rpc.ButterflyCollectorSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBytesValue {
            value?: (Uint8Array|null);
        }

        class BytesValue implements IBytesValue {
            constructor(properties?: POGOProtos.Rpc.IBytesValue);
            public value: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IBytesValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.BytesValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.BytesValue;
            public static toObject(message: POGOProtos.Rpc.BytesValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICampaignExperimentIds {
            campaign_experiment_ids?: ((number|Long)[]|null);
        }

        class CampaignExperimentIds implements ICampaignExperimentIds {
            constructor(properties?: POGOProtos.Rpc.ICampaignExperimentIds);
            public campaign_experiment_ids: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.ICampaignExperimentIds, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CampaignExperimentIds;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CampaignExperimentIds;
            public static toObject(message: POGOProtos.Rpc.CampaignExperimentIds, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICampfireSettingsProto {
            campfire_enabled?: (boolean|null);
            map_buttons_enabled?: (boolean|null);
            catch_card_enabled?: (boolean|null);
            ar_catch_card_enabled?: (boolean|null);
            catch_card_template_bundle_keys?: (string[]|null);
            catch_card_available_seconds?: (number|null);
            settings_toggle_enabled?: (boolean|null);
            catch_card_share_campfire_enabled?: (boolean|null);
            ar_catch_card_share_campfire_enabled?: (boolean|null);
            meetup_query_timer_ms?: (number|Long|null);
            campfire_notifications_enabled?: (boolean|null);
            passwordless_login_enabled?: (boolean|null);
        }

        class CampfireSettingsProto implements ICampfireSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICampfireSettingsProto);
            public campfire_enabled: boolean;
            public map_buttons_enabled: boolean;
            public catch_card_enabled: boolean;
            public ar_catch_card_enabled: boolean;
            public catch_card_template_bundle_keys: string[];
            public catch_card_available_seconds: number;
            public settings_toggle_enabled: boolean;
            public catch_card_share_campfire_enabled: boolean;
            public ar_catch_card_share_campfire_enabled: boolean;
            public meetup_query_timer_ms: (number|Long);
            public campfire_notifications_enabled: boolean;
            public passwordless_login_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ICampfireSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CampfireSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CampfireSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CampfireSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICanClaimPtcRewardActionOutProto {
            can_claim?: (boolean|null);
        }

        class CanClaimPtcRewardActionOutProto implements ICanClaimPtcRewardActionOutProto {
            constructor(properties?: POGOProtos.Rpc.ICanClaimPtcRewardActionOutProto);
            public can_claim: boolean;
            public static encode(message: POGOProtos.Rpc.ICanClaimPtcRewardActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CanClaimPtcRewardActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CanClaimPtcRewardActionOutProto;
            public static toObject(message: POGOProtos.Rpc.CanClaimPtcRewardActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICanClaimPtcRewardActionProto {
        }

        class CanClaimPtcRewardActionProto implements ICanClaimPtcRewardActionProto {
            constructor(properties?: POGOProtos.Rpc.ICanClaimPtcRewardActionProto);
            public static encode(message: POGOProtos.Rpc.ICanClaimPtcRewardActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CanClaimPtcRewardActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CanClaimPtcRewardActionProto;
            public static toObject(message: POGOProtos.Rpc.CanClaimPtcRewardActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICanReportRouteOutProto {
            result?: (POGOProtos.Rpc.ReportRouteOutProto.Result|null);
            remaining_cooldown_days?: (number|null);
        }

        class CanReportRouteOutProto implements ICanReportRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.ICanReportRouteOutProto);
            public result: POGOProtos.Rpc.ReportRouteOutProto.Result;
            public remaining_cooldown_days: number;
            public static encode(message: POGOProtos.Rpc.ICanReportRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CanReportRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CanReportRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.CanReportRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICanReportRouteProto {
            route_id?: (string|null);
        }

        class CanReportRouteProto implements ICanReportRouteProto {
            constructor(properties?: POGOProtos.Rpc.ICanReportRouteProto);
            public route_id: string;
            public static encode(message: POGOProtos.Rpc.ICanReportRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CanReportRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CanReportRouteProto;
            public static toObject(message: POGOProtos.Rpc.CanReportRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelCombatChallengeData {
            rpc_id?: (number|null);
        }

        class CancelCombatChallengeData implements ICancelCombatChallengeData {
            constructor(properties?: POGOProtos.Rpc.ICancelCombatChallengeData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ICancelCombatChallengeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelCombatChallengeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelCombatChallengeData;
            public static toObject(message: POGOProtos.Rpc.CancelCombatChallengeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelCombatChallengeOutProto {
            result?: (POGOProtos.Rpc.CancelCombatChallengeOutProto.Result|null);
        }

        class CancelCombatChallengeOutProto implements ICancelCombatChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.ICancelCombatChallengeOutProto);
            public result: POGOProtos.Rpc.CancelCombatChallengeOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICancelCombatChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelCombatChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelCombatChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.CancelCombatChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CancelCombatChallengeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_CHALLENGE_STATE = 2,
                ERROR_CHALLENGE_NOT_FOUND = 3,
                ERROR_ALREADY_ACCEPTED = 4,
                ERROR_ALREADY_DECLINED = 5,
                ERROR_ALREADY_TIMEDOUT = 6,
                ERROR_ACCESS_DENIED = 7
            }
        }

        interface ICancelCombatChallengeProto {
            challenge_id?: (string|null);
        }

        class CancelCombatChallengeProto implements ICancelCombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.ICancelCombatChallengeProto);
            public challenge_id: string;
            public static encode(message: POGOProtos.Rpc.ICancelCombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelCombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelCombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.CancelCombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelCombatChallengeResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.CancelCombatChallengeOutProto.Result|null);
        }

        class CancelCombatChallengeResponseData implements ICancelCombatChallengeResponseData {
            constructor(properties?: POGOProtos.Rpc.ICancelCombatChallengeResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.CancelCombatChallengeOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICancelCombatChallengeResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelCombatChallengeResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelCombatChallengeResponseData;
            public static toObject(message: POGOProtos.Rpc.CancelCombatChallengeResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelEventRsvpOutProto {
            status?: (POGOProtos.Rpc.CancelEventRsvpOutProto.Result|null);
        }

        class CancelEventRsvpOutProto implements ICancelEventRsvpOutProto {
            constructor(properties?: POGOProtos.Rpc.ICancelEventRsvpOutProto);
            public status: POGOProtos.Rpc.CancelEventRsvpOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICancelEventRsvpOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelEventRsvpOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelEventRsvpOutProto;
            public static toObject(message: POGOProtos.Rpc.CancelEventRsvpOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CancelEventRsvpOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FOUND = 3
            }
        }

        interface ICancelEventRsvpProto {
            location_id?: (string|null);
            timestamp_ms?: (number|Long|null);
        }

        class CancelEventRsvpProto implements ICancelEventRsvpProto {
            constructor(properties?: POGOProtos.Rpc.ICancelEventRsvpProto);
            public location_id: string;
            public timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICancelEventRsvpProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelEventRsvpProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelEventRsvpProto;
            public static toObject(message: POGOProtos.Rpc.CancelEventRsvpProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelMatchmakingData {
            rpc_id?: (number|null);
        }

        class CancelMatchmakingData implements ICancelMatchmakingData {
            constructor(properties?: POGOProtos.Rpc.ICancelMatchmakingData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ICancelMatchmakingData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelMatchmakingData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelMatchmakingData;
            public static toObject(message: POGOProtos.Rpc.CancelMatchmakingData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelMatchmakingOutProto {
            result?: (POGOProtos.Rpc.CancelMatchmakingOutProto.Result|null);
        }

        class CancelMatchmakingOutProto implements ICancelMatchmakingOutProto {
            constructor(properties?: POGOProtos.Rpc.ICancelMatchmakingOutProto);
            public result: POGOProtos.Rpc.CancelMatchmakingOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICancelMatchmakingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelMatchmakingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelMatchmakingOutProto;
            public static toObject(message: POGOProtos.Rpc.CancelMatchmakingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CancelMatchmakingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESSFULLY_CANCELLED = 1,
                ERROR_ALREADY_MATCHED = 2,
                ERROR_PLAYER_NOT_FOUND = 3,
                ERROR_QUEUE_NOT_FOUND = 4
            }
        }

        interface ICancelMatchmakingProto {
            queue_id?: (string|null);
        }

        class CancelMatchmakingProto implements ICancelMatchmakingProto {
            constructor(properties?: POGOProtos.Rpc.ICancelMatchmakingProto);
            public queue_id: string;
            public static encode(message: POGOProtos.Rpc.ICancelMatchmakingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelMatchmakingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelMatchmakingProto;
            public static toObject(message: POGOProtos.Rpc.CancelMatchmakingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelMatchmakingResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.CancelMatchmakingOutProto.Result|null);
        }

        class CancelMatchmakingResponseData implements ICancelMatchmakingResponseData {
            constructor(properties?: POGOProtos.Rpc.ICancelMatchmakingResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.CancelMatchmakingOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICancelMatchmakingResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelMatchmakingResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelMatchmakingResponseData;
            public static toObject(message: POGOProtos.Rpc.CancelMatchmakingResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelPartyInviteOutProto {
            result?: (POGOProtos.Rpc.CancelPartyInviteOutProto.Result|null);
        }

        class CancelPartyInviteOutProto implements ICancelPartyInviteOutProto {
            constructor(properties?: POGOProtos.Rpc.ICancelPartyInviteOutProto);
            public result: POGOProtos.Rpc.CancelPartyInviteOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICancelPartyInviteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelPartyInviteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelPartyInviteOutProto;
            public static toObject(message: POGOProtos.Rpc.CancelPartyInviteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CancelPartyInviteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVITE_NOT_FOUND = 3,
                ERROR_NO_SUCH_PARTY = 4,
                ERROR_ALREADY_CANCELED = 5
            }
        }

        interface ICancelPartyInviteProto {
            party_id?: (number|Long|null);
            invitee_id?: (string|null);
        }

        class CancelPartyInviteProto implements ICancelPartyInviteProto {
            constructor(properties?: POGOProtos.Rpc.ICancelPartyInviteProto);
            public party_id: (number|Long);
            public invitee_id: string;
            public static encode(message: POGOProtos.Rpc.ICancelPartyInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelPartyInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelPartyInviteProto;
            public static toObject(message: POGOProtos.Rpc.CancelPartyInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelRouteOutProto {
            status?: (POGOProtos.Rpc.RoutePlayStatus.Status|null);
            cooldown_finish_ms?: (number|Long|null);
        }

        class CancelRouteOutProto implements ICancelRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.ICancelRouteOutProto);
            public status: POGOProtos.Rpc.RoutePlayStatus.Status;
            public cooldown_finish_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICancelRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.CancelRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelRouteProto {
        }

        class CancelRouteProto implements ICancelRouteProto {
            constructor(properties?: POGOProtos.Rpc.ICancelRouteProto);
            public static encode(message: POGOProtos.Rpc.ICancelRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelRouteProto;
            public static toObject(message: POGOProtos.Rpc.CancelRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICancelTradingOutProto {
            result?: (POGOProtos.Rpc.CancelTradingOutProto.Result|null);
            trading?: (POGOProtos.Rpc.ITradingProto|null);
        }

        class CancelTradingOutProto implements ICancelTradingOutProto {
            constructor(properties?: POGOProtos.Rpc.ICancelTradingOutProto);
            public result: POGOProtos.Rpc.CancelTradingOutProto.Result;
            public trading?: (POGOProtos.Rpc.ITradingProto|null);
            public static encode(message: POGOProtos.Rpc.ICancelTradingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelTradingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelTradingOutProto;
            public static toObject(message: POGOProtos.Rpc.CancelTradingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CancelTradingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FRIEND_NOT_FOUND = 3,
                ERROR_INVALID_PLAYER_ID = 4,
                ERROR_INVALID_STATE = 5,
                ERROR_STATE_HANDLER = 6
            }
        }

        interface ICancelTradingProto {
            player_id?: (string|null);
        }

        class CancelTradingProto implements ICancelTradingProto {
            constructor(properties?: POGOProtos.Rpc.ICancelTradingProto);
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.ICancelTradingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CancelTradingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CancelTradingProto;
            public static toObject(message: POGOProtos.Rpc.CancelTradingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICapProto {
            center?: (POGOProtos.Rpc.IPointProto|null);
            angle_degrees?: (number|null);
        }

        class CapProto implements ICapProto {
            constructor(properties?: POGOProtos.Rpc.ICapProto);
            public center?: (POGOProtos.Rpc.IPointProto|null);
            public angle_degrees: number;
            public static encode(message: POGOProtos.Rpc.ICapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CapProto;
            public static toObject(message: POGOProtos.Rpc.CapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICaptureProbabilityProto {
            pokeball_type?: (POGOProtos.Rpc.Item[]|null);
            capture_probability?: (number[]|null);
            reticle_difficulty_scale?: (number|null);
        }

        class CaptureProbabilityProto implements ICaptureProbabilityProto {
            constructor(properties?: POGOProtos.Rpc.ICaptureProbabilityProto);
            public pokeball_type: POGOProtos.Rpc.Item[];
            public capture_probability: number[];
            public reticle_difficulty_scale: number;
            public static encode(message: POGOProtos.Rpc.ICaptureProbabilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CaptureProbabilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CaptureProbabilityProto;
            public static toObject(message: POGOProtos.Rpc.CaptureProbabilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICaptureScoreProto {
            activity_type?: (POGOProtos.Rpc.HoloActivityType[]|null);
            exp?: (number[]|null);
            candy?: (number[]|null);
            stardust?: (number[]|null);
            xl_candy?: (number[]|null);
            candy_from_active_mega?: (number|null);
            items?: (POGOProtos.Rpc.ILootProto[]|null);
            experience_from_active_mega?: (number|null);
            temp_evo_score_info?: (POGOProtos.Rpc.CaptureScoreProto.ITempEvoScoreInfo|null);
            mp?: (number[]|null);
        }

        class CaptureScoreProto implements ICaptureScoreProto {
            constructor(properties?: POGOProtos.Rpc.ICaptureScoreProto);
            public activity_type: POGOProtos.Rpc.HoloActivityType[];
            public exp: number[];
            public candy: number[];
            public stardust: number[];
            public xl_candy: number[];
            public candy_from_active_mega: number;
            public items: POGOProtos.Rpc.ILootProto[];
            public experience_from_active_mega: number;
            public temp_evo_score_info?: (POGOProtos.Rpc.CaptureScoreProto.ITempEvoScoreInfo|null);
            public mp: number[];
            public static encode(message: POGOProtos.Rpc.ICaptureScoreProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CaptureScoreProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CaptureScoreProto;
            public static toObject(message: POGOProtos.Rpc.CaptureScoreProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CaptureScoreProto {

            interface ITempEvoScoreInfo {
                active_temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
                candy_from_active_temp_evo?: (number|null);
                experience_from_active_temp_evo?: (number|null);
            }

            class TempEvoScoreInfo implements ITempEvoScoreInfo {
                constructor(properties?: POGOProtos.Rpc.CaptureScoreProto.ITempEvoScoreInfo);
                public active_temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
                public candy_from_active_temp_evo: number;
                public experience_from_active_temp_evo: number;
                public static encode(message: POGOProtos.Rpc.CaptureScoreProto.ITempEvoScoreInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CaptureScoreProto.TempEvoScoreInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CaptureScoreProto.TempEvoScoreInfo;
                public static toObject(message: POGOProtos.Rpc.CaptureScoreProto.TempEvoScoreInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICatchCardTelemetry {
            photo_type?: (POGOProtos.Rpc.CatchCardTelemetry.PhotoType|null);
            template_id?: (string|null);
            shared_to_system?: (boolean|null);
            campfire_id?: (string|null);
            time_since_caught_seconds?: (number|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            shiny?: (boolean|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            individual_attack?: (number|null);
            individual_defense?: (number|null);
            individual_stamina?: (number|null);
            alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment|null);
        }

        class CatchCardTelemetry implements ICatchCardTelemetry {
            constructor(properties?: POGOProtos.Rpc.ICatchCardTelemetry);
            public photo_type: POGOProtos.Rpc.CatchCardTelemetry.PhotoType;
            public template_id: string;
            public shared_to_system: boolean;
            public campfire_id: string;
            public time_since_caught_seconds: number;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public shiny: boolean;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public individual_attack: number;
            public individual_defense: number;
            public individual_stamina: number;
            public alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment;
            public static encode(message: POGOProtos.Rpc.ICatchCardTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchCardTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchCardTelemetry;
            public static toObject(message: POGOProtos.Rpc.CatchCardTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CatchCardTelemetry {

            enum PhotoType {
                UNSET = 0,
                DEFAULT = 1,
                AR_CLASSIC = 2,
                AR_PLUS = 3
            }
        }

        interface ICatchPokemonGlobalSettingsProto {
            enable_capture_origin_details_display?: (boolean|null);
            enable_capture_origin_events_display?: (boolean|null);
        }

        class CatchPokemonGlobalSettingsProto implements ICatchPokemonGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICatchPokemonGlobalSettingsProto);
            public enable_capture_origin_details_display: boolean;
            public enable_capture_origin_events_display: boolean;
            public static encode(message: POGOProtos.Rpc.ICatchPokemonGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchPokemonGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchPokemonGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CatchPokemonGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICatchPokemonLogEntry {
            result?: (POGOProtos.Rpc.CatchPokemonLogEntry.Result|null);
            pokedex_number?: (number|null);
            combat_points?: (number|null);
            pokemon_id?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            items?: (POGOProtos.Rpc.ILootItemProto[]|null);
        }

        class CatchPokemonLogEntry implements ICatchPokemonLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICatchPokemonLogEntry);
            public result: POGOProtos.Rpc.CatchPokemonLogEntry.Result;
            public pokedex_number: number;
            public combat_points: number;
            public pokemon_id: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public items: POGOProtos.Rpc.ILootItemProto[];
            public static encode(message: POGOProtos.Rpc.ICatchPokemonLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchPokemonLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchPokemonLogEntry;
            public static toObject(message: POGOProtos.Rpc.CatchPokemonLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CatchPokemonLogEntry {

            enum Result {
                UNSET = 0,
                POKEMON_CAPTURED = 1,
                POKEMON_FLED = 2,
                POKEMON_HATCHED = 3
            }
        }

        interface ICatchPokemonOutProto {
            status?: (POGOProtos.Rpc.CatchPokemonOutProto.Status|null);
            miss_percent?: (number|null);
            captured_pokemon_id?: (number|Long|null);
            scores?: (POGOProtos.Rpc.ICaptureScoreProto|null);
            capture_reason?: (POGOProtos.Rpc.CatchPokemonOutProto.CaptureReason|null);
            display_pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            throws_remaining?: (number|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            display_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            dropped_items?: (POGOProtos.Rpc.ILootProto|null);
        }

        class CatchPokemonOutProto implements ICatchPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.ICatchPokemonOutProto);
            public status: POGOProtos.Rpc.CatchPokemonOutProto.Status;
            public miss_percent: number;
            public captured_pokemon_id: (number|Long);
            public scores?: (POGOProtos.Rpc.ICaptureScoreProto|null);
            public capture_reason: POGOProtos.Rpc.CatchPokemonOutProto.CaptureReason;
            public display_pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public throws_remaining: number;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public display_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public dropped_items?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.ICatchPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.CatchPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CatchPokemonOutProto {

            enum CaptureReason {
                UNSET = 0,
                DEFAULT = 1,
                ELEMENTAL_BADGE = 2,
                CRITICAL_CATCH = 3
            }

            enum Status {
                CATCH_ERROR = 0,
                CATCH_SUCCESS = 1,
                CATCH_ESCAPE = 2,
                CATCH_FLEE = 3,
                CATCH_MISSED = 4
            }
        }

        interface ICatchPokemonProto {
            encounter_id?: (number|Long|null);
            pokeball?: (POGOProtos.Rpc.Item|null);
            normalized_reticle_size?: (number|null);
            spawn_point_guid?: (string|null);
            hit_pokemon?: (boolean|null);
            spin_modifier?: (number|null);
            normalized_hit_position?: (number|null);
            ar_plus_values?: (POGOProtos.Rpc.IARPlusEncounterValuesProto|null);
        }

        class CatchPokemonProto implements ICatchPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ICatchPokemonProto);
            public encounter_id: (number|Long);
            public pokeball: POGOProtos.Rpc.Item;
            public normalized_reticle_size: number;
            public spawn_point_guid: string;
            public hit_pokemon: boolean;
            public spin_modifier: number;
            public normalized_hit_position: number;
            public ar_plus_values?: (POGOProtos.Rpc.IARPlusEncounterValuesProto|null);
            public static encode(message: POGOProtos.Rpc.ICatchPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchPokemonProto;
            public static toObject(message: POGOProtos.Rpc.CatchPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICatchPokemonQuestProto {
            unique_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            active_encounter_id?: (number|Long|null);
        }

        class CatchPokemonQuestProto implements ICatchPokemonQuestProto {
            constructor(properties?: POGOProtos.Rpc.ICatchPokemonQuestProto);
            public unique_pokemon_id: POGOProtos.Rpc.HoloPokemonId[];
            public active_encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICatchPokemonQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchPokemonQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchPokemonQuestProto;
            public static toObject(message: POGOProtos.Rpc.CatchPokemonQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICatchPokemonTelemetry {
            status?: (string|null);
            encounter_pokemon_telemetry?: (POGOProtos.Rpc.IEncounterPokemonTelemetry|null);
            balltype?: (POGOProtos.Rpc.Item|null);
            hit_grade?: (number|null);
            curve_ball?: (boolean|null);
            miss_percent?: (number|null);
        }

        class CatchPokemonTelemetry implements ICatchPokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.ICatchPokemonTelemetry);
            public status: string;
            public encounter_pokemon_telemetry?: (POGOProtos.Rpc.IEncounterPokemonTelemetry|null);
            public balltype: POGOProtos.Rpc.Item;
            public hit_grade: number;
            public curve_ball: boolean;
            public miss_percent: number;
            public static encode(message: POGOProtos.Rpc.ICatchPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchPokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchPokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.CatchPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICatchRadiusMultiplierSettingsProto {
            catch_radius_multiplier_settings_enabled?: (boolean|null);
        }

        class CatchRadiusMultiplierSettingsProto implements ICatchRadiusMultiplierSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICatchRadiusMultiplierSettingsProto);
            public catch_radius_multiplier_settings_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ICatchRadiusMultiplierSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CatchRadiusMultiplierSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CatchRadiusMultiplierSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CatchRadiusMultiplierSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChallengeIdMismatchData {
            non_matching_challenge_id?: (string|null);
            log_type?: (POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType|null);
        }

        class ChallengeIdMismatchData implements IChallengeIdMismatchData {
            constructor(properties?: POGOProtos.Rpc.IChallengeIdMismatchData);
            public non_matching_challenge_id: string;
            public log_type: POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType;
            public static encode(message: POGOProtos.Rpc.IChallengeIdMismatchData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChallengeIdMismatchData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChallengeIdMismatchData;
            public static toObject(message: POGOProtos.Rpc.ChallengeIdMismatchData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChallengeQuestSectionProto {
            quest_id?: (string[]|null);
        }

        class ChallengeQuestSectionProto implements IChallengeQuestSectionProto {
            constructor(properties?: POGOProtos.Rpc.IChallengeQuestSectionProto);
            public quest_id: string[];
            public static encode(message: POGOProtos.Rpc.IChallengeQuestSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChallengeQuestSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChallengeQuestSectionProto;
            public static toObject(message: POGOProtos.Rpc.ChallengeQuestSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChangeArTelemetry {
            ar_enabled?: (boolean|null);
            ar_plus_enabled?: (boolean|null);
        }

        class ChangeArTelemetry implements IChangeArTelemetry {
            constructor(properties?: POGOProtos.Rpc.IChangeArTelemetry);
            public ar_enabled: boolean;
            public ar_plus_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IChangeArTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeArTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeArTelemetry;
            public static toObject(message: POGOProtos.Rpc.ChangeArTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChangeOnlineStatusTelemetry {
            is_online_status_on?: (boolean|null);
        }

        class ChangeOnlineStatusTelemetry implements IChangeOnlineStatusTelemetry {
            constructor(properties?: POGOProtos.Rpc.IChangeOnlineStatusTelemetry);
            public is_online_status_on: boolean;
            public static encode(message: POGOProtos.Rpc.IChangeOnlineStatusTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeOnlineStatusTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeOnlineStatusTelemetry;
            public static toObject(message: POGOProtos.Rpc.ChangeOnlineStatusTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChangePokemonFormOutProto {
            result?: (POGOProtos.Rpc.ChangePokemonFormOutProto.Result|null);
            changed_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            exp_awarded?: (number|null);
            candy_awarded?: (number|null);
        }

        class ChangePokemonFormOutProto implements IChangePokemonFormOutProto {
            constructor(properties?: POGOProtos.Rpc.IChangePokemonFormOutProto);
            public result: POGOProtos.Rpc.ChangePokemonFormOutProto.Result;
            public changed_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public exp_awarded: number;
            public candy_awarded: number;
            public static encode(message: POGOProtos.Rpc.IChangePokemonFormOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangePokemonFormOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangePokemonFormOutProto;
            public static toObject(message: POGOProtos.Rpc.ChangePokemonFormOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ChangePokemonFormOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_MISSING = 2,
                ERROR_INSUFFICIENT_RESOURCES = 3,
                ERROR_QUEST_INCOMPLETE = 4,
                ERROR_POKEMON_CANNOT_CHANGE = 5,
                ERROR_POKEMON_DEPLOYED = 6,
                ERROR_FEATURE_DISABLED = 7,
                ERROR_UNKNOWN = 8
            }
        }

        interface IChangePokemonFormProto {
            pokemon_id?: (number|Long|null);
            target_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class ChangePokemonFormProto implements IChangePokemonFormProto {
            constructor(properties?: POGOProtos.Rpc.IChangePokemonFormProto);
            public pokemon_id: (number|Long);
            public target_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IChangePokemonFormProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangePokemonFormProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangePokemonFormProto;
            public static toObject(message: POGOProtos.Rpc.ChangePokemonFormProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChangeStampCollectionPlayerDataOutProto {
            result?: (POGOProtos.Rpc.ChangeStampCollectionPlayerDataOutProto.Result|null);
            collection?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto|null);
        }

        class ChangeStampCollectionPlayerDataOutProto implements IChangeStampCollectionPlayerDataOutProto {
            constructor(properties?: POGOProtos.Rpc.IChangeStampCollectionPlayerDataOutProto);
            public result: POGOProtos.Rpc.ChangeStampCollectionPlayerDataOutProto.Result;
            public collection?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto|null);
            public static encode(message: POGOProtos.Rpc.IChangeStampCollectionPlayerDataOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeStampCollectionPlayerDataOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeStampCollectionPlayerDataOutProto;
            public static toObject(message: POGOProtos.Rpc.ChangeStampCollectionPlayerDataOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ChangeStampCollectionPlayerDataOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE_NO_SUCH_COLLECTION = 2,
                FAILURE_CANNOT_MODIFY_DATA = 3
            }
        }

        interface IChangeStampCollectionPlayerDataProto {
            collection_id?: (string|null);
            paused?: (boolean|null);
            seen_opening_dialog?: (boolean|null);
        }

        class ChangeStampCollectionPlayerDataProto implements IChangeStampCollectionPlayerDataProto {
            constructor(properties?: POGOProtos.Rpc.IChangeStampCollectionPlayerDataProto);
            public collection_id: string;
            public paused?: (boolean|null);
            public seen_opening_dialog?: (boolean|null);
            public Data?: ("paused"|"seen_opening_dialog");
            public static encode(message: POGOProtos.Rpc.IChangeStampCollectionPlayerDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeStampCollectionPlayerDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeStampCollectionPlayerDataProto;
            public static toObject(message: POGOProtos.Rpc.ChangeStampCollectionPlayerDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChangeStatIncreaseGoalOutProto {
            status?: (POGOProtos.Rpc.ChangeStatIncreaseGoalOutProto.Status|null);
            trainee_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            training_quests?: (POGOProtos.Rpc.IPokemonTrainingQuestProto|null);
        }

        class ChangeStatIncreaseGoalOutProto implements IChangeStatIncreaseGoalOutProto {
            constructor(properties?: POGOProtos.Rpc.IChangeStatIncreaseGoalOutProto);
            public status: POGOProtos.Rpc.ChangeStatIncreaseGoalOutProto.Status;
            public trainee_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public training_quests?: (POGOProtos.Rpc.IPokemonTrainingQuestProto|null);
            public static encode(message: POGOProtos.Rpc.IChangeStatIncreaseGoalOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeStatIncreaseGoalOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeStatIncreaseGoalOutProto;
            public static toObject(message: POGOProtos.Rpc.ChangeStatIncreaseGoalOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ChangeStatIncreaseGoalOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_NOT_ACTIVELY_TRAINING = 2,
                ERROR_STAT_NOT_ACTIVELY_TRAINING = 3,
                ERROR_INVALID_STAT_LEVEL = 4,
                ERROR_INVALID_STAT_TYPE = 5,
                ERROR_INVALID_POKEMON = 6,
                ERROR_UNCHANGED_GOAL = 7
            }
        }

        interface IChangeStatIncreaseGoalProto {
            pokemon_id?: (number|Long|null);
            stat_types_with_goal?: (POGOProtos.Rpc.IPokemonTrainingTypeGroupProto[]|null);
        }

        class ChangeStatIncreaseGoalProto implements IChangeStatIncreaseGoalProto {
            constructor(properties?: POGOProtos.Rpc.IChangeStatIncreaseGoalProto);
            public pokemon_id: (number|Long);
            public stat_types_with_goal: POGOProtos.Rpc.IPokemonTrainingTypeGroupProto[];
            public static encode(message: POGOProtos.Rpc.IChangeStatIncreaseGoalProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeStatIncreaseGoalProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeStatIncreaseGoalProto;
            public static toObject(message: POGOProtos.Rpc.ChangeStatIncreaseGoalProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChangeTeamOutProto {
            status?: (POGOProtos.Rpc.ChangeTeamOutProto.Status|null);
            updated_player?: (POGOProtos.Rpc.IClientPlayerProto|null);
        }

        class ChangeTeamOutProto implements IChangeTeamOutProto {
            constructor(properties?: POGOProtos.Rpc.IChangeTeamOutProto);
            public status: POGOProtos.Rpc.ChangeTeamOutProto.Status;
            public updated_player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public static encode(message: POGOProtos.Rpc.IChangeTeamOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeTeamOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeTeamOutProto;
            public static toObject(message: POGOProtos.Rpc.ChangeTeamOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ChangeTeamOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_SAME_TEAM = 2,
                ERROR_ITEM_NOT_IN_INVENTORY = 3,
                ERROR_WRONG_ITEM = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IChangeTeamProto {
            item?: (POGOProtos.Rpc.Item|null);
            team?: (POGOProtos.Rpc.Team|null);
        }

        class ChangeTeamProto implements IChangeTeamProto {
            constructor(properties?: POGOProtos.Rpc.IChangeTeamProto);
            public item: POGOProtos.Rpc.Item;
            public team: POGOProtos.Rpc.Team;
            public static encode(message: POGOProtos.Rpc.IChangeTeamProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChangeTeamProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChangeTeamProto;
            public static toObject(message: POGOProtos.Rpc.ChangeTeamProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICharacterDisplayProto {
            style?: (POGOProtos.Rpc.EnumWrapper.PokestopStyle|null);
            character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
        }

        class CharacterDisplayProto implements ICharacterDisplayProto {
            constructor(properties?: POGOProtos.Rpc.ICharacterDisplayProto);
            public style: POGOProtos.Rpc.EnumWrapper.PokestopStyle;
            public character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public static encode(message: POGOProtos.Rpc.ICharacterDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CharacterDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CharacterDisplayProto;
            public static toObject(message: POGOProtos.Rpc.CharacterDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckAwardedBadgesOutProto {
            success?: (boolean|null);
            awarded_badges?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            awarded_badge_levels?: (number[]|null);
            avatar_template_ids?: (string[]|null);
            neutral_avatar_template_ids?: (string[]|null);
        }

        class CheckAwardedBadgesOutProto implements ICheckAwardedBadgesOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckAwardedBadgesOutProto);
            public success: boolean;
            public awarded_badges: POGOProtos.Rpc.HoloBadgeType[];
            public awarded_badge_levels: number[];
            public avatar_template_ids: string[];
            public neutral_avatar_template_ids: string[];
            public static encode(message: POGOProtos.Rpc.ICheckAwardedBadgesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckAwardedBadgesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckAwardedBadgesOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckAwardedBadgesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckAwardedBadgesProto {
        }

        class CheckAwardedBadgesProto implements ICheckAwardedBadgesProto {
            constructor(properties?: POGOProtos.Rpc.ICheckAwardedBadgesProto);
            public static encode(message: POGOProtos.Rpc.ICheckAwardedBadgesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckAwardedBadgesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckAwardedBadgesProto;
            public static toObject(message: POGOProtos.Rpc.CheckAwardedBadgesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckChallengeOutProto {
            show_challenge?: (boolean|null);
            challenge_url?: (string|null);
        }

        class CheckChallengeOutProto implements ICheckChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckChallengeOutProto);
            public show_challenge: boolean;
            public challenge_url: string;
            public static encode(message: POGOProtos.Rpc.ICheckChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckChallengeProto {
            debug_request?: (boolean|null);
        }

        class CheckChallengeProto implements ICheckChallengeProto {
            constructor(properties?: POGOProtos.Rpc.ICheckChallengeProto);
            public debug_request: boolean;
            public static encode(message: POGOProtos.Rpc.ICheckChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckChallengeProto;
            public static toObject(message: POGOProtos.Rpc.CheckChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckContestEligibilityOutProto {
            status?: (POGOProtos.Rpc.CheckContestEligibilityOutProto.Status|null);
            pokemon_id_to_replace?: (number|Long|null);
        }

        class CheckContestEligibilityOutProto implements ICheckContestEligibilityOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckContestEligibilityOutProto);
            public status: POGOProtos.Rpc.CheckContestEligibilityOutProto.Status;
            public pokemon_id_to_replace: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICheckContestEligibilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckContestEligibilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckContestEligibilityOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckContestEligibilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CheckContestEligibilityOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                OUT_OF_RANGE = 3,
                PLAYER_LIMIT_REACHED = 4,
                CONTEST_LIMIT_REACHED = 5,
                SAME_CYCLE_TRADE_NOT_ALLOWED = 6,
                SAME_SEASON_WINNER_NOT_ALLOWED = 7,
                POKEMON_IN_OTHER_CONTEST = 8,
                POKEMON_IN_OTHER_CONTEST_NEED_SUBSTITUTION = 9,
                NEED_SUBSTITUTION = 10,
                PENDING_REWARD_ENTRY_NOT_ALLOWED = 11
            }
        }

        interface ICheckContestEligibilityProto {
            fort_id?: (string|null);
            contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id?: (number|Long|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
        }

        class CheckContestEligibilityProto implements ICheckContestEligibilityProto {
            constructor(properties?: POGOProtos.Rpc.ICheckContestEligibilityProto);
            public fort_id: string;
            public contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id: (number|Long);
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.ICheckContestEligibilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckContestEligibilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckContestEligibilityProto;
            public static toObject(message: POGOProtos.Rpc.CheckContestEligibilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckEncounterTrayInfoTelemetry {
            berry_tray_info?: (boolean|null);
            ball_tray_info?: (boolean|null);
        }

        class CheckEncounterTrayInfoTelemetry implements ICheckEncounterTrayInfoTelemetry {
            constructor(properties?: POGOProtos.Rpc.ICheckEncounterTrayInfoTelemetry);
            public berry_tray_info: boolean;
            public ball_tray_info: boolean;
            public static encode(message: POGOProtos.Rpc.ICheckEncounterTrayInfoTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckEncounterTrayInfoTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckEncounterTrayInfoTelemetry;
            public static toObject(message: POGOProtos.Rpc.CheckEncounterTrayInfoTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckGiftingEligibilityOutProto {
            gifting_eligibility?: (POGOProtos.Rpc.IGiftingEligibilityStatusProto|null);
        }

        class CheckGiftingEligibilityOutProto implements ICheckGiftingEligibilityOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckGiftingEligibilityOutProto);
            public gifting_eligibility?: (POGOProtos.Rpc.IGiftingEligibilityStatusProto|null);
            public static encode(message: POGOProtos.Rpc.ICheckGiftingEligibilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckGiftingEligibilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckGiftingEligibilityOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckGiftingEligibilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckGiftingEligibilityProto {
            gifting_iap_item?: (POGOProtos.Rpc.IGiftingIapItemProto|null);
            recipient_friend_id?: (string|null);
        }

        class CheckGiftingEligibilityProto implements ICheckGiftingEligibilityProto {
            constructor(properties?: POGOProtos.Rpc.ICheckGiftingEligibilityProto);
            public gifting_iap_item?: (POGOProtos.Rpc.IGiftingIapItemProto|null);
            public recipient_friend_id: string;
            public static encode(message: POGOProtos.Rpc.ICheckGiftingEligibilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckGiftingEligibilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckGiftingEligibilityProto;
            public static toObject(message: POGOProtos.Rpc.CheckGiftingEligibilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckPhotobombOutProto {
            status?: (POGOProtos.Rpc.CheckPhotobombOutProto.Status|null);
            photobomb_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            photobomb_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            encounter_id?: (number|Long|null);
            uri?: (string|null);
        }

        class CheckPhotobombOutProto implements ICheckPhotobombOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckPhotobombOutProto);
            public status: POGOProtos.Rpc.CheckPhotobombOutProto.Status;
            public photobomb_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public photobomb_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public encounter_id: (number|Long);
            public uri: string;
            public static encode(message: POGOProtos.Rpc.ICheckPhotobombOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckPhotobombOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckPhotobombOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckPhotobombOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CheckPhotobombOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PHOTO_POKEMON_INVALID = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface ICheckPhotobombProto {
            photo_pokemon_id?: (number|Long|null);
            photo_context?: (POGOProtos.Rpc.ArContext|null);
        }

        class CheckPhotobombProto implements ICheckPhotobombProto {
            constructor(properties?: POGOProtos.Rpc.ICheckPhotobombProto);
            public photo_pokemon_id: (number|Long);
            public photo_context: POGOProtos.Rpc.ArContext;
            public static encode(message: POGOProtos.Rpc.ICheckPhotobombProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckPhotobombProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckPhotobombProto;
            public static toObject(message: POGOProtos.Rpc.CheckPhotobombProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckPokemonSizeLeaderboardEligibilityOutProto {
            status?: (POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityOutProto.Status|null);
            pokemon_id_to_replace?: (number|Long|null);
        }

        class CheckPokemonSizeLeaderboardEligibilityOutProto implements ICheckPokemonSizeLeaderboardEligibilityOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityOutProto);
            public status: POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityOutProto.Status;
            public pokemon_id_to_replace: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CheckPokemonSizeLeaderboardEligibilityOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                OUT_OF_RANGE = 3,
                PLAYER_LIMIT_REACHED = 4,
                CONTEST_LIMIT_REACHED = 5,
                SAME_CYCLE_TRADE_NOT_ALLOWED = 6,
                SAME_SEASON_WINNER_NOT_ALLOWED = 7,
                POKEMON_IN_OTHER_CONTEST = 8,
                POKEMON_IN_OTHER_CONTEST_NEED_SUBSTITUTION = 9,
                NEED_SUBSTITUTION = 10,
                PENDING_REWARD_ENTRY_NOT_ALLOWED = 11
            }
        }

        interface ICheckPokemonSizeLeaderboardEligibilityProto {
            fort_id?: (string|null);
            contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id?: (number|Long|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
        }

        class CheckPokemonSizeLeaderboardEligibilityProto implements ICheckPokemonSizeLeaderboardEligibilityProto {
            constructor(properties?: POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityProto);
            public fort_id: string;
            public contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id: (number|Long);
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.ICheckPokemonSizeLeaderboardEligibilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityProto;
            public static toObject(message: POGOProtos.Rpc.CheckPokemonSizeLeaderboardEligibilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckSendGiftOutProto {
            result?: (POGOProtos.Rpc.CheckSendGiftOutProto.Result|null);
        }

        class CheckSendGiftOutProto implements ICheckSendGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckSendGiftOutProto);
            public result: POGOProtos.Rpc.CheckSendGiftOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICheckSendGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckSendGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckSendGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckSendGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CheckSendGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_DOES_NOT_EXIST = 3,
                ERROR_GIFT_NOT_AVAILABLE = 4,
                ERROR_GIFT_ALREADY_SENT_TODAY = 5,
                ERROR_PLAYER_HAS_UNOPENED_GIFT = 6
            }
        }

        interface ICheckSendGiftProto {
            player_id?: (string|null);
        }

        class CheckSendGiftProto implements ICheckSendGiftProto {
            constructor(properties?: POGOProtos.Rpc.ICheckSendGiftProto);
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.ICheckSendGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckSendGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckSendGiftProto;
            public static toObject(message: POGOProtos.Rpc.CheckSendGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICheckStampGiftabilityOutProto {
            result?: (POGOProtos.Rpc.CheckStampGiftabilityOutProto.Result|null);
        }

        class CheckStampGiftabilityOutProto implements ICheckStampGiftabilityOutProto {
            constructor(properties?: POGOProtos.Rpc.ICheckStampGiftabilityOutProto);
            public result: POGOProtos.Rpc.CheckStampGiftabilityOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICheckStampGiftabilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckStampGiftabilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckStampGiftabilityOutProto;
            public static toObject(message: POGOProtos.Rpc.CheckStampGiftabilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CheckStampGiftabilityOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PREFERENCES = 2,
                ERROR_ALREADY_STAMPED = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface ICheckStampGiftabilityProto {
            fort_id?: (string|null);
            collection_id?: (string|null);
            friend_id?: (string|null);
        }

        class CheckStampGiftabilityProto implements ICheckStampGiftabilityProto {
            constructor(properties?: POGOProtos.Rpc.ICheckStampGiftabilityProto);
            public fort_id: string;
            public collection_id: string;
            public friend_id: string;
            public static encode(message: POGOProtos.Rpc.ICheckStampGiftabilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CheckStampGiftabilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CheckStampGiftabilityProto;
            public static toObject(message: POGOProtos.Rpc.CheckStampGiftabilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IChooseGlobalTicketedEventVariantOutProto {
            status?: (POGOProtos.Rpc.ChooseGlobalTicketedEventVariantOutProto.Status|null);
        }

        class ChooseGlobalTicketedEventVariantOutProto implements IChooseGlobalTicketedEventVariantOutProto {
            constructor(properties?: POGOProtos.Rpc.IChooseGlobalTicketedEventVariantOutProto);
            public status: POGOProtos.Rpc.ChooseGlobalTicketedEventVariantOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IChooseGlobalTicketedEventVariantOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChooseGlobalTicketedEventVariantOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChooseGlobalTicketedEventVariantOutProto;
            public static toObject(message: POGOProtos.Rpc.ChooseGlobalTicketedEventVariantOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ChooseGlobalTicketedEventVariantOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_HAS_REQUESTED_BADGE = 2,
                ERROR_HAS_MUTUALLY_EXCLUSIVE_BADGE = 3
            }
        }

        interface IChooseGlobalTicketedEventVariantProto {
            target_variant?: (POGOProtos.Rpc.HoloBadgeType|null);
        }

        class ChooseGlobalTicketedEventVariantProto implements IChooseGlobalTicketedEventVariantProto {
            constructor(properties?: POGOProtos.Rpc.IChooseGlobalTicketedEventVariantProto);
            public target_variant: POGOProtos.Rpc.HoloBadgeType;
            public static encode(message: POGOProtos.Rpc.IChooseGlobalTicketedEventVariantProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ChooseGlobalTicketedEventVariantProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ChooseGlobalTicketedEventVariantProto;
            public static toObject(message: POGOProtos.Rpc.ChooseGlobalTicketedEventVariantProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICircleShape {
            lat?: (number|null);
            lng?: (number|null);
            radius_meters?: (number|null);
        }

        class CircleShape implements ICircleShape {
            constructor(properties?: POGOProtos.Rpc.ICircleShape);
            public lat: number;
            public lng: number;
            public radius_meters: number;
            public static encode(message: POGOProtos.Rpc.ICircleShape, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CircleShape;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CircleShape;
            public static toObject(message: POGOProtos.Rpc.CircleShape, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimCodenameRequestProto {
            codename?: (string|null);
            force?: (boolean|null);
            generate_suggested_codenames?: (boolean|null);
        }

        class ClaimCodenameRequestProto implements IClaimCodenameRequestProto {
            constructor(properties?: POGOProtos.Rpc.IClaimCodenameRequestProto);
            public codename: string;
            public force: boolean;
            public generate_suggested_codenames: boolean;
            public static encode(message: POGOProtos.Rpc.IClaimCodenameRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimCodenameRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimCodenameRequestProto;
            public static toObject(message: POGOProtos.Rpc.ClaimCodenameRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimContestsRewardsOutProto {
            status?: (POGOProtos.Rpc.ClaimContestsRewardsOutProto.Status|null);
            rewards_per_contest?: (POGOProtos.Rpc.IRewardsPerContestProto[]|null);
        }

        class ClaimContestsRewardsOutProto implements IClaimContestsRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IClaimContestsRewardsOutProto);
            public status: POGOProtos.Rpc.ClaimContestsRewardsOutProto.Status;
            public rewards_per_contest: POGOProtos.Rpc.IRewardsPerContestProto[];
            public static encode(message: POGOProtos.Rpc.IClaimContestsRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimContestsRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimContestsRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.ClaimContestsRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClaimContestsRewardsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IClaimContestsRewardsProto {
        }

        class ClaimContestsRewardsProto implements IClaimContestsRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IClaimContestsRewardsProto);
            public static encode(message: POGOProtos.Rpc.IClaimContestsRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimContestsRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimContestsRewardsProto;
            public static toObject(message: POGOProtos.Rpc.ClaimContestsRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimEventPassRewardsLogEntry {
            event_pass_id?: (string|null);
            event_pass_title_key?: (string|null);
            slot_rewards?: (POGOProtos.Rpc.IEventPassSlotRewardProto[]|null);
        }

        class ClaimEventPassRewardsLogEntry implements IClaimEventPassRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IClaimEventPassRewardsLogEntry);
            public event_pass_id: string;
            public event_pass_title_key: string;
            public slot_rewards: POGOProtos.Rpc.IEventPassSlotRewardProto[];
            public static encode(message: POGOProtos.Rpc.IClaimEventPassRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimEventPassRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimEventPassRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.ClaimEventPassRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimEventPassRewardsRequestProto {
            pass_id?: (string|null);
            reward_slots?: (POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.IClaimRewardsSlotProto[]|null);
            claim_all_rewards?: (boolean|null);
        }

        class ClaimEventPassRewardsRequestProto implements IClaimEventPassRewardsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IClaimEventPassRewardsRequestProto);
            public pass_id: string;
            public reward_slots: POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.IClaimRewardsSlotProto[];
            public claim_all_rewards: boolean;
            public static encode(message: POGOProtos.Rpc.IClaimEventPassRewardsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimEventPassRewardsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimEventPassRewardsRequestProto;
            public static toObject(message: POGOProtos.Rpc.ClaimEventPassRewardsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClaimEventPassRewardsRequestProto {

            interface IClaimRewardsSlotProto {
                track?: (POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack|null);
                rank?: (number|null);
            }

            class ClaimRewardsSlotProto implements IClaimRewardsSlotProto {
                constructor(properties?: POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.IClaimRewardsSlotProto);
                public track: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack;
                public rank: number;
                public static encode(message: POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.IClaimRewardsSlotProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.ClaimRewardsSlotProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.ClaimRewardsSlotProto;
                public static toObject(message: POGOProtos.Rpc.ClaimEventPassRewardsRequestProto.ClaimRewardsSlotProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IClaimEventPassRewardsResponseProto {
            status?: (POGOProtos.Rpc.ClaimEventPassRewardsResponseProto.Status|null);
            rewards_granted?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class ClaimEventPassRewardsResponseProto implements IClaimEventPassRewardsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IClaimEventPassRewardsResponseProto);
            public status: POGOProtos.Rpc.ClaimEventPassRewardsResponseProto.Status;
            public rewards_granted: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IClaimEventPassRewardsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimEventPassRewardsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimEventPassRewardsResponseProto;
            public static toObject(message: POGOProtos.Rpc.ClaimEventPassRewardsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClaimEventPassRewardsResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_INVALID_PASS = 3,
                ERROR_INVALID_REWARD = 4,
                ERROR_UNAVAILABLE_REWARD_RANK = 5,
                ERROR_UNAVAILABLE_REWARD_TRACK = 6,
                ERROR_REWARD_ALREADY_CLAIMED = 7
            }
        }

        interface IClaimPtcLinkingRewardOutProto {
            status?: (POGOProtos.Rpc.ClaimPtcLinkingRewardOutProto.Status|null);
        }

        class ClaimPtcLinkingRewardOutProto implements IClaimPtcLinkingRewardOutProto {
            constructor(properties?: POGOProtos.Rpc.IClaimPtcLinkingRewardOutProto);
            public status: POGOProtos.Rpc.ClaimPtcLinkingRewardOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IClaimPtcLinkingRewardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimPtcLinkingRewardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimPtcLinkingRewardOutProto;
            public static toObject(message: POGOProtos.Rpc.ClaimPtcLinkingRewardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClaimPtcLinkingRewardOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_GMT = 3,
                ERROR_ITEM_NOT_SUPPORTED = 4,
                ERROR_REWARD_CLAIMED_ALREADY = 5
            }
        }

        interface IClaimPtcLinkingRewardProto {
        }

        class ClaimPtcLinkingRewardProto implements IClaimPtcLinkingRewardProto {
            constructor(properties?: POGOProtos.Rpc.IClaimPtcLinkingRewardProto);
            public static encode(message: POGOProtos.Rpc.IClaimPtcLinkingRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimPtcLinkingRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimPtcLinkingRewardProto;
            public static toObject(message: POGOProtos.Rpc.ClaimPtcLinkingRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimRewardsSlotProto {
            track?: (POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack|null);
            rank?: (number|null);
        }

        class ClaimRewardsSlotProto implements IClaimRewardsSlotProto {
            constructor(properties?: POGOProtos.Rpc.IClaimRewardsSlotProto);
            public track: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack;
            public rank: number;
            public static encode(message: POGOProtos.Rpc.IClaimRewardsSlotProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimRewardsSlotProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimRewardsSlotProto;
            public static toObject(message: POGOProtos.Rpc.ClaimRewardsSlotProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimStampCollectionRewardOutProto {
            result?: (POGOProtos.Rpc.ClaimStampCollectionRewardOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.ISpawnablePokemon|null);
            collection?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto|null);
            rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class ClaimStampCollectionRewardOutProto implements IClaimStampCollectionRewardOutProto {
            constructor(properties?: POGOProtos.Rpc.IClaimStampCollectionRewardOutProto);
            public result: POGOProtos.Rpc.ClaimStampCollectionRewardOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.ISpawnablePokemon|null);
            public collection?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto|null);
            public rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IClaimStampCollectionRewardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimStampCollectionRewardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimStampCollectionRewardOutProto;
            public static toObject(message: POGOProtos.Rpc.ClaimStampCollectionRewardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClaimStampCollectionRewardOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE_ALREADY_CLAIMED = 2,
                FAILURE_NO_SUCH_REWARD = 3,
                FAILURE_NOT_ENOUGH_PROGRESS = 4,
                FAILURE_NOT_IN_RANGE = 5,
                FAILURE_NOT_SUCH_COLLECTION = 6
            }
        }

        interface IClaimStampCollectionRewardProto {
            collection_id?: (string|null);
            stamp_count_goal?: (number|null);
            selected_fort_id?: (string|null);
        }

        class ClaimStampCollectionRewardProto implements IClaimStampCollectionRewardProto {
            constructor(properties?: POGOProtos.Rpc.IClaimStampCollectionRewardProto);
            public collection_id: string;
            public stamp_count_goal: number;
            public selected_fort_id: string;
            public static encode(message: POGOProtos.Rpc.IClaimStampCollectionRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimStampCollectionRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimStampCollectionRewardProto;
            public static toObject(message: POGOProtos.Rpc.ClaimStampCollectionRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClaimVsSeekerRewardsOutProto {
            result?: (POGOProtos.Rpc.ClaimVsSeekerRewardsOutProto.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class ClaimVsSeekerRewardsOutProto implements IClaimVsSeekerRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IClaimVsSeekerRewardsOutProto);
            public result: POGOProtos.Rpc.ClaimVsSeekerRewardsOutProto.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IClaimVsSeekerRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimVsSeekerRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimVsSeekerRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.ClaimVsSeekerRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClaimVsSeekerRewardsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_REDEEM_POKEMON = 2,
                ERROR_PLAYER_NOT_ENOUGH_VICTORIES = 3,
                ERROR_REWARD_ALREADY_CLAIMED = 4,
                ERROR_INVENTORY_FULL = 5
            }
        }

        interface IClaimVsSeekerRewardsProto {
            win_index?: (number|null);
        }

        class ClaimVsSeekerRewardsProto implements IClaimVsSeekerRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IClaimVsSeekerRewardsProto);
            public win_index: number;
            public static encode(message: POGOProtos.Rpc.IClaimVsSeekerRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClaimVsSeekerRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClaimVsSeekerRewardsProto;
            public static toObject(message: POGOProtos.Rpc.ClaimVsSeekerRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientBreadcrumbSessionSettings {
            session_duration_m?: (number|null);
            update_interval_s?: (number|null);
            as_fallback_foreground_reporting_interval_s?: (number|null);
        }

        class ClientBreadcrumbSessionSettings implements IClientBreadcrumbSessionSettings {
            constructor(properties?: POGOProtos.Rpc.IClientBreadcrumbSessionSettings);
            public session_duration_m: number;
            public update_interval_s: number;
            public as_fallback_foreground_reporting_interval_s: number;
            public static encode(message: POGOProtos.Rpc.IClientBreadcrumbSessionSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientBreadcrumbSessionSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientBreadcrumbSessionSettings;
            public static toObject(message: POGOProtos.Rpc.ClientBreadcrumbSessionSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientContestIncidentProto {
            contests?: (POGOProtos.Rpc.IContestProto[]|null);
        }

        class ClientContestIncidentProto implements IClientContestIncidentProto {
            constructor(properties?: POGOProtos.Rpc.IClientContestIncidentProto);
            public contests: POGOProtos.Rpc.IContestProto[];
            public static encode(message: POGOProtos.Rpc.IClientContestIncidentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientContestIncidentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientContestIncidentProto;
            public static toObject(message: POGOProtos.Rpc.ClientContestIncidentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientDialogueLineProto {
            text?: (string|null);
            character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
            expression?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacterExpression|null);
            left_asset_address?: (string|null);
            side?: (POGOProtos.Rpc.ClientDialogueLineProto.Side|null);
            display_only_loot?: (POGOProtos.Rpc.ILootProto|null);
        }

        class ClientDialogueLineProto implements IClientDialogueLineProto {
            constructor(properties?: POGOProtos.Rpc.IClientDialogueLineProto);
            public text: string;
            public character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public expression: POGOProtos.Rpc.EnumWrapper.InvasionCharacterExpression;
            public left_asset_address: string;
            public side: POGOProtos.Rpc.ClientDialogueLineProto.Side;
            public display_only_loot?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IClientDialogueLineProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientDialogueLineProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientDialogueLineProto;
            public static toObject(message: POGOProtos.Rpc.ClientDialogueLineProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClientDialogueLineProto {

            enum Side {
                UNSET = 0,
                RIGHT = 1,
                LEFT = 2
            }
        }

        interface IClientEnvironmentProto {
            language_code?: (string|null);
            timezone?: (string|null);
            device_country_code?: (string|null);
            ip_country_code?: (string|null);
            client_version?: (string|null);
            device_type?: (string|null);
            device_os?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
        }

        class ClientEnvironmentProto implements IClientEnvironmentProto {
            constructor(properties?: POGOProtos.Rpc.IClientEnvironmentProto);
            public language_code: string;
            public timezone: string;
            public device_country_code: string;
            public ip_country_code: string;
            public client_version: string;
            public device_type: string;
            public device_os: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public static encode(message: POGOProtos.Rpc.IClientEnvironmentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientEnvironmentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientEnvironmentProto;
            public static toObject(message: POGOProtos.Rpc.ClientEnvironmentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientEvolutionQuestTemplateProto {
            quest_template_id?: (string|null);
            quest_type?: (POGOProtos.Rpc.QuestType|null);
            goals?: (POGOProtos.Rpc.IQuestGoalProto[]|null);
            context?: (POGOProtos.Rpc.QuestProto.Context|null);
            display?: (POGOProtos.Rpc.IQuestDisplayProto|null);
        }

        class ClientEvolutionQuestTemplateProto implements IClientEvolutionQuestTemplateProto {
            constructor(properties?: POGOProtos.Rpc.IClientEvolutionQuestTemplateProto);
            public quest_template_id: string;
            public quest_type: POGOProtos.Rpc.QuestType;
            public goals: POGOProtos.Rpc.IQuestGoalProto[];
            public context: POGOProtos.Rpc.QuestProto.Context;
            public display?: (POGOProtos.Rpc.IQuestDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IClientEvolutionQuestTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientEvolutionQuestTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientEvolutionQuestTemplateProto;
            public static toObject(message: POGOProtos.Rpc.ClientEvolutionQuestTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientFortModifierProto {
            modifier_type?: (POGOProtos.Rpc.Item|null);
            expiration_time_ms?: (number|Long|null);
            deploying_player_codename?: (string|null);
        }

        class ClientFortModifierProto implements IClientFortModifierProto {
            constructor(properties?: POGOProtos.Rpc.IClientFortModifierProto);
            public modifier_type: POGOProtos.Rpc.Item;
            public expiration_time_ms: (number|Long);
            public deploying_player_codename: string;
            public static encode(message: POGOProtos.Rpc.IClientFortModifierProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientFortModifierProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientFortModifierProto;
            public static toObject(message: POGOProtos.Rpc.ClientFortModifierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientGameMasterTemplateProto {
            template_id?: (string|null);
            data?: (POGOProtos.Rpc.IGameMasterClientTemplateProto|null);
        }

        class ClientGameMasterTemplateProto implements IClientGameMasterTemplateProto {
            constructor(properties?: POGOProtos.Rpc.IClientGameMasterTemplateProto);
            public template_id: string;
            public data?: (POGOProtos.Rpc.IGameMasterClientTemplateProto|null);
            public static encode(message: POGOProtos.Rpc.IClientGameMasterTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientGameMasterTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientGameMasterTemplateProto;
            public static toObject(message: POGOProtos.Rpc.ClientGameMasterTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientGenderProto {
            male_percent?: (number|null);
            female_percent?: (number|null);
            genderless_percent?: (number|null);
        }

        class ClientGenderProto implements IClientGenderProto {
            constructor(properties?: POGOProtos.Rpc.IClientGenderProto);
            public male_percent: number;
            public female_percent: number;
            public genderless_percent: number;
            public static encode(message: POGOProtos.Rpc.IClientGenderProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientGenderProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientGenderProto;
            public static toObject(message: POGOProtos.Rpc.ClientGenderProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientGenderSettingsProto {
            pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            gender?: (POGOProtos.Rpc.IClientGenderProto|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class ClientGenderSettingsProto implements IClientGenderSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IClientGenderSettingsProto);
            public pokemon: POGOProtos.Rpc.HoloPokemonId;
            public gender?: (POGOProtos.Rpc.IClientGenderProto|null);
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IClientGenderSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientGenderSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientGenderSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ClientGenderSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientInbox {
            notifications?: (POGOProtos.Rpc.ClientInbox.INotification[]|null);
            builtin_variables?: (POGOProtos.Rpc.ITemplateVariable[]|null);
        }

        class ClientInbox implements IClientInbox {
            constructor(properties?: POGOProtos.Rpc.IClientInbox);
            public notifications: POGOProtos.Rpc.ClientInbox.INotification[];
            public builtin_variables: POGOProtos.Rpc.ITemplateVariable[];
            public static encode(message: POGOProtos.Rpc.IClientInbox, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientInbox;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientInbox;
            public static toObject(message: POGOProtos.Rpc.ClientInbox, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClientInbox {

            enum Label {
                UNSET_LABEL = 0,
                UNREAD = 1,
                NEW = 2,
                IMMEDIATE = 3
            }

            interface INotification {
                notification_id?: (string|null);
                title_key?: (string|null);
                category?: (string|null);
                create_timestamp_ms?: (number|Long|null);
                variables?: (POGOProtos.Rpc.ITemplateVariable[]|null);
                labels?: (POGOProtos.Rpc.ClientInbox.Label[]|null);
                expire_time_ms?: (number|Long|null);
            }

            class Notification implements INotification {
                constructor(properties?: POGOProtos.Rpc.ClientInbox.INotification);
                public notification_id: string;
                public title_key: string;
                public category: string;
                public create_timestamp_ms: (number|Long);
                public variables: POGOProtos.Rpc.ITemplateVariable[];
                public labels: POGOProtos.Rpc.ClientInbox.Label[];
                public expire_time_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.ClientInbox.INotification, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientInbox.Notification;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientInbox.Notification;
                public static toObject(message: POGOProtos.Rpc.ClientInbox.Notification, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IClientIncidentProto {
            incident_id?: (string|null);
            fort_id?: (string|null);
            fort_name?: (string|null);
            pokestop_image_uri?: (string|null);
            current_step?: (number|null);
            step?: (POGOProtos.Rpc.IClientIncidentStepProto[]|null);
            completion_display?: (POGOProtos.Rpc.IPokestopIncidentDisplayProto|null);
            context?: (POGOProtos.Rpc.EnumWrapper.InvasionContext|null);
            start_phase?: (POGOProtos.Rpc.EnumWrapper.IncidentStartPhase|null);
        }

        class ClientIncidentProto implements IClientIncidentProto {
            constructor(properties?: POGOProtos.Rpc.IClientIncidentProto);
            public incident_id: string;
            public fort_id: string;
            public fort_name: string;
            public pokestop_image_uri: string;
            public current_step: number;
            public step: POGOProtos.Rpc.IClientIncidentStepProto[];
            public completion_display?: (POGOProtos.Rpc.IPokestopIncidentDisplayProto|null);
            public context: POGOProtos.Rpc.EnumWrapper.InvasionContext;
            public start_phase: POGOProtos.Rpc.EnumWrapper.IncidentStartPhase;
            public static encode(message: POGOProtos.Rpc.IClientIncidentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientIncidentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientIncidentProto;
            public static toObject(message: POGOProtos.Rpc.ClientIncidentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientIncidentStepProto {
            invasion_battle?: (POGOProtos.Rpc.IClientInvasionBattleStepProto|null);
            invasion_encounter?: (POGOProtos.Rpc.IClientInvasionEncounterStepProto|null);
            pokestop_dialogue?: (POGOProtos.Rpc.IClientPokestopNpcDialogueStepProto|null);
            pokestop_spin?: (POGOProtos.Rpc.IClientPokestopSpinStepProto|null);
        }

        class ClientIncidentStepProto implements IClientIncidentStepProto {
            constructor(properties?: POGOProtos.Rpc.IClientIncidentStepProto);
            public invasion_battle?: (POGOProtos.Rpc.IClientInvasionBattleStepProto|null);
            public invasion_encounter?: (POGOProtos.Rpc.IClientInvasionEncounterStepProto|null);
            public pokestop_dialogue?: (POGOProtos.Rpc.IClientPokestopNpcDialogueStepProto|null);
            public pokestop_spin?: (POGOProtos.Rpc.IClientPokestopSpinStepProto|null);
            public ClientIncidentStep?: ("invasion_battle"|"invasion_encounter"|"pokestop_dialogue"|"pokestop_spin");
            public static encode(message: POGOProtos.Rpc.IClientIncidentStepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientIncidentStepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientIncidentStepProto;
            public static toObject(message: POGOProtos.Rpc.ClientIncidentStepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientInvasionBattleStepProto {
            character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
        }

        class ClientInvasionBattleStepProto implements IClientInvasionBattleStepProto {
            constructor(properties?: POGOProtos.Rpc.IClientInvasionBattleStepProto);
            public character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public static encode(message: POGOProtos.Rpc.IClientInvasionBattleStepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientInvasionBattleStepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientInvasionBattleStepProto;
            public static toObject(message: POGOProtos.Rpc.ClientInvasionBattleStepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientInvasionEncounterStepProto {
        }

        class ClientInvasionEncounterStepProto implements IClientInvasionEncounterStepProto {
            constructor(properties?: POGOProtos.Rpc.IClientInvasionEncounterStepProto);
            public static encode(message: POGOProtos.Rpc.IClientInvasionEncounterStepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientInvasionEncounterStepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientInvasionEncounterStepProto;
            public static toObject(message: POGOProtos.Rpc.ClientInvasionEncounterStepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientMapCellProto {
            s2_cell_id?: (number|Long|null);
            as_of_time_ms?: (number|Long|null);
            fort?: (POGOProtos.Rpc.IPokemonFortProto[]|null);
            spawn_point?: (POGOProtos.Rpc.IClientSpawnPointProto[]|null);
            wild_pokemon?: (POGOProtos.Rpc.IWildPokemonProto[]|null);
            deleted_object?: (string[]|null);
            is_truncated_list?: (boolean|null);
            fort_summary?: (POGOProtos.Rpc.IPokemonSummaryFortProto[]|null);
            decimated_spawn_point?: (POGOProtos.Rpc.IClientSpawnPointProto[]|null);
            catchable_pokemon?: (POGOProtos.Rpc.IMapPokemonProto[]|null);
            nearby_pokemon?: (POGOProtos.Rpc.INearbyPokemonProto[]|null);
            route_list_hash?: (string|null);
            hyperlocal_experiment?: (POGOProtos.Rpc.IHyperlocalExperimentClientProto[]|null);
            stations?: (POGOProtos.Rpc.IStationProto[]|null);
            num_vps_activated_locations?: (number|null);
            tappables?: (POGOProtos.Rpc.ITappable[]|null);
        }

        class ClientMapCellProto implements IClientMapCellProto {
            constructor(properties?: POGOProtos.Rpc.IClientMapCellProto);
            public s2_cell_id: (number|Long);
            public as_of_time_ms: (number|Long);
            public fort: POGOProtos.Rpc.IPokemonFortProto[];
            public spawn_point: POGOProtos.Rpc.IClientSpawnPointProto[];
            public wild_pokemon: POGOProtos.Rpc.IWildPokemonProto[];
            public deleted_object: string[];
            public is_truncated_list: boolean;
            public fort_summary: POGOProtos.Rpc.IPokemonSummaryFortProto[];
            public decimated_spawn_point: POGOProtos.Rpc.IClientSpawnPointProto[];
            public catchable_pokemon: POGOProtos.Rpc.IMapPokemonProto[];
            public nearby_pokemon: POGOProtos.Rpc.INearbyPokemonProto[];
            public route_list_hash: string;
            public hyperlocal_experiment: POGOProtos.Rpc.IHyperlocalExperimentClientProto[];
            public stations: POGOProtos.Rpc.IStationProto[];
            public num_vps_activated_locations: number;
            public tappables: POGOProtos.Rpc.ITappable[];
            public static encode(message: POGOProtos.Rpc.IClientMapCellProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientMapCellProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientMapCellProto;
            public static toObject(message: POGOProtos.Rpc.ClientMapCellProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientMapObjectsInteractionRangeSettingsProto {
            interaction_range_meters?: (number|null);
            far_interaction_range_meters?: (number|null);
            remote_interaction_range_meters?: (number|null);
            white_pulse_radius_meters?: (number|null);
        }

        class ClientMapObjectsInteractionRangeSettingsProto implements IClientMapObjectsInteractionRangeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IClientMapObjectsInteractionRangeSettingsProto);
            public interaction_range_meters: number;
            public far_interaction_range_meters: number;
            public remote_interaction_range_meters: number;
            public white_pulse_radius_meters: number;
            public static encode(message: POGOProtos.Rpc.IClientMapObjectsInteractionRangeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientMapObjectsInteractionRangeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientMapObjectsInteractionRangeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ClientMapObjectsInteractionRangeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientMetrics {
            window?: (POGOProtos.Rpc.ITimeWindow|null);
            log_source_metrics?: (POGOProtos.Rpc.ILogSourceMetrics[]|null);
            global_metrics?: (POGOProtos.Rpc.IGlobalMetrics|null);
            app_namespace?: (string|null);
        }

        class ClientMetrics implements IClientMetrics {
            constructor(properties?: POGOProtos.Rpc.IClientMetrics);
            public window?: (POGOProtos.Rpc.ITimeWindow|null);
            public log_source_metrics: POGOProtos.Rpc.ILogSourceMetrics[];
            public global_metrics?: (POGOProtos.Rpc.IGlobalMetrics|null);
            public app_namespace: string;
            public static encode(message: POGOProtos.Rpc.IClientMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientMetrics;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientMetrics;
            public static toObject(message: POGOProtos.Rpc.ClientMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPerformanceSettingsProto {
            max_number_local_battle_parties?: (number|null);
            multi_pokemon_battle_party_select?: (boolean|null);
            use_whole_match_for_filter_key?: (boolean|null);
        }

        class ClientPerformanceSettingsProto implements IClientPerformanceSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IClientPerformanceSettingsProto);
            public max_number_local_battle_parties: number;
            public multi_pokemon_battle_party_select: boolean;
            public use_whole_match_for_filter_key: boolean;
            public static encode(message: POGOProtos.Rpc.IClientPerformanceSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPerformanceSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPerformanceSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ClientPerformanceSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPlayerProto {
            creation_time_ms?: (number|Long|null);
            name?: (string|null);
            team?: (POGOProtos.Rpc.Team|null);
            tutorial_complete?: (POGOProtos.Rpc.TutorialCompletion[]|null);
            player_avatar_proto?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            max_pokemon_storage?: (number|null);
            max_item_storage?: (number|null);
            daily_bonus_proto?: (POGOProtos.Rpc.IDailyBonusProto|null);
            contact_settings_proto?: (POGOProtos.Rpc.IContactSettingsProto|null);
            currency_balance?: (POGOProtos.Rpc.ICurrencyQuantityProto[]|null);
            remaining_codename_claims?: (number|null);
            buddy_pokemon_proto?: (POGOProtos.Rpc.IBuddyPokemonProto|null);
            battle_lockout_end_ms?: (number|Long|null);
            secondary_player_avatar_proto?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            name_is_blacklisted?: (boolean|null);
            social_player_settings?: (POGOProtos.Rpc.ISocialPlayerSettingsProto|null);
            combat_player_preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
            player_support_id?: (string|null);
            team_change_info?: (POGOProtos.Rpc.ITeamChangeInfoProto|null);
            consumed_eevee_easter_eggs?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            combat_log?: (POGOProtos.Rpc.ICombatLogProto|null);
            time_zone_offset_ms?: (number|Long|null);
            buddy_observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            helpshift_user_id?: (string|null);
            player_preferences?: (POGOProtos.Rpc.IPlayerPreferencesProto|null);
            event_ticket_active_time?: (POGOProtos.Rpc.IEventTicketActiveTimeProto[]|null);
            lapsed_player_returned_time_ms?: (number|Long|null);
            max_postcard_storage?: (number|null);
            pokecoin_caps?: (POGOProtos.Rpc.IPlayerPokecoinCapProto[]|null);
            obfuscated_player_id?: (string|null);
            ptc_oauth_linked_before?: (boolean|null);
            quago_player_id?: (string|null);
            age_level?: (POGOProtos.Rpc.AgeLevelProto.AgeLevel|null);
            temp_evolved_pokemon_id?: (number|Long|null);
            active_training_pokemon?: (POGOProtos.Rpc.ITrainingPokemonProto[]|null);
        }

        class ClientPlayerProto implements IClientPlayerProto {
            constructor(properties?: POGOProtos.Rpc.IClientPlayerProto);
            public creation_time_ms: (number|Long);
            public name: string;
            public team: POGOProtos.Rpc.Team;
            public tutorial_complete: POGOProtos.Rpc.TutorialCompletion[];
            public player_avatar_proto?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public max_pokemon_storage: number;
            public max_item_storage: number;
            public daily_bonus_proto?: (POGOProtos.Rpc.IDailyBonusProto|null);
            public contact_settings_proto?: (POGOProtos.Rpc.IContactSettingsProto|null);
            public currency_balance: POGOProtos.Rpc.ICurrencyQuantityProto[];
            public remaining_codename_claims: number;
            public buddy_pokemon_proto?: (POGOProtos.Rpc.IBuddyPokemonProto|null);
            public battle_lockout_end_ms: (number|Long);
            public secondary_player_avatar_proto?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public name_is_blacklisted: boolean;
            public social_player_settings?: (POGOProtos.Rpc.ISocialPlayerSettingsProto|null);
            public combat_player_preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
            public player_support_id: string;
            public team_change_info?: (POGOProtos.Rpc.ITeamChangeInfoProto|null);
            public consumed_eevee_easter_eggs: POGOProtos.Rpc.HoloPokemonId[];
            public combat_log?: (POGOProtos.Rpc.ICombatLogProto|null);
            public time_zone_offset_ms: (number|Long);
            public buddy_observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public helpshift_user_id: string;
            public player_preferences?: (POGOProtos.Rpc.IPlayerPreferencesProto|null);
            public event_ticket_active_time: POGOProtos.Rpc.IEventTicketActiveTimeProto[];
            public lapsed_player_returned_time_ms: (number|Long);
            public max_postcard_storage: number;
            public pokecoin_caps: POGOProtos.Rpc.IPlayerPokecoinCapProto[];
            public obfuscated_player_id: string;
            public ptc_oauth_linked_before: boolean;
            public quago_player_id: string;
            public age_level: POGOProtos.Rpc.AgeLevelProto.AgeLevel;
            public temp_evolved_pokemon_id: (number|Long);
            public active_training_pokemon: POGOProtos.Rpc.ITrainingPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IClientPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPlayerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPlayerProto;
            public static toObject(message: POGOProtos.Rpc.ClientPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPlugins {
            plugins?: (POGOProtos.Rpc.IPluginInfo[]|null);
        }

        class ClientPlugins implements IClientPlugins {
            constructor(properties?: POGOProtos.Rpc.IClientPlugins);
            public plugins: POGOProtos.Rpc.IPluginInfo[];
            public static encode(message: POGOProtos.Rpc.IClientPlugins, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPlugins;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPlugins;
            public static toObject(message: POGOProtos.Rpc.ClientPlugins, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPoiDecorationGroupProto {
            decoration_id?: (string|null);
            addressable_id?: (string|null);
            decorated_pois?: (string[]|null);
        }

        class ClientPoiDecorationGroupProto implements IClientPoiDecorationGroupProto {
            constructor(properties?: POGOProtos.Rpc.IClientPoiDecorationGroupProto);
            public decoration_id: string;
            public addressable_id: string;
            public decorated_pois: string[];
            public static encode(message: POGOProtos.Rpc.IClientPoiDecorationGroupProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPoiDecorationGroupProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPoiDecorationGroupProto;
            public static toObject(message: POGOProtos.Rpc.ClientPoiDecorationGroupProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPokestopNpcDialogueStepProto {
            dialogue_line?: (POGOProtos.Rpc.IClientDialogueLineProto[]|null);
        }

        class ClientPokestopNpcDialogueStepProto implements IClientPokestopNpcDialogueStepProto {
            constructor(properties?: POGOProtos.Rpc.IClientPokestopNpcDialogueStepProto);
            public dialogue_line: POGOProtos.Rpc.IClientDialogueLineProto[];
            public static encode(message: POGOProtos.Rpc.IClientPokestopNpcDialogueStepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPokestopNpcDialogueStepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPokestopNpcDialogueStepProto;
            public static toObject(message: POGOProtos.Rpc.ClientPokestopNpcDialogueStepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPokestopSpinStepProto {
        }

        class ClientPokestopSpinStepProto implements IClientPokestopSpinStepProto {
            constructor(properties?: POGOProtos.Rpc.IClientPokestopSpinStepProto);
            public static encode(message: POGOProtos.Rpc.IClientPokestopSpinStepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPokestopSpinStepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPokestopSpinStepProto;
            public static toObject(message: POGOProtos.Rpc.ClientPokestopSpinStepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientPredictionInconsistencyData {
            hp_change?: (number|null);
        }

        class ClientPredictionInconsistencyData implements IClientPredictionInconsistencyData {
            constructor(properties?: POGOProtos.Rpc.IClientPredictionInconsistencyData);
            public hp_change: number;
            public static encode(message: POGOProtos.Rpc.IClientPredictionInconsistencyData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientPredictionInconsistencyData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientPredictionInconsistencyData;
            public static toObject(message: POGOProtos.Rpc.ClientPredictionInconsistencyData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientQuestProto {
            quest?: (POGOProtos.Rpc.IQuestProto|null);
            quest_display?: (POGOProtos.Rpc.IQuestDisplayProto|null);
        }

        class ClientQuestProto implements IClientQuestProto {
            constructor(properties?: POGOProtos.Rpc.IClientQuestProto);
            public quest?: (POGOProtos.Rpc.IQuestProto|null);
            public quest_display?: (POGOProtos.Rpc.IQuestDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IClientQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientQuestProto;
            public static toObject(message: POGOProtos.Rpc.ClientQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientRouteGetProto {
            route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            s2_cell_id?: ((number|Long)[]|null);
        }

        class ClientRouteGetProto implements IClientRouteGetProto {
            constructor(properties?: POGOProtos.Rpc.IClientRouteGetProto);
            public route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public s2_cell_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IClientRouteGetProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientRouteGetProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientRouteGetProto;
            public static toObject(message: POGOProtos.Rpc.ClientRouteGetProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientRouteMapCellProto {
            s2_cell_id?: (number|Long|null);
            route_list_hash?: (string|null);
            route?: (POGOProtos.Rpc.ISharedRouteProto[]|null);
        }

        class ClientRouteMapCellProto implements IClientRouteMapCellProto {
            constructor(properties?: POGOProtos.Rpc.IClientRouteMapCellProto);
            public s2_cell_id: (number|Long);
            public route_list_hash: string;
            public route: POGOProtos.Rpc.ISharedRouteProto[];
            public static encode(message: POGOProtos.Rpc.IClientRouteMapCellProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientRouteMapCellProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientRouteMapCellProto;
            public static toObject(message: POGOProtos.Rpc.ClientRouteMapCellProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientSettingsTelemetry {
            music_volume?: (number|null);
            sound_volume?: (number|null);
        }

        class ClientSettingsTelemetry implements IClientSettingsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IClientSettingsTelemetry);
            public music_volume: number;
            public sound_volume: number;
            public static encode(message: POGOProtos.Rpc.IClientSettingsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientSettingsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientSettingsTelemetry;
            public static toObject(message: POGOProtos.Rpc.ClientSettingsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientSleepRecord {
            start_time_sec?: (number|null);
            duration_sec?: (number|null);
        }

        class ClientSleepRecord implements IClientSleepRecord {
            constructor(properties?: POGOProtos.Rpc.IClientSleepRecord);
            public start_time_sec: number;
            public duration_sec: number;
            public static encode(message: POGOProtos.Rpc.IClientSleepRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientSleepRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientSleepRecord;
            public static toObject(message: POGOProtos.Rpc.ClientSleepRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientSpawnPointProto {
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class ClientSpawnPointProto implements IClientSpawnPointProto {
            constructor(properties?: POGOProtos.Rpc.IClientSpawnPointProto);
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IClientSpawnPointProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientSpawnPointProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientSpawnPointProto;
            public static toObject(message: POGOProtos.Rpc.ClientSpawnPointProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientTelemetryBatchProto {
            telemetry_scope_id?: (POGOProtos.Rpc.ClientTelemetryBatchProto.TelemetryScopeId|null);
            events?: (POGOProtos.Rpc.IClientTelemetryRecordProto[]|null);
            api_version?: (string|null);
            message_version?: (string|null);
        }

        class ClientTelemetryBatchProto implements IClientTelemetryBatchProto {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryBatchProto);
            public telemetry_scope_id: POGOProtos.Rpc.ClientTelemetryBatchProto.TelemetryScopeId;
            public events: POGOProtos.Rpc.IClientTelemetryRecordProto[];
            public api_version: string;
            public message_version: string;
            public static encode(message: POGOProtos.Rpc.IClientTelemetryBatchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryBatchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryBatchProto;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryBatchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClientTelemetryBatchProto {

            enum TelemetryScopeId {
                unset = 0,
                core = 1,
                game = 2,
                titan = 3,
                common = 4,
                pre_age_gate = 5,
                pre_login = 6,
                ardk = 7,
                marketing = 8
            }
        }

        interface IClientTelemetryClientSettingsProto {
            is_upload_enabled?: (boolean|null);
            max_upload_size_in_bytes?: (number|Long|null);
            update_interval_in_sec?: (number|Long|null);
            settings_update_interval_in_sec?: (number|Long|null);
            max_envelope_queue_size?: (number|Long|null);
            sampling_probability?: (number|null);
            use_player_based_sampling?: (boolean|null);
            player_hash?: (number|null);
            player_external_omni_id?: (string|null);
            disable_omni_sending?: (boolean|null);
            special_sampling_probability_map?: ({ [k: string]: number }|null);
            player_external_ua_id?: (string|null);
            player_external_in_app_survey_id?: (string|null);
            player_external_ardk_id?: (string|null);
            enable_experimental_features?: (boolean|null);
        }

        class ClientTelemetryClientSettingsProto implements IClientTelemetryClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryClientSettingsProto);
            public is_upload_enabled: boolean;
            public max_upload_size_in_bytes: (number|Long);
            public update_interval_in_sec: (number|Long);
            public settings_update_interval_in_sec: (number|Long);
            public max_envelope_queue_size: (number|Long);
            public sampling_probability: number;
            public use_player_based_sampling: boolean;
            public player_hash: number;
            public player_external_omni_id: string;
            public disable_omni_sending: boolean;
            public special_sampling_probability_map: { [k: string]: number };
            public player_external_ua_id: string;
            public player_external_in_app_survey_id: string;
            public player_external_ardk_id: string;
            public enable_experimental_features: boolean;
            public static encode(message: POGOProtos.Rpc.IClientTelemetryClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientTelemetryCommonFilterProto {
            application_identifier?: (string|null);
            operating_system_name?: (string|null);
            device_model?: (string|null);
            locale_country_code?: (string|null);
            locale_language_code?: (string|null);
            sampling_probability?: (number|null);
            quality_level?: (string|null);
            network_connectivity_type?: (string|null);
            game_context?: (string|null);
            language_code?: (string|null);
            timezone?: (string|null);
            ip_country_code?: (string|null);
            client_version?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
        }

        class ClientTelemetryCommonFilterProto implements IClientTelemetryCommonFilterProto {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryCommonFilterProto);
            public application_identifier: string;
            public operating_system_name: string;
            public device_model: string;
            public locale_country_code: string;
            public locale_language_code: string;
            public sampling_probability: number;
            public quality_level: string;
            public network_connectivity_type: string;
            public game_context: string;
            public language_code: string;
            public timezone: string;
            public ip_country_code: string;
            public client_version: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public static encode(message: POGOProtos.Rpc.IClientTelemetryCommonFilterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryCommonFilterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryCommonFilterProto;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryCommonFilterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientTelemetryRecordProto {
            record_id?: (string|null);
            encoded_message?: (POGOProtos.Rpc.IHoloholoClientTelemetryOmniProto|null);
            client_timestamp_ms?: (number|Long|null);
            metric_id?: (number|Long|null);
            event_name?: (string|null);
            common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
        }

        class ClientTelemetryRecordProto implements IClientTelemetryRecordProto {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryRecordProto);
            public record_id: string;
            public encoded_message?: (POGOProtos.Rpc.IHoloholoClientTelemetryOmniProto|null);
            public client_timestamp_ms: (number|Long);
            public metric_id: (number|Long);
            public event_name: string;
            public common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
            public static encode(message: POGOProtos.Rpc.IClientTelemetryRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryRecordProto;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientTelemetryRecordResult {
            record_id?: (string|null);
            status?: (POGOProtos.Rpc.ClientTelemetryRecordResult.Status|null);
            telemetry_type_name?: (string|null);
        }

        class ClientTelemetryRecordResult implements IClientTelemetryRecordResult {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryRecordResult);
            public record_id: string;
            public status: POGOProtos.Rpc.ClientTelemetryRecordResult.Status;
            public telemetry_type_name: string;
            public static encode(message: POGOProtos.Rpc.IClientTelemetryRecordResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryRecordResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryRecordResult;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryRecordResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClientTelemetryRecordResult {

            enum Status {
                unset = 0,
                success = 20,
                error_family_unset = 21,
                error_family_invalid = 22,
                error_encoding_invalid = 23,
                error_unset_metric_id = 24,
                error_event_telemetry_undefined = 25
            }
        }

        interface IClientTelemetryResponseProto {
            status?: (POGOProtos.Rpc.ClientTelemetryResponseProto.Status|null);
            rows_written?: (number|null);
            nonretryable_failures?: (number|null);
            retryable_failures?: (POGOProtos.Rpc.IClientTelemetryRecordResult[]|null);
        }

        class ClientTelemetryResponseProto implements IClientTelemetryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryResponseProto);
            public status: POGOProtos.Rpc.ClientTelemetryResponseProto.Status;
            public rows_written: number;
            public nonretryable_failures: number;
            public retryable_failures: POGOProtos.Rpc.IClientTelemetryRecordResult[];
            public static encode(message: POGOProtos.Rpc.IClientTelemetryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryResponseProto;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClientTelemetryResponseProto {

            enum Status {
                unset = 0,
                success = 1,
                failure = 2,
                partial_failure = 3,
                invalid_request = 4
            }
        }

        interface IClientTelemetrySettingsRequestProto {
        }

        class ClientTelemetrySettingsRequestProto implements IClientTelemetrySettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetrySettingsRequestProto);
            public static encode(message: POGOProtos.Rpc.IClientTelemetrySettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetrySettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetrySettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetrySettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientTelemetryV2Request {
            telemetry_request_metadata?: (POGOProtos.Rpc.ITelemetryRequestMetadata|null);
            batch_proto?: (POGOProtos.Rpc.IClientTelemetryBatchProto|null);
        }

        class ClientTelemetryV2Request implements IClientTelemetryV2Request {
            constructor(properties?: POGOProtos.Rpc.IClientTelemetryV2Request);
            public telemetry_request_metadata?: (POGOProtos.Rpc.ITelemetryRequestMetadata|null);
            public batch_proto?: (POGOProtos.Rpc.IClientTelemetryBatchProto|null);
            public static encode(message: POGOProtos.Rpc.IClientTelemetryV2Request, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientTelemetryV2Request;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientTelemetryV2Request;
            public static toObject(message: POGOProtos.Rpc.ClientTelemetryV2Request, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientToggleSettingsTelemetry {
            toggle_id?: (POGOProtos.Rpc.ClientToggleSettingsTelemetry.ToggleSettingId|null);
            toggle_event?: (POGOProtos.Rpc.ClientToggleSettingsTelemetry.ToggleEvent|null);
        }

        class ClientToggleSettingsTelemetry implements IClientToggleSettingsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IClientToggleSettingsTelemetry);
            public toggle_id: POGOProtos.Rpc.ClientToggleSettingsTelemetry.ToggleSettingId;
            public toggle_event: POGOProtos.Rpc.ClientToggleSettingsTelemetry.ToggleEvent;
            public static encode(message: POGOProtos.Rpc.IClientToggleSettingsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientToggleSettingsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientToggleSettingsTelemetry;
            public static toObject(message: POGOProtos.Rpc.ClientToggleSettingsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ClientToggleSettingsTelemetry {

            enum ToggleEvent {
                UNDEFINED = 0,
                OFF = 1,
                ON = 2
            }

            enum ToggleSettingId {
                UNSET = 0,
                REMEMBER_LAST_POKEBALL = 1,
                ADVANCED_HAPTICS = 2
            }
        }

        interface IClientUpgradeRequestProto {
            version?: (string|null);
            operating_system?: (POGOProtos.Rpc.ClientOperatingSystem|null);
        }

        class ClientUpgradeRequestProto implements IClientUpgradeRequestProto {
            constructor(properties?: POGOProtos.Rpc.IClientUpgradeRequestProto);
            public version: string;
            public operating_system: POGOProtos.Rpc.ClientOperatingSystem;
            public static encode(message: POGOProtos.Rpc.IClientUpgradeRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientUpgradeRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientUpgradeRequestProto;
            public static toObject(message: POGOProtos.Rpc.ClientUpgradeRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientUpgradeResponseProto {
            needs_upgrade?: (boolean|null);
        }

        class ClientUpgradeResponseProto implements IClientUpgradeResponseProto {
            constructor(properties?: POGOProtos.Rpc.IClientUpgradeResponseProto);
            public needs_upgrade: boolean;
            public static encode(message: POGOProtos.Rpc.IClientUpgradeResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientUpgradeResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientUpgradeResponseProto;
            public static toObject(message: POGOProtos.Rpc.ClientUpgradeResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientVersionProto {
            min_version?: (string|null);
        }

        class ClientVersionProto implements IClientVersionProto {
            constructor(properties?: POGOProtos.Rpc.IClientVersionProto);
            public min_version: string;
            public static encode(message: POGOProtos.Rpc.IClientVersionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientVersionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientVersionProto;
            public static toObject(message: POGOProtos.Rpc.ClientVersionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IClientWeatherProto {
            s2_cell_id?: (number|Long|null);
            display_weather?: (POGOProtos.Rpc.IDisplayWeatherProto|null);
            gameplay_weather?: (POGOProtos.Rpc.IGameplayWeatherProto|null);
            alerts?: (POGOProtos.Rpc.IWeatherAlertProto[]|null);
        }

        class ClientWeatherProto implements IClientWeatherProto {
            constructor(properties?: POGOProtos.Rpc.IClientWeatherProto);
            public s2_cell_id: (number|Long);
            public display_weather?: (POGOProtos.Rpc.IDisplayWeatherProto|null);
            public gameplay_weather?: (POGOProtos.Rpc.IGameplayWeatherProto|null);
            public alerts: POGOProtos.Rpc.IWeatherAlertProto[];
            public static encode(message: POGOProtos.Rpc.IClientWeatherProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ClientWeatherProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ClientWeatherProto;
            public static toObject(message: POGOProtos.Rpc.ClientWeatherProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICodeGateProto {
            is_enabled?: (boolean|null);
            blocked_rollout_percentage?: (number|null);
            sub_code_gate_list?: (POGOProtos.Rpc.CodeGateProto.ISubCodeGateProto[]|null);
            code_gate_owner?: (string|null);
            latest_update_timestamp_ms?: (number|Long|null);
        }

        class CodeGateProto implements ICodeGateProto {
            constructor(properties?: POGOProtos.Rpc.ICodeGateProto);
            public is_enabled: boolean;
            public blocked_rollout_percentage: number;
            public sub_code_gate_list: POGOProtos.Rpc.CodeGateProto.ISubCodeGateProto[];
            public code_gate_owner: string;
            public latest_update_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICodeGateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CodeGateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CodeGateProto;
            public static toObject(message: POGOProtos.Rpc.CodeGateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CodeGateProto {

            interface ISubCodeGateProto {
                name?: (string|null);
                is_enabled?: (boolean|null);
            }

            class SubCodeGateProto implements ISubCodeGateProto {
                constructor(properties?: POGOProtos.Rpc.CodeGateProto.ISubCodeGateProto);
                public name: string;
                public is_enabled: boolean;
                public static encode(message: POGOProtos.Rpc.CodeGateProto.ISubCodeGateProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CodeGateProto.SubCodeGateProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CodeGateProto.SubCodeGateProto;
                public static toObject(message: POGOProtos.Rpc.CodeGateProto.SubCodeGateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICodenameResultProto {
            codename?: (string|null);
            user_message?: (string|null);
            is_assignable?: (boolean|null);
            status?: (POGOProtos.Rpc.CodenameResultProto.Status|null);
            updated_player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            suggested_codenames?: (string[]|null);
        }

        class CodenameResultProto implements ICodenameResultProto {
            constructor(properties?: POGOProtos.Rpc.ICodenameResultProto);
            public codename: string;
            public user_message: string;
            public is_assignable: boolean;
            public status: POGOProtos.Rpc.CodenameResultProto.Status;
            public updated_player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public suggested_codenames: string[];
            public static encode(message: POGOProtos.Rpc.ICodenameResultProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CodenameResultProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CodenameResultProto;
            public static toObject(message: POGOProtos.Rpc.CodenameResultProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CodenameResultProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                CODENAME_NOT_AVAILABLE = 2,
                CODENAME_NOT_VALID = 3,
                CURRENT_OWNER = 4,
                CODENAME_CHANGE_NOT_ALLOWED = 5
            }
        }

        interface ICollectDailyBonusOutProto {
            result?: (POGOProtos.Rpc.CollectDailyBonusOutProto.Result|null);
        }

        class CollectDailyBonusOutProto implements ICollectDailyBonusOutProto {
            constructor(properties?: POGOProtos.Rpc.ICollectDailyBonusOutProto);
            public result: POGOProtos.Rpc.CollectDailyBonusOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICollectDailyBonusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CollectDailyBonusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CollectDailyBonusOutProto;
            public static toObject(message: POGOProtos.Rpc.CollectDailyBonusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CollectDailyBonusOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                TOO_SOON = 3
            }
        }

        interface ICollectDailyBonusProto {
        }

        class CollectDailyBonusProto implements ICollectDailyBonusProto {
            constructor(properties?: POGOProtos.Rpc.ICollectDailyBonusProto);
            public static encode(message: POGOProtos.Rpc.ICollectDailyBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CollectDailyBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CollectDailyBonusProto;
            public static toObject(message: POGOProtos.Rpc.CollectDailyBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICollectDailyDefenderBonusOutProto {
            result?: (POGOProtos.Rpc.CollectDailyDefenderBonusOutProto.Result|null);
            currency_type?: (string[]|null);
            currency_awarded?: (number[]|null);
            num_defenders?: (number|null);
        }

        class CollectDailyDefenderBonusOutProto implements ICollectDailyDefenderBonusOutProto {
            constructor(properties?: POGOProtos.Rpc.ICollectDailyDefenderBonusOutProto);
            public result: POGOProtos.Rpc.CollectDailyDefenderBonusOutProto.Result;
            public currency_type: string[];
            public currency_awarded: number[];
            public num_defenders: number;
            public static encode(message: POGOProtos.Rpc.ICollectDailyDefenderBonusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CollectDailyDefenderBonusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CollectDailyDefenderBonusOutProto;
            public static toObject(message: POGOProtos.Rpc.CollectDailyDefenderBonusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CollectDailyDefenderBonusOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                TOO_SOON = 3,
                NO_DEFENDERS = 4
            }
        }

        interface ICollectDailyDefenderBonusProto {
        }

        class CollectDailyDefenderBonusProto implements ICollectDailyDefenderBonusProto {
            constructor(properties?: POGOProtos.Rpc.ICollectDailyDefenderBonusProto);
            public static encode(message: POGOProtos.Rpc.ICollectDailyDefenderBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CollectDailyDefenderBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CollectDailyDefenderBonusProto;
            public static toObject(message: POGOProtos.Rpc.CollectDailyDefenderBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatActionLogProto {
            type?: (POGOProtos.Rpc.CombatActionProto.ActionType|null);
            action_start_turn?: (number|null);
            duration_turns?: (number|null);
            attacker_index?: (number|null);
            target_index?: (number|null);
            active_pokemon_index?: (number|null);
            target_pokemon_index?: (number|null);
            minigame_score?: (number|null);
            move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class CombatActionLogProto implements ICombatActionLogProto {
            constructor(properties?: POGOProtos.Rpc.ICombatActionLogProto);
            public type: POGOProtos.Rpc.CombatActionProto.ActionType;
            public action_start_turn: number;
            public duration_turns: number;
            public attacker_index: number;
            public target_index: number;
            public active_pokemon_index: number;
            public target_pokemon_index: number;
            public minigame_score: number;
            public move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.ICombatActionLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatActionLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatActionLogProto;
            public static toObject(message: POGOProtos.Rpc.CombatActionLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatActionProto {
            type?: (POGOProtos.Rpc.CombatActionProto.ActionType|null);
            action_start_turn?: (number|null);
            duration_turns?: (number|null);
            attacker_index?: (number|null);
            target_index?: (number|null);
            active_pokemon_id?: (number|Long|null);
            target_pokemon_id?: (number|Long|null);
            minigame_score?: (number|null);
            move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class CombatActionProto implements ICombatActionProto {
            constructor(properties?: POGOProtos.Rpc.ICombatActionProto);
            public type: POGOProtos.Rpc.CombatActionProto.ActionType;
            public action_start_turn: number;
            public duration_turns: number;
            public attacker_index: number;
            public target_index: number;
            public active_pokemon_id: (number|Long);
            public target_pokemon_id: (number|Long);
            public minigame_score: number;
            public move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.ICombatActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatActionProto;
            public static toObject(message: POGOProtos.Rpc.CombatActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatActionProto {

            enum ActionType {
                UNSET = 0,
                ATTACK = 1,
                SPECIAL_ATTACK = 2,
                SPECIAL_ATTACK_2 = 3,
                MINIGAME_OFFENSIVE_FINISH = 4,
                MINIGAME_DEFENSIVE_START = 5,
                MINIGAME_DEFENSIVE_FINISH = 6,
                FAINT = 7,
                CHANGE_POKEMON = 8,
                QUICK_SWAP_POKEMON = 9
            }
        }

        interface ICombatBaseStatsProto {
            total_battles?: (number|null);
            wins?: (number|null);
            rating?: (number|null);
        }

        class CombatBaseStatsProto implements ICombatBaseStatsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatBaseStatsProto);
            public total_battles: number;
            public wins: number;
            public rating: number;
            public static encode(message: POGOProtos.Rpc.ICombatBaseStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatBaseStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatBaseStatsProto;
            public static toObject(message: POGOProtos.Rpc.CombatBaseStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatChallengeGlobalSettingsProto {
            distance_check_override_friendship_level?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            get_combat_challenge_polling_interval_sec?: (number|null);
            enable_downstream_dispatch?: (boolean|null);
            enable_challenge_notifications?: (boolean|null);
        }

        class CombatChallengeGlobalSettingsProto implements ICombatChallengeGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatChallengeGlobalSettingsProto);
            public distance_check_override_friendship_level: POGOProtos.Rpc.FriendshipLevelMilestone;
            public get_combat_challenge_polling_interval_sec: number;
            public enable_downstream_dispatch: boolean;
            public enable_challenge_notifications: boolean;
            public static encode(message: POGOProtos.Rpc.ICombatChallengeGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatChallengeGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatChallengeGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatChallengeGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatChallengeLogProto {
            type?: (POGOProtos.Rpc.CombatType|null);
            challenger_pokemon_indexes?: (number[]|null);
            opponent_pokemon_indexes?: (number[]|null);
            state?: (POGOProtos.Rpc.CombatChallengeProto.CombatChallengeState|null);
            created_timestamp_offset_ms?: (number|null);
            expiration_timestamp_offset_ms?: (number|null);
        }

        class CombatChallengeLogProto implements ICombatChallengeLogProto {
            constructor(properties?: POGOProtos.Rpc.ICombatChallengeLogProto);
            public type: POGOProtos.Rpc.CombatType;
            public challenger_pokemon_indexes: number[];
            public opponent_pokemon_indexes: number[];
            public state: POGOProtos.Rpc.CombatChallengeProto.CombatChallengeState;
            public created_timestamp_offset_ms: number;
            public expiration_timestamp_offset_ms: number;
            public static encode(message: POGOProtos.Rpc.ICombatChallengeLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatChallengeLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatChallengeLogProto;
            public static toObject(message: POGOProtos.Rpc.CombatChallengeLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatChallengeProto {
            challenge_id?: (string|null);
            type?: (POGOProtos.Rpc.CombatType|null);
            combat_league_template_id?: (string|null);
            challenger?: (POGOProtos.Rpc.CombatChallengeProto.IChallengePlayer|null);
            opponent?: (POGOProtos.Rpc.CombatChallengeProto.IChallengePlayer|null);
            state?: (POGOProtos.Rpc.CombatChallengeProto.CombatChallengeState|null);
            created_timestamp_ms?: (number|Long|null);
            combat_id?: (string|null);
            gbl_battle_realm?: (string|null);
            expiration_timestamp_ms?: (number|Long|null);
        }

        class CombatChallengeProto implements ICombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.ICombatChallengeProto);
            public challenge_id: string;
            public type: POGOProtos.Rpc.CombatType;
            public combat_league_template_id: string;
            public challenger?: (POGOProtos.Rpc.CombatChallengeProto.IChallengePlayer|null);
            public opponent?: (POGOProtos.Rpc.CombatChallengeProto.IChallengePlayer|null);
            public state: POGOProtos.Rpc.CombatChallengeProto.CombatChallengeState;
            public created_timestamp_ms: (number|Long);
            public combat_id: string;
            public gbl_battle_realm: string;
            public expiration_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.CombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatChallengeProto {

            enum CombatChallengeState {
                UNSET = 0,
                CREATED = 1,
                OPENED = 2,
                CANCELLED = 3,
                ACCEPTED = 4,
                DECLINED = 5,
                READY = 6,
                TIMEOUT = 7
            }

            interface IChallengePlayer {
                player_id?: (string|null);
                player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
                combat_player_s2_cell_id?: (number|Long|null);
                attacking_pokemon_id?: ((number|Long)[]|null);
                public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                nia_account_id?: (string|null);
            }

            class ChallengePlayer implements IChallengePlayer {
                constructor(properties?: POGOProtos.Rpc.CombatChallengeProto.IChallengePlayer);
                public player_id: string;
                public player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
                public combat_player_s2_cell_id: (number|Long);
                public attacking_pokemon_id: (number|Long)[];
                public public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                public nia_account_id: string;
                public static encode(message: POGOProtos.Rpc.CombatChallengeProto.IChallengePlayer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatChallengeProto.ChallengePlayer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatChallengeProto.ChallengePlayer;
                public static toObject(message: POGOProtos.Rpc.CombatChallengeProto.ChallengePlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatClientLog {
            header?: (POGOProtos.Rpc.ICombatLogHeader|null);
            entries?: (POGOProtos.Rpc.ICombatLogData[]|null);
        }

        class CombatClientLog implements ICombatClientLog {
            constructor(properties?: POGOProtos.Rpc.ICombatClientLog);
            public header?: (POGOProtos.Rpc.ICombatLogHeader|null);
            public entries: POGOProtos.Rpc.ICombatLogData[];
            public static encode(message: POGOProtos.Rpc.ICombatClientLog, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatClientLog;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatClientLog;
            public static toObject(message: POGOProtos.Rpc.CombatClientLog, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatClockSynchronization {
            sync_attempt_count?: (number|null);
            enabled?: (boolean|null);
        }

        class CombatClockSynchronization implements ICombatClockSynchronization {
            constructor(properties?: POGOProtos.Rpc.ICombatClockSynchronization);
            public sync_attempt_count: number;
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ICombatClockSynchronization, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatClockSynchronization;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatClockSynchronization;
            public static toObject(message: POGOProtos.Rpc.CombatClockSynchronization, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatCompetitiveSeasonSettingsProto {
            season_end_time_timestamp?: ((number|Long)[]|null);
            rating_adjustment_percentage?: (number|null);
            ranking_adjustment_percentage?: (number|null);
            player_facing_season_number?: (number|null);
        }

        class CombatCompetitiveSeasonSettingsProto implements ICombatCompetitiveSeasonSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatCompetitiveSeasonSettingsProto);
            public season_end_time_timestamp: (number|Long)[];
            public rating_adjustment_percentage: number;
            public ranking_adjustment_percentage: number;
            public player_facing_season_number: number;
            public static encode(message: POGOProtos.Rpc.ICombatCompetitiveSeasonSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatCompetitiveSeasonSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatCompetitiveSeasonSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatCompetitiveSeasonSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatDefensiveInputChallengeSettings {
            full_rotations_for_max_score?: (number|null);
        }

        class CombatDefensiveInputChallengeSettings implements ICombatDefensiveInputChallengeSettings {
            constructor(properties?: POGOProtos.Rpc.ICombatDefensiveInputChallengeSettings);
            public full_rotations_for_max_score: number;
            public static encode(message: POGOProtos.Rpc.ICombatDefensiveInputChallengeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatDefensiveInputChallengeSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatDefensiveInputChallengeSettings;
            public static toObject(message: POGOProtos.Rpc.CombatDefensiveInputChallengeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatEndData {
            type?: (POGOProtos.Rpc.CombatEndData.Type|null);
        }

        class CombatEndData implements ICombatEndData {
            constructor(properties?: POGOProtos.Rpc.ICombatEndData);
            public type: POGOProtos.Rpc.CombatEndData.Type;
            public static encode(message: POGOProtos.Rpc.ICombatEndData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatEndData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatEndData;
            public static toObject(message: POGOProtos.Rpc.CombatEndData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatEndData {

            enum Type {
                NO_END = 0,
                COMBAT_STATE_EXIT = 1
            }
        }

        interface ICombatFeatureFlags {
            real_device_time_enabled?: (boolean|null);
            next_available_turn_enabled?: (boolean|null);
            server_fly_in_fly_out_enabled?: (boolean|null);
            client_shield_insta_report_enabled?: (boolean|null);
        }

        class CombatFeatureFlags implements ICombatFeatureFlags {
            constructor(properties?: POGOProtos.Rpc.ICombatFeatureFlags);
            public real_device_time_enabled: boolean;
            public next_available_turn_enabled: boolean;
            public server_fly_in_fly_out_enabled: boolean;
            public client_shield_insta_report_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ICombatFeatureFlags, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatFeatureFlags;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatFeatureFlags;
            public static toObject(message: POGOProtos.Rpc.CombatFeatureFlags, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatForLogProto {
            combat_state?: (POGOProtos.Rpc.CombatProto.CombatState|null);
            player?: (POGOProtos.Rpc.CombatForLogProto.ICombatPlayerLogProto|null);
            opponent?: (POGOProtos.Rpc.CombatForLogProto.ICombatPlayerLogProto|null);
            server_offset_ms?: (number|null);
            current_turn?: (number|null);
            turn_start_offset_ms?: (number|null);
            minigame_end_offset_ms?: (number|null);
            minigame_submit_score_end_offset_ms?: (number|null);
            change_pokemon_end_offset_ms?: (number|null);
            quick_swap_cooldown_duration_offset_ms?: (number|null);
            state_change_delay_until_turn?: (number|null);
            combat_request_counter?: (number|null);
            opponent_triggered?: (boolean|null);
            opponent_request_counter?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class CombatForLogProto implements ICombatForLogProto {
            constructor(properties?: POGOProtos.Rpc.ICombatForLogProto);
            public combat_state: POGOProtos.Rpc.CombatProto.CombatState;
            public player?: (POGOProtos.Rpc.CombatForLogProto.ICombatPlayerLogProto|null);
            public opponent?: (POGOProtos.Rpc.CombatForLogProto.ICombatPlayerLogProto|null);
            public server_offset_ms: number;
            public current_turn: number;
            public turn_start_offset_ms: number;
            public minigame_end_offset_ms: number;
            public minigame_submit_score_end_offset_ms: number;
            public change_pokemon_end_offset_ms: number;
            public quick_swap_cooldown_duration_offset_ms: number;
            public state_change_delay_until_turn: number;
            public combat_request_counter: number;
            public opponent_triggered: boolean;
            public opponent_request_counter: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.ICombatForLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatForLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatForLogProto;
            public static toObject(message: POGOProtos.Rpc.CombatForLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatForLogProto {

            interface ICombatPlayerLogProto {
                active_pokemon?: (POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto|null);
                reserve_pokemon?: (POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto[]|null);
                fainted_pokemon?: (POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto[]|null);
                current_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
                lockstep_ack?: (boolean|null);
                last_updated_turn?: (number|null);
                minigame_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
                quick_swap_available_offset_ms?: (number|null);
                minigame_defense_chances_left?: (number|null);
            }

            class CombatPlayerLogProto implements ICombatPlayerLogProto {
                constructor(properties?: POGOProtos.Rpc.CombatForLogProto.ICombatPlayerLogProto);
                public active_pokemon?: (POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto|null);
                public reserve_pokemon: POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto[];
                public fainted_pokemon: POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto[];
                public current_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
                public lockstep_ack: boolean;
                public last_updated_turn: number;
                public minigame_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
                public quick_swap_available_offset_ms: number;
                public minigame_defense_chances_left: number;
                public static encode(message: POGOProtos.Rpc.CombatForLogProto.ICombatPlayerLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatForLogProto.CombatPlayerLogProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatForLogProto.CombatPlayerLogProto;
                public static toObject(message: POGOProtos.Rpc.CombatForLogProto.CombatPlayerLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPokemonDynamicProto {
                index?: (number|null);
                stamina?: (number|null);
                energy?: (number|null);
                attack_stat_stage?: (number|null);
                defense_stat_stage?: (number|null);
            }

            class CombatPokemonDynamicProto implements ICombatPokemonDynamicProto {
                constructor(properties?: POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto);
                public index: number;
                public stamina: number;
                public energy: number;
                public attack_stat_stage: number;
                public defense_stat_stage: number;
                public static encode(message: POGOProtos.Rpc.CombatForLogProto.ICombatPokemonDynamicProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatForLogProto.CombatPokemonDynamicProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatForLogProto.CombatPokemonDynamicProto;
                public static toObject(message: POGOProtos.Rpc.CombatForLogProto.CombatPokemonDynamicProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatFriendRequestOutProto {
            result?: (POGOProtos.Rpc.CombatFriendRequestOutProto.Result|null);
        }

        class CombatFriendRequestOutProto implements ICombatFriendRequestOutProto {
            constructor(properties?: POGOProtos.Rpc.ICombatFriendRequestOutProto);
            public result: POGOProtos.Rpc.CombatFriendRequestOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICombatFriendRequestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatFriendRequestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatFriendRequestOutProto;
            public static toObject(message: POGOProtos.Rpc.CombatFriendRequestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatFriendRequestOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_COMBAT_NOT_FOUND = 2,
                ERROR_COMBAT_INCOMPLETE = 3,
                ERROR_PLAYER_NOT_IN_COMBAT = 4,
                ERROR_SOCIAL_RPC = 5
            }
        }

        interface ICombatFriendRequestProto {
            combat_id?: (string|null);
        }

        class CombatFriendRequestProto implements ICombatFriendRequestProto {
            constructor(properties?: POGOProtos.Rpc.ICombatFriendRequestProto);
            public combat_id: string;
            public static encode(message: POGOProtos.Rpc.ICombatFriendRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatFriendRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatFriendRequestProto;
            public static toObject(message: POGOProtos.Rpc.CombatFriendRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatGlobalSettingsProto {
            enable_combat?: (boolean|null);
            maximum_daily_rewarded_battles?: (number|null);
            enable_combat_stat_stages?: (boolean|null);
            minimum_player_level?: (number|null);
            maximum_daily_npc_rewarded_battles?: (number|null);
            active_combat_update_interval_ms?: (number|null);
            waiting_for_player_update_interval_ms?: (number|null);
            ready_for_battle_update_interval_ms?: (number|null);
            pre_move_submit_window_ms?: (number|null);
            post_move_submit_window_ms?: (number|null);
            enable_sockets?: (boolean|null);
            vs_seeker_walking_dist_poll_duration_ms?: (number|null);
            vs_seeker_player_min_level?: (number|null);
            matchmaking_poll_duration_ms?: (number|null);
            enable_vs_seeker_upgrade_iap?: (boolean|null);
            enable_flyout_animations?: (boolean|null);
            matchmaking_timeout_duration_ms?: (number|null);
            planned_downtime_timestamp_ms?: (number|Long|null);
            latency_compensation_threshold_ms?: (number|null);
            combat_refactor_allowlist_set1?: (POGOProtos.Rpc.CombatGlobalSettingsProto.CombatRefactorFlags[]|null);
            combat_refactor_allowlist_gbl_leagues?: (string[]|null);
        }

        class CombatGlobalSettingsProto implements ICombatGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatGlobalSettingsProto);
            public enable_combat: boolean;
            public maximum_daily_rewarded_battles: number;
            public enable_combat_stat_stages: boolean;
            public minimum_player_level: number;
            public maximum_daily_npc_rewarded_battles: number;
            public active_combat_update_interval_ms: number;
            public waiting_for_player_update_interval_ms: number;
            public ready_for_battle_update_interval_ms: number;
            public pre_move_submit_window_ms: number;
            public post_move_submit_window_ms: number;
            public enable_sockets: boolean;
            public vs_seeker_walking_dist_poll_duration_ms: number;
            public vs_seeker_player_min_level: number;
            public matchmaking_poll_duration_ms: number;
            public enable_vs_seeker_upgrade_iap: boolean;
            public enable_flyout_animations: boolean;
            public matchmaking_timeout_duration_ms: number;
            public planned_downtime_timestamp_ms: (number|Long);
            public latency_compensation_threshold_ms: number;
            public combat_refactor_allowlist_set1: POGOProtos.Rpc.CombatGlobalSettingsProto.CombatRefactorFlags[];
            public combat_refactor_allowlist_gbl_leagues: string[];
            public static encode(message: POGOProtos.Rpc.ICombatGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatGlobalSettingsProto {

            enum CombatRefactorFlags {
                NONE = 0,
                TRAINER_NPC_COMBAT = 1,
                INVASION_GRUNT_COMBAT = 2,
                INVASION_BOSS_COMBAT = 3,
                FRIEND_COMBAT = 4
            }
        }

        interface ICombatHubEntranceTelemetry {
            combat_hub_telemetry_id?: (POGOProtos.Rpc.CombatHubEntranceTelemetryIds|null);
        }

        class CombatHubEntranceTelemetry implements ICombatHubEntranceTelemetry {
            constructor(properties?: POGOProtos.Rpc.ICombatHubEntranceTelemetry);
            public combat_hub_telemetry_id: POGOProtos.Rpc.CombatHubEntranceTelemetryIds;
            public static encode(message: POGOProtos.Rpc.ICombatHubEntranceTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatHubEntranceTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatHubEntranceTelemetry;
            public static toObject(message: POGOProtos.Rpc.CombatHubEntranceTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatIdMismatchData {
            non_matching_combat_id?: (string|null);
            log_type?: (POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType|null);
        }

        class CombatIdMismatchData implements ICombatIdMismatchData {
            constructor(properties?: POGOProtos.Rpc.ICombatIdMismatchData);
            public non_matching_combat_id: string;
            public log_type: POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType;
            public static encode(message: POGOProtos.Rpc.ICombatIdMismatchData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatIdMismatchData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatIdMismatchData;
            public static toObject(message: POGOProtos.Rpc.CombatIdMismatchData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatLeagueProto {
            title?: (string|null);
            enabled?: (boolean|null);
            unlock_condition?: (POGOProtos.Rpc.CombatLeagueProto.IUnlockConditionProto[]|null);
            pokemon_condition?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonConditionProto[]|null);
            icon_url?: (string|null);
            pokemon_count?: (number|null);
            banned_pokemon?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            minigame_defense_chance_limit?: (number|null);
            battle_party_combat_league_template_id?: (string|null);
            league_type?: (POGOProtos.Rpc.CombatLeagueProto.LeagueType|null);
            border_color_hex?: (string|null);
            allow_temp_evos?: (boolean|null);
            combat_experiment?: (POGOProtos.Rpc.CombatExperiment[]|null);
        }

        class CombatLeagueProto implements ICombatLeagueProto {
            constructor(properties?: POGOProtos.Rpc.ICombatLeagueProto);
            public title: string;
            public enabled: boolean;
            public unlock_condition: POGOProtos.Rpc.CombatLeagueProto.IUnlockConditionProto[];
            public pokemon_condition: POGOProtos.Rpc.CombatLeagueProto.IPokemonConditionProto[];
            public icon_url: string;
            public pokemon_count: number;
            public banned_pokemon: POGOProtos.Rpc.HoloPokemonId[];
            public badge_type: POGOProtos.Rpc.HoloBadgeType;
            public minigame_defense_chance_limit: number;
            public battle_party_combat_league_template_id: string;
            public league_type: POGOProtos.Rpc.CombatLeagueProto.LeagueType;
            public border_color_hex: string;
            public allow_temp_evos: boolean;
            public combat_experiment: POGOProtos.Rpc.CombatExperiment[];
            public static encode(message: POGOProtos.Rpc.ICombatLeagueProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto;
            public static toObject(message: POGOProtos.Rpc.CombatLeagueProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatLeagueProto {

            enum ConditionType {
                UNSET = 0,
                WITH_POKEMON_CP_LIMIT = 1,
                WITH_PLAYER_LEVEL = 2,
                WITH_POKEMON_TYPE = 3,
                WITH_POKEMON_CATEGORY = 4,
                WITH_UNIQUE_POKEMON = 5,
                POKEMON_WHITELIST = 6,
                POKEMON_BANLIST = 7,
                POKEMON_CAUGHT_TIMESTAMP = 8,
                POKEMON_LEVEL_RANGE = 9
            }

            enum LeagueType {
                NONE = 0,
                STANDARD = 1,
                PREMIER = 2
            }

            interface IPokemonBanlist {
                name?: (string|null);
                pokemon?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonWithForm[]|null);
                group_condition?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonGroupConditionProto|null);
            }

            class PokemonBanlist implements IPokemonBanlist {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonBanlist);
                public name: string;
                public pokemon: POGOProtos.Rpc.CombatLeagueProto.IPokemonWithForm[];
                public group_condition?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonGroupConditionProto|null);
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonBanlist, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonBanlist;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonBanlist;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonBanlist, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonCaughtTimestamp {
                after_timestamp?: (number|Long|null);
                before_timestamp?: (number|Long|null);
            }

            class PokemonCaughtTimestamp implements IPokemonCaughtTimestamp {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonCaughtTimestamp);
                public after_timestamp: (number|Long);
                public before_timestamp: (number|Long);
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonCaughtTimestamp, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonCaughtTimestamp;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonCaughtTimestamp;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonCaughtTimestamp, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonConditionProto {
                with_pokemon_cp_limit?: (POGOProtos.Rpc.IWithPokemonCpLimitProto|null);
                with_pokemon_type?: (POGOProtos.Rpc.IWithPokemonTypeProto|null);
                with_pokemon_category?: (POGOProtos.Rpc.IWithPokemonCategoryProto|null);
                pokemon_whitelist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonWhitelist|null);
                pokemon_banlist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonBanlist|null);
                pokemon_caught_timestamp?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonCaughtTimestamp|null);
                pokemon_level_range?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonLevelRange|null);
                type?: (POGOProtos.Rpc.CombatLeagueProto.ConditionType|null);
            }

            class PokemonConditionProto implements IPokemonConditionProto {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonConditionProto);
                public with_pokemon_cp_limit?: (POGOProtos.Rpc.IWithPokemonCpLimitProto|null);
                public with_pokemon_type?: (POGOProtos.Rpc.IWithPokemonTypeProto|null);
                public with_pokemon_category?: (POGOProtos.Rpc.IWithPokemonCategoryProto|null);
                public pokemon_whitelist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonWhitelist|null);
                public pokemon_banlist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonBanlist|null);
                public pokemon_caught_timestamp?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonCaughtTimestamp|null);
                public pokemon_level_range?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonLevelRange|null);
                public type: POGOProtos.Rpc.CombatLeagueProto.ConditionType;
                public Condition?: ("with_pokemon_cp_limit"|"with_pokemon_type"|"with_pokemon_category"|"pokemon_whitelist"|"pokemon_banlist"|"pokemon_caught_timestamp"|"pokemon_level_range");
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonConditionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonConditionProto;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonGroupConditionProto {
                pokedex_range?: (POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.IPokedexNumberRange[]|null);
                can_evolve?: (boolean|null);
                has_mega?: (boolean|null);
                is_evolved?: (boolean|null);
                pokemon_class?: (POGOProtos.Rpc.HoloPokemonClass[]|null);
                alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment[]|null);
                pokemon_size?: (POGOProtos.Rpc.HoloPokemonSize[]|null);
            }

            class PokemonGroupConditionProto implements IPokemonGroupConditionProto {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonGroupConditionProto);
                public pokedex_range: POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.IPokedexNumberRange[];
                public can_evolve: boolean;
                public has_mega: boolean;
                public is_evolved: boolean;
                public pokemon_class: POGOProtos.Rpc.HoloPokemonClass[];
                public alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment[];
                public pokemon_size: POGOProtos.Rpc.HoloPokemonSize[];
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonGroupConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PokemonGroupConditionProto {

                interface IPokedexNumberRange {
                    start?: (number|null);
                    end?: (number|null);
                }

                class PokedexNumberRange implements IPokedexNumberRange {
                    constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.IPokedexNumberRange);
                    public start: number;
                    public end: number;
                    public static encode(message: POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.IPokedexNumberRange, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.PokedexNumberRange;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.PokedexNumberRange;
                    public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonGroupConditionProto.PokedexNumberRange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IPokemonLevelRange {
                min_level?: (number|null);
                max_level?: (number|null);
            }

            class PokemonLevelRange implements IPokemonLevelRange {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonLevelRange);
                public min_level: number;
                public max_level: number;
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonLevelRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonLevelRange;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonLevelRange;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonLevelRange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonWhitelist {
                name?: (string|null);
                pokemon?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonWithForm[]|null);
                group_condition?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonGroupConditionProto|null);
            }

            class PokemonWhitelist implements IPokemonWhitelist {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonWhitelist);
                public name: string;
                public pokemon: POGOProtos.Rpc.CombatLeagueProto.IPokemonWithForm[];
                public group_condition?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonGroupConditionProto|null);
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonWhitelist, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonWhitelist;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonWhitelist;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonWhitelist, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonWithForm {
                id?: (POGOProtos.Rpc.HoloPokemonId|null);
                form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
                forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            }

            class PokemonWithForm implements IPokemonWithForm {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IPokemonWithForm);
                public id: POGOProtos.Rpc.HoloPokemonId;
                public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
                public forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IPokemonWithForm, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.PokemonWithForm;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.PokemonWithForm;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.PokemonWithForm, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IUnlockConditionProto {
                with_player_level?: (POGOProtos.Rpc.IWithPlayerLevelProto|null);
                with_pokemon_cp_limit?: (POGOProtos.Rpc.IWithPokemonCpLimitProto|null);
                with_pokemon_type?: (POGOProtos.Rpc.IWithPokemonTypeProto|null);
                with_pokemon_category?: (POGOProtos.Rpc.IWithPokemonCategoryProto|null);
                pokemon_whitelist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonWhitelist|null);
                pokemon_banlist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonBanlist|null);
                pokemon_caught_timestamp?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonCaughtTimestamp|null);
                pokemon_level_range?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonLevelRange|null);
                type?: (POGOProtos.Rpc.CombatLeagueProto.ConditionType|null);
                min_pokemon_count?: (number|null);
            }

            class UnlockConditionProto implements IUnlockConditionProto {
                constructor(properties?: POGOProtos.Rpc.CombatLeagueProto.IUnlockConditionProto);
                public with_player_level?: (POGOProtos.Rpc.IWithPlayerLevelProto|null);
                public with_pokemon_cp_limit?: (POGOProtos.Rpc.IWithPokemonCpLimitProto|null);
                public with_pokemon_type?: (POGOProtos.Rpc.IWithPokemonTypeProto|null);
                public with_pokemon_category?: (POGOProtos.Rpc.IWithPokemonCategoryProto|null);
                public pokemon_whitelist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonWhitelist|null);
                public pokemon_banlist?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonBanlist|null);
                public pokemon_caught_timestamp?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonCaughtTimestamp|null);
                public pokemon_level_range?: (POGOProtos.Rpc.CombatLeagueProto.IPokemonLevelRange|null);
                public type: POGOProtos.Rpc.CombatLeagueProto.ConditionType;
                public min_pokemon_count: number;
                public Condition?: ("with_player_level"|"with_pokemon_cp_limit"|"with_pokemon_type"|"with_pokemon_category"|"pokemon_whitelist"|"pokemon_banlist"|"pokemon_caught_timestamp"|"pokemon_level_range");
                public static encode(message: POGOProtos.Rpc.CombatLeagueProto.IUnlockConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueProto.UnlockConditionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueProto.UnlockConditionProto;
                public static toObject(message: POGOProtos.Rpc.CombatLeagueProto.UnlockConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatLeagueResultProto {
            combat_league_template_id?: (string|null);
            league_start_timestamp_ms?: (number|Long|null);
            rank?: (number|null);
            total_battles?: (number|null);
            total_wins?: (number|null);
            rating?: (number|null);
            longest_win_streak?: (number|null);
            current_streak?: (number|null);
        }

        class CombatLeagueResultProto implements ICombatLeagueResultProto {
            constructor(properties?: POGOProtos.Rpc.ICombatLeagueResultProto);
            public combat_league_template_id: string;
            public league_start_timestamp_ms: (number|Long);
            public rank: number;
            public total_battles: number;
            public total_wins: number;
            public rating: number;
            public longest_win_streak: number;
            public current_streak: number;
            public static encode(message: POGOProtos.Rpc.ICombatLeagueResultProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueResultProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueResultProto;
            public static toObject(message: POGOProtos.Rpc.CombatLeagueResultProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatLeagueSettingsProto {
            combat_league_template_id?: (string[]|null);
        }

        class CombatLeagueSettingsProto implements ICombatLeagueSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatLeagueSettingsProto);
            public combat_league_template_id: string[];
            public static encode(message: POGOProtos.Rpc.ICombatLeagueSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLeagueSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLeagueSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatLeagueSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatLogData {
            open_combat_session_data?: (POGOProtos.Rpc.IOpenCombatSessionData|null);
            open_combat_session_response_data?: (POGOProtos.Rpc.IOpenCombatSessionResponseData|null);
            update_combat_data?: (POGOProtos.Rpc.IUpdateCombatData|null);
            update_combat_response_data?: (POGOProtos.Rpc.IUpdateCombatResponseData|null);
            quit_combat_data?: (POGOProtos.Rpc.IQuitCombatData|null);
            quit_combat_response_data?: (POGOProtos.Rpc.IQuitCombatResponseData|null);
            web_socket_response_data?: (POGOProtos.Rpc.IWebSocketResponseData|null);
            rpc_error_data?: (POGOProtos.Rpc.IRpcErrorData|null);
            get_combat_player_profile_data?: (POGOProtos.Rpc.IGetCombatPlayerProfileData|null);
            get_combat_player_profile_response_data?: (POGOProtos.Rpc.IGetCombatPlayerProfileResponseData|null);
            generate_combat_challenge_id_data?: (POGOProtos.Rpc.IGenerateCombatChallengeIdData|null);
            generate_combat_challenge_id_response_data?: (POGOProtos.Rpc.IGenerateCombatChallengeIdResponseData|null);
            create_combat_challenge_data?: (POGOProtos.Rpc.ICreateCombatChallengeData|null);
            create_combat_challenge_response_data?: (POGOProtos.Rpc.ICreateCombatChallengeResponseData|null);
            open_combat_challenge_data?: (POGOProtos.Rpc.IOpenCombatChallengeData|null);
            open_combat_challenge_response_data?: (POGOProtos.Rpc.IOpenCombatChallengeResponseData|null);
            open_npc_combat_session_data?: (POGOProtos.Rpc.IOpenNpcCombatSessionData|null);
            open_npc_combat_session_response_data?: (POGOProtos.Rpc.IOpenNpcCombatSessionResponseData|null);
            accept_combat_challenge_data?: (POGOProtos.Rpc.IAcceptCombatChallengeData|null);
            accept_combat_challenge_response_data?: (POGOProtos.Rpc.IAcceptCombatChallengeResponseData|null);
            submit_combat_challenge_pokemons_data?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsData|null);
            submit_combat_challenge_pokemons_response_data?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsResponseData|null);
            decline_combat_challenge_data?: (POGOProtos.Rpc.IDeclineCombatChallengeData|null);
            decline_combat_challenge_response_data?: (POGOProtos.Rpc.IDeclineCombatChallengeResponseData|null);
            cancel_combat_challenge_data?: (POGOProtos.Rpc.ICancelCombatChallengeData|null);
            cancel_combat_challenge_response_data?: (POGOProtos.Rpc.ICancelCombatChallengeResponseData|null);
            get_combat_challenge_data?: (POGOProtos.Rpc.IGetCombatChallengeData|null);
            get_combat_challenge_response_data?: (POGOProtos.Rpc.IGetCombatChallengeResponseData|null);
            vs_seeker_start_matchmaking_data?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingData|null);
            vs_seeker_start_matchmaking_response_data?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingResponseData|null);
            get_matchmaking_status_data?: (POGOProtos.Rpc.IGetMatchmakingStatusData|null);
            get_matchmaking_status_response_data?: (POGOProtos.Rpc.IGetMatchmakingStatusResponseData|null);
            cancel_matchmaking_data?: (POGOProtos.Rpc.ICancelMatchmakingData|null);
            cancel_matchmaking_response_data?: (POGOProtos.Rpc.ICancelMatchmakingResponseData|null);
            submit_combat_action?: (POGOProtos.Rpc.ISubmitCombatAction|null);
            invasion_open_combat_session_data?: (POGOProtos.Rpc.IInvasionOpenCombatSessionData|null);
            invasion_open_combat_session_response_data?: (POGOProtos.Rpc.IInvasionOpenCombatSessionResponseData|null);
            invasion_battle_update?: (POGOProtos.Rpc.IInvasionBattleUpdate|null);
            invasion_battle_response_update?: (POGOProtos.Rpc.IInvasionBattleResponseUpdate|null);
            combat_id_mismatch_data?: (POGOProtos.Rpc.ICombatIdMismatchData|null);
            league_id_mismatch_data?: (POGOProtos.Rpc.ILeagueIdMismatchData|null);
            challenge_id_mismatch_data?: (POGOProtos.Rpc.IChallengeIdMismatchData|null);
            progress_token_data?: (POGOProtos.Rpc.ICombatProgressTokenData|null);
            on_application_focus_data?: (POGOProtos.Rpc.IOnApplicationFocusData|null);
            on_application_pause_data?: (POGOProtos.Rpc.IOnApplicationPauseData|null);
            on_application_quit_data?: (POGOProtos.Rpc.IOnApplicationQuitData|null);
            exception_caught_data?: (POGOProtos.Rpc.IExceptionCaughtInCombatData|null);
            combat_pub_sub_data?: (POGOProtos.Rpc.ICombatPubSubData|null);
            combat_end_data?: (POGOProtos.Rpc.ICombatEndData|null);
            combat_sync_server_data?: (POGOProtos.Rpc.ICombatSyncServerData|null);
            combat_sync_server_response_data?: (POGOProtos.Rpc.ICombatSyncServerResponseData|null);
            combat_special_move_player_data?: (POGOProtos.Rpc.ICombatSpecialMovePlayerData|null);
            header?: (POGOProtos.Rpc.CombatLogData.ICombatLogDataHeader|null);
        }

        class CombatLogData implements ICombatLogData {
            constructor(properties?: POGOProtos.Rpc.ICombatLogData);
            public open_combat_session_data?: (POGOProtos.Rpc.IOpenCombatSessionData|null);
            public open_combat_session_response_data?: (POGOProtos.Rpc.IOpenCombatSessionResponseData|null);
            public update_combat_data?: (POGOProtos.Rpc.IUpdateCombatData|null);
            public update_combat_response_data?: (POGOProtos.Rpc.IUpdateCombatResponseData|null);
            public quit_combat_data?: (POGOProtos.Rpc.IQuitCombatData|null);
            public quit_combat_response_data?: (POGOProtos.Rpc.IQuitCombatResponseData|null);
            public web_socket_response_data?: (POGOProtos.Rpc.IWebSocketResponseData|null);
            public rpc_error_data?: (POGOProtos.Rpc.IRpcErrorData|null);
            public get_combat_player_profile_data?: (POGOProtos.Rpc.IGetCombatPlayerProfileData|null);
            public get_combat_player_profile_response_data?: (POGOProtos.Rpc.IGetCombatPlayerProfileResponseData|null);
            public generate_combat_challenge_id_data?: (POGOProtos.Rpc.IGenerateCombatChallengeIdData|null);
            public generate_combat_challenge_id_response_data?: (POGOProtos.Rpc.IGenerateCombatChallengeIdResponseData|null);
            public create_combat_challenge_data?: (POGOProtos.Rpc.ICreateCombatChallengeData|null);
            public create_combat_challenge_response_data?: (POGOProtos.Rpc.ICreateCombatChallengeResponseData|null);
            public open_combat_challenge_data?: (POGOProtos.Rpc.IOpenCombatChallengeData|null);
            public open_combat_challenge_response_data?: (POGOProtos.Rpc.IOpenCombatChallengeResponseData|null);
            public open_npc_combat_session_data?: (POGOProtos.Rpc.IOpenNpcCombatSessionData|null);
            public open_npc_combat_session_response_data?: (POGOProtos.Rpc.IOpenNpcCombatSessionResponseData|null);
            public accept_combat_challenge_data?: (POGOProtos.Rpc.IAcceptCombatChallengeData|null);
            public accept_combat_challenge_response_data?: (POGOProtos.Rpc.IAcceptCombatChallengeResponseData|null);
            public submit_combat_challenge_pokemons_data?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsData|null);
            public submit_combat_challenge_pokemons_response_data?: (POGOProtos.Rpc.ISubmitCombatChallengePokemonsResponseData|null);
            public decline_combat_challenge_data?: (POGOProtos.Rpc.IDeclineCombatChallengeData|null);
            public decline_combat_challenge_response_data?: (POGOProtos.Rpc.IDeclineCombatChallengeResponseData|null);
            public cancel_combat_challenge_data?: (POGOProtos.Rpc.ICancelCombatChallengeData|null);
            public cancel_combat_challenge_response_data?: (POGOProtos.Rpc.ICancelCombatChallengeResponseData|null);
            public get_combat_challenge_data?: (POGOProtos.Rpc.IGetCombatChallengeData|null);
            public get_combat_challenge_response_data?: (POGOProtos.Rpc.IGetCombatChallengeResponseData|null);
            public vs_seeker_start_matchmaking_data?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingData|null);
            public vs_seeker_start_matchmaking_response_data?: (POGOProtos.Rpc.IVsSeekerStartMatchmakingResponseData|null);
            public get_matchmaking_status_data?: (POGOProtos.Rpc.IGetMatchmakingStatusData|null);
            public get_matchmaking_status_response_data?: (POGOProtos.Rpc.IGetMatchmakingStatusResponseData|null);
            public cancel_matchmaking_data?: (POGOProtos.Rpc.ICancelMatchmakingData|null);
            public cancel_matchmaking_response_data?: (POGOProtos.Rpc.ICancelMatchmakingResponseData|null);
            public submit_combat_action?: (POGOProtos.Rpc.ISubmitCombatAction|null);
            public invasion_open_combat_session_data?: (POGOProtos.Rpc.IInvasionOpenCombatSessionData|null);
            public invasion_open_combat_session_response_data?: (POGOProtos.Rpc.IInvasionOpenCombatSessionResponseData|null);
            public invasion_battle_update?: (POGOProtos.Rpc.IInvasionBattleUpdate|null);
            public invasion_battle_response_update?: (POGOProtos.Rpc.IInvasionBattleResponseUpdate|null);
            public combat_id_mismatch_data?: (POGOProtos.Rpc.ICombatIdMismatchData|null);
            public league_id_mismatch_data?: (POGOProtos.Rpc.ILeagueIdMismatchData|null);
            public challenge_id_mismatch_data?: (POGOProtos.Rpc.IChallengeIdMismatchData|null);
            public progress_token_data?: (POGOProtos.Rpc.ICombatProgressTokenData|null);
            public on_application_focus_data?: (POGOProtos.Rpc.IOnApplicationFocusData|null);
            public on_application_pause_data?: (POGOProtos.Rpc.IOnApplicationPauseData|null);
            public on_application_quit_data?: (POGOProtos.Rpc.IOnApplicationQuitData|null);
            public exception_caught_data?: (POGOProtos.Rpc.IExceptionCaughtInCombatData|null);
            public combat_pub_sub_data?: (POGOProtos.Rpc.ICombatPubSubData|null);
            public combat_end_data?: (POGOProtos.Rpc.ICombatEndData|null);
            public combat_sync_server_data?: (POGOProtos.Rpc.ICombatSyncServerData|null);
            public combat_sync_server_response_data?: (POGOProtos.Rpc.ICombatSyncServerResponseData|null);
            public combat_special_move_player_data?: (POGOProtos.Rpc.ICombatSpecialMovePlayerData|null);
            public header?: (POGOProtos.Rpc.CombatLogData.ICombatLogDataHeader|null);
            public Data?: ("open_combat_session_data"|"open_combat_session_response_data"|"update_combat_data"|"update_combat_response_data"|"quit_combat_data"|"quit_combat_response_data"|"web_socket_response_data"|"rpc_error_data"|"get_combat_player_profile_data"|"get_combat_player_profile_response_data"|"generate_combat_challenge_id_data"|"generate_combat_challenge_id_response_data"|"create_combat_challenge_data"|"create_combat_challenge_response_data"|"open_combat_challenge_data"|"open_combat_challenge_response_data"|"open_npc_combat_session_data"|"open_npc_combat_session_response_data"|"accept_combat_challenge_data"|"accept_combat_challenge_response_data"|"submit_combat_challenge_pokemons_data"|"submit_combat_challenge_pokemons_response_data"|"decline_combat_challenge_data"|"decline_combat_challenge_response_data"|"cancel_combat_challenge_data"|"cancel_combat_challenge_response_data"|"get_combat_challenge_data"|"get_combat_challenge_response_data"|"vs_seeker_start_matchmaking_data"|"vs_seeker_start_matchmaking_response_data"|"get_matchmaking_status_data"|"get_matchmaking_status_response_data"|"cancel_matchmaking_data"|"cancel_matchmaking_response_data"|"submit_combat_action"|"invasion_open_combat_session_data"|"invasion_open_combat_session_response_data"|"invasion_battle_update"|"invasion_battle_response_update"|"combat_id_mismatch_data"|"league_id_mismatch_data"|"challenge_id_mismatch_data"|"progress_token_data"|"on_application_focus_data"|"on_application_pause_data"|"on_application_quit_data"|"exception_caught_data"|"combat_pub_sub_data"|"combat_end_data"|"combat_sync_server_data"|"combat_sync_server_response_data"|"combat_special_move_player_data");
            public static encode(message: POGOProtos.Rpc.ICombatLogData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLogData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLogData;
            public static toObject(message: POGOProtos.Rpc.CombatLogData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatLogData {

            interface ICombatLogDataHeader {
                type?: (POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType|null);
                time_now_offset_ms?: (number|null);
                client_server_time_offset_ms?: (number|null);
                frame_rate?: (number|null);
            }

            class CombatLogDataHeader implements ICombatLogDataHeader {
                constructor(properties?: POGOProtos.Rpc.CombatLogData.ICombatLogDataHeader);
                public type: POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType;
                public time_now_offset_ms: number;
                public client_server_time_offset_ms: number;
                public frame_rate: number;
                public static encode(message: POGOProtos.Rpc.CombatLogData.ICombatLogDataHeader, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLogData.CombatLogDataHeader;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLogData.CombatLogDataHeader;
                public static toObject(message: POGOProtos.Rpc.CombatLogData.CombatLogDataHeader, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CombatLogDataHeader {

                enum LogType {
                    NO_TYPE = 0,
                    OPEN_COMBAT_SESSION = 1,
                    OPEN_COMBAT_SESSION_RESPONSE = 2,
                    UPDATE_COMBAT = 3,
                    UPDATE_COMBAT_RESPONSE = 4,
                    QUIT_COMBAT = 5,
                    QUIT_COMBAT_RESPONSE = 6,
                    WEB_SOCKET_RESPONSE = 7,
                    RPC_ERROR = 8,
                    GET_COMBAT_PLAYER_PROFILE = 9,
                    GET_COMBAT_PLAYER_PROFILE_RESPONSE = 10,
                    GENERATE_COMBAT_CHALLENGE_ID = 11,
                    GENERATE_COMBAT_CHALLENGE_ID_RESPONSE = 12,
                    CREATE_COMBAT_CHALLENGE = 13,
                    CREATE_COMBAT_CHALLENGE_RESPONSE = 14,
                    OPEN_COMBAT_CHALLENGE = 15,
                    OPEN_COMBAT_CHALLENGE_RESPONSE = 16,
                    OPEN_NPC_COMBAT_SESSION = 17,
                    OPEN_NPC_COMBAT_SESSION_RESPONSE = 18,
                    ACCEPT_COMBAT_CHALLENGE = 19,
                    ACCEPT_COMBAT_CHALLENGE_RESPONSE = 20,
                    SUBMIT_COMBAT_CHALLENGE_POKEMONS = 21,
                    SUBMIT_COMBAT_CHALLENGE_POKEMONS_RESPONSE = 22,
                    DECLINE_COMBAT_CHALLENGE = 23,
                    DECLINE_COMBAT_CHALLENGE_RESPONSE = 24,
                    CANCEL_COMBAT_CHALLENGE = 25,
                    CANCEL_COMBAT_CHALLENGE_RESPONSE = 26,
                    GET_COMBAT_CHALLENGE = 27,
                    GET_COMBAT_CHALLENGE_RESPONSE = 28,
                    VS_SEEKER_START_MATCHMAKING = 29,
                    VS_SEEKER_START_MATCHMAKING_RESPONSE = 30,
                    GET_MATCHMAKING_STATUS = 31,
                    GET_MATCHMAKING_STATUS_RESPONSE = 32,
                    CANCEL_MATCHMAKING = 33,
                    CANCEL_MATCHMAKING_RESPONSE = 34,
                    SUBMIT_COMBAT_ACTION = 35,
                    INVASION_OPEN_COMBAT_SESSION = 36,
                    INVASION_OPEN_COMBAT_SESSION_RESPONSE = 37,
                    INVASION_BATTLE_UPDATE = 38,
                    INVASION_BATTLE_UPDATE_RESPONSE = 39,
                    COMBAT_ID_MISMATCH = 40,
                    LEAGUE_ID_MISMATCH = 41,
                    CHALLENGE_ID_MISMATCH = 42,
                    PROGRESS_TOKEN = 43,
                    ON_APPLICATION_FOCUS = 44,
                    ON_APPLICATION_PAUSE = 45,
                    ON_APPLICATION_QUIT = 46,
                    EXCEPTION_CAUGHT = 47,
                    PUB_SUB_MESSAGE = 48,
                    PLAYER_END_COMBAT = 49,
                    COMBAT_SYNC_SERVER = 50,
                    COMBAT_SYNC_SERVER_RESPONSE = 51,
                    COMBAT_SPECIAL_MOVE_PLAYER = 52
                }
            }
        }

        interface ICombatLogEntry {
            result?: (POGOProtos.Rpc.CombatLogEntry.Result|null);
            finish_state?: (POGOProtos.Rpc.CombatPlayerFinishState|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            opponent?: (string|null);
            combat_league_template_id?: (string|null);
            npc_template_id?: (string|null);
        }

        class CombatLogEntry implements ICombatLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICombatLogEntry);
            public result: POGOProtos.Rpc.CombatLogEntry.Result;
            public finish_state: POGOProtos.Rpc.CombatPlayerFinishState;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public opponent: string;
            public combat_league_template_id: string;
            public npc_template_id: string;
            public static encode(message: POGOProtos.Rpc.ICombatLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLogEntry;
            public static toObject(message: POGOProtos.Rpc.CombatLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ICombatLogHeader {
            combat_id?: (string|null);
            combat_league_template_id?: (string|null);
            combat_challenge_id?: (string|null);
            combat_npc_id?: (string|null);
            combat_npc_personality_id?: (string|null);
            queue_id?: (string|null);
            challenger_pokemon?: (POGOProtos.Rpc.ICombatPokemonLogProto[]|null);
            opponent_pokemon?: (POGOProtos.Rpc.ICombatPokemonLogProto[]|null);
            time_root_ms?: (number|Long|null);
            lobby_challenger_join_time_ms?: (number|Long|null);
            lobby_opponent_join_time_ms?: (number|Long|null);
            combat_start_ms?: (number|Long|null);
            combat_end_ms?: (number|Long|null);
            realm?: (string|null);
        }

        class CombatLogHeader implements ICombatLogHeader {
            constructor(properties?: POGOProtos.Rpc.ICombatLogHeader);
            public combat_id: string;
            public combat_league_template_id: string;
            public combat_challenge_id: string;
            public combat_npc_id: string;
            public combat_npc_personality_id: string;
            public queue_id: string;
            public challenger_pokemon: POGOProtos.Rpc.ICombatPokemonLogProto[];
            public opponent_pokemon: POGOProtos.Rpc.ICombatPokemonLogProto[];
            public time_root_ms: (number|Long);
            public lobby_challenger_join_time_ms: (number|Long);
            public lobby_opponent_join_time_ms: (number|Long);
            public combat_start_ms: (number|Long);
            public combat_end_ms: (number|Long);
            public realm: string;
            public static encode(message: POGOProtos.Rpc.ICombatLogHeader, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLogHeader;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLogHeader;
            public static toObject(message: POGOProtos.Rpc.CombatLogHeader, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatLogProto {
            lifetime_results?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            current_season_results?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            current_vs_seeker_set_results?: (POGOProtos.Rpc.IVsSeekerBattleResult[]|null);
            previous_season_results?: (POGOProtos.Rpc.ICombatSeasonResult|null);
        }

        class CombatLogProto implements ICombatLogProto {
            constructor(properties?: POGOProtos.Rpc.ICombatLogProto);
            public lifetime_results?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            public current_season_results?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            public current_vs_seeker_set_results: POGOProtos.Rpc.IVsSeekerBattleResult[];
            public previous_season_results?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            public static encode(message: POGOProtos.Rpc.ICombatLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatLogProto;
            public static toObject(message: POGOProtos.Rpc.CombatLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatMinigameTelemetry {
            combat_type?: (POGOProtos.Rpc.CombatMinigameTelemetry.MinigameCombatType|null);
            move_type?: (POGOProtos.Rpc.HoloPokemonType|null);
            score?: (number|null);
        }

        class CombatMinigameTelemetry implements ICombatMinigameTelemetry {
            constructor(properties?: POGOProtos.Rpc.ICombatMinigameTelemetry);
            public combat_type: POGOProtos.Rpc.CombatMinigameTelemetry.MinigameCombatType;
            public move_type: POGOProtos.Rpc.HoloPokemonType;
            public score: number;
            public static encode(message: POGOProtos.Rpc.ICombatMinigameTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatMinigameTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatMinigameTelemetry;
            public static toObject(message: POGOProtos.Rpc.CombatMinigameTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatMinigameTelemetry {

            enum MinigameCombatType {
                UNSET = 0,
                PVP = 1,
                PVE = 2
            }
        }

        interface ICombatMoveSettingsProto {
            unique_id?: (POGOProtos.Rpc.HoloPokemonMove|null);
            type?: (POGOProtos.Rpc.HoloPokemonType|null);
            power?: (number|null);
            vfx_name?: (string|null);
            duration_turns?: (number|null);
            energy_delta?: (number|null);
            buffs?: (POGOProtos.Rpc.CombatMoveSettingsProto.ICombatMoveBuffsProto|null);
            modifier?: (POGOProtos.Rpc.IMoveModifierProto[]|null);
        }

        class CombatMoveSettingsProto implements ICombatMoveSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatMoveSettingsProto);
            public unique_id: POGOProtos.Rpc.HoloPokemonMove;
            public type: POGOProtos.Rpc.HoloPokemonType;
            public power: number;
            public vfx_name: string;
            public duration_turns: number;
            public energy_delta: number;
            public buffs?: (POGOProtos.Rpc.CombatMoveSettingsProto.ICombatMoveBuffsProto|null);
            public modifier: POGOProtos.Rpc.IMoveModifierProto[];
            public static encode(message: POGOProtos.Rpc.ICombatMoveSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatMoveSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatMoveSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatMoveSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatMoveSettingsProto {

            interface ICombatMoveBuffsProto {
                attacker_attack_stat_stage_change?: (number|null);
                attacker_defense_stat_stage_change?: (number|null);
                target_attack_stat_stage_change?: (number|null);
                target_defense_stat_stage_change?: (number|null);
                buff_activation_chance?: (number|null);
            }

            class CombatMoveBuffsProto implements ICombatMoveBuffsProto {
                constructor(properties?: POGOProtos.Rpc.CombatMoveSettingsProto.ICombatMoveBuffsProto);
                public attacker_attack_stat_stage_change: number;
                public attacker_defense_stat_stage_change: number;
                public target_attack_stat_stage_change: number;
                public target_defense_stat_stage_change: number;
                public buff_activation_chance: number;
                public static encode(message: POGOProtos.Rpc.CombatMoveSettingsProto.ICombatMoveBuffsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatMoveSettingsProto.CombatMoveBuffsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatMoveSettingsProto.CombatMoveBuffsProto;
                public static toObject(message: POGOProtos.Rpc.CombatMoveSettingsProto.CombatMoveBuffsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatNpcPersonalityProto {
            personality_name?: (string|null);
            super_effective_chance?: (number|null);
            special_chance?: (number|null);
            defensive_minimum_score?: (number|null);
            defensive_maximum_score?: (number|null);
            offensive_minimum_score?: (number|null);
            offensive_maximum_score?: (number|null);
        }

        class CombatNpcPersonalityProto implements ICombatNpcPersonalityProto {
            constructor(properties?: POGOProtos.Rpc.ICombatNpcPersonalityProto);
            public personality_name: string;
            public super_effective_chance: number;
            public special_chance: number;
            public defensive_minimum_score: number;
            public defensive_maximum_score: number;
            public offensive_minimum_score: number;
            public offensive_maximum_score: number;
            public static encode(message: POGOProtos.Rpc.ICombatNpcPersonalityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatNpcPersonalityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatNpcPersonalityProto;
            public static toObject(message: POGOProtos.Rpc.CombatNpcPersonalityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatNpcTrainerProto {
            trainer_name?: (string|null);
            combat_league_template_id?: (string|null);
            combat_personality_id?: (string|null);
            win_loot_table_id?: (string|null);
            lose_loot_table_id?: (string|null);
            avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            available_pokemon?: (POGOProtos.Rpc.INpcPokemonProto[]|null);
            trainer_title?: (string|null);
            trainer_quote?: (string|null);
            icon_url?: (string|null);
            backdrop_image_bundle?: (string|null);
        }

        class CombatNpcTrainerProto implements ICombatNpcTrainerProto {
            constructor(properties?: POGOProtos.Rpc.ICombatNpcTrainerProto);
            public trainer_name: string;
            public combat_league_template_id: string;
            public combat_personality_id: string;
            public win_loot_table_id: string;
            public lose_loot_table_id: string;
            public avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public available_pokemon: POGOProtos.Rpc.INpcPokemonProto[];
            public trainer_title: string;
            public trainer_quote: string;
            public icon_url: string;
            public backdrop_image_bundle: string;
            public static encode(message: POGOProtos.Rpc.ICombatNpcTrainerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatNpcTrainerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatNpcTrainerProto;
            public static toObject(message: POGOProtos.Rpc.CombatNpcTrainerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatOffensiveInputChallengeSettings {
            score_per_tap?: (number|null);
            score_decay_per_second?: (number|null);
            max_score?: (number|null);
            high_score_additional_decay_per_second?: (number|null);
            max_time_additional_decay_per_second?: (number|null);
        }

        class CombatOffensiveInputChallengeSettings implements ICombatOffensiveInputChallengeSettings {
            constructor(properties?: POGOProtos.Rpc.ICombatOffensiveInputChallengeSettings);
            public score_per_tap: number;
            public score_decay_per_second: number;
            public max_score: number;
            public high_score_additional_decay_per_second: number;
            public max_time_additional_decay_per_second: number;
            public static encode(message: POGOProtos.Rpc.ICombatOffensiveInputChallengeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatOffensiveInputChallengeSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatOffensiveInputChallengeSettings;
            public static toObject(message: POGOProtos.Rpc.CombatOffensiveInputChallengeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatPlayerPreferencesProto {
            friends_combat_opt_out?: (boolean|null);
            nearby_combat_opt_in?: (boolean|null);
        }

        class CombatPlayerPreferencesProto implements ICombatPlayerPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.ICombatPlayerPreferencesProto);
            public friends_combat_opt_out: boolean;
            public nearby_combat_opt_in: boolean;
            public static encode(message: POGOProtos.Rpc.ICombatPlayerPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatPlayerPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatPlayerPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.CombatPlayerPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatPlayerProfileProto {
            player_id?: (string|null);
            public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            combat_league_template_id?: (string[]|null);
            buddy_pokemon_id?: (number|Long|null);
            location?: (POGOProtos.Rpc.CombatPlayerProfileProto.ILocation|null);
            combat_player_preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
            player_nia_id?: (string|null);
        }

        class CombatPlayerProfileProto implements ICombatPlayerProfileProto {
            constructor(properties?: POGOProtos.Rpc.ICombatPlayerProfileProto);
            public player_id: string;
            public public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public combat_league_template_id: string[];
            public buddy_pokemon_id: (number|Long);
            public location?: (POGOProtos.Rpc.CombatPlayerProfileProto.ILocation|null);
            public combat_player_preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
            public player_nia_id: string;
            public static encode(message: POGOProtos.Rpc.ICombatPlayerProfileProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatPlayerProfileProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatPlayerProfileProto;
            public static toObject(message: POGOProtos.Rpc.CombatPlayerProfileProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatPlayerProfileProto {

            interface ILocation {
                lat_degree?: (number|null);
                lng_degree?: (number|null);
            }

            class Location implements ILocation {
                constructor(properties?: POGOProtos.Rpc.CombatPlayerProfileProto.ILocation);
                public lat_degree: number;
                public lng_degree: number;
                public static encode(message: POGOProtos.Rpc.CombatPlayerProfileProto.ILocation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatPlayerProfileProto.Location;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatPlayerProfileProto.Location;
                public static toObject(message: POGOProtos.Rpc.CombatPlayerProfileProto.Location, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatPokemonLogProto {
            pokemon_id?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            cp_multiplier?: (number|null);
            max_stamina?: (number|null);
            move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
            move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
            move3?: (POGOProtos.Rpc.HoloPokemonMove|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            individual_attack?: (number|null);
            individual_defense?: (number|null);
            individual_stamina?: (number|null);
            battles_won?: (number|null);
            battles_lost?: (number|null);
            nickname?: (string|null);
            pokeball?: (POGOProtos.Rpc.Item|null);
        }

        class CombatPokemonLogProto implements ICombatPokemonLogProto {
            constructor(properties?: POGOProtos.Rpc.ICombatPokemonLogProto);
            public pokemon_id: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public cp_multiplier: number;
            public max_stamina: number;
            public move1: POGOProtos.Rpc.HoloPokemonMove;
            public move2: POGOProtos.Rpc.HoloPokemonMove;
            public move3: POGOProtos.Rpc.HoloPokemonMove;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public individual_attack: number;
            public individual_defense: number;
            public individual_stamina: number;
            public battles_won: number;
            public battles_lost: number;
            public nickname: string;
            public pokeball: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.ICombatPokemonLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatPokemonLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatPokemonLogProto;
            public static toObject(message: POGOProtos.Rpc.CombatPokemonLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatProgressTokenData {
            combat_active_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatActiveStateFunction|null);
            combat_end_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatEndStateFunction|null);
            combat_ready_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatReadyStateFunction|null);
            combat_swap_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatSwapStateFunction|null);
            combat_special_move_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatSpecialMoveStateFunction|null);
            combat_wait_for_player_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatWaitForPlayerStateFunction|null);
            combat_presentation_director_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatPresentationDirectorFunction|null);
            combat_director_v2_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatDirectorV2Function|null);
            combat_state_v2_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatStateV2Function|null);
            combat_pokemon_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatPokemonFunction|null);
            line_number?: (number|null);
        }

        class CombatProgressTokenData implements ICombatProgressTokenData {
            constructor(properties?: POGOProtos.Rpc.ICombatProgressTokenData);
            public combat_active_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatActiveStateFunction|null);
            public combat_end_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatEndStateFunction|null);
            public combat_ready_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatReadyStateFunction|null);
            public combat_swap_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatSwapStateFunction|null);
            public combat_special_move_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatSpecialMoveStateFunction|null);
            public combat_wait_for_player_state_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatWaitForPlayerStateFunction|null);
            public combat_presentation_director_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatPresentationDirectorFunction|null);
            public combat_director_v2_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatDirectorV2Function|null);
            public combat_state_v2_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatStateV2Function|null);
            public combat_pokemon_function?: (POGOProtos.Rpc.CombatProgressTokenData.CombatPokemonFunction|null);
            public line_number: number;
            public Token?: ("combat_active_state_function"|"combat_end_state_function"|"combat_ready_state_function"|"combat_swap_state_function"|"combat_special_move_state_function"|"combat_wait_for_player_state_function"|"combat_presentation_director_function"|"combat_director_v2_function"|"combat_state_v2_function"|"combat_pokemon_function");
            public static encode(message: POGOProtos.Rpc.ICombatProgressTokenData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProgressTokenData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProgressTokenData;
            public static toObject(message: POGOProtos.Rpc.CombatProgressTokenData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatProgressTokenData {

            enum CombatActiveStateFunction {
                NONE_COMBAT_ACTIVE_STATE = 0,
                ENTER_COMBAT_ACTIVE_STATE = 1,
                EXIT_COMBAT_ACTIVE_STATE = 2,
                DO_WORK_COMBAT_ACTIVE_STATE = 3
            }

            enum CombatDirectorV2Function {
                NONE_COMBAT_DIRECTOR_V2 = 0,
                TRY_START_COMBAT = 1,
                START_COMBAT_ERROR = 2,
                RECEIVE_COMBAT_UPDATE = 3,
                TRY_FAST_ATTACK = 4,
                SWAP_POKEMON_TO = 5,
                QUEUE_SPECIAL_ATTACK = 6,
                TRY_SPECIAL_ATTACK = 7,
                TRY_EXECUTE_BUFFERED_ACTION = 8,
                CAN_ACT_ON_TURN = 9,
                CAN_PERFORM_ATTACK = 10,
                CHECK_OPPONENT_CHARGE_MOVE_CHANCE = 11
            }

            enum CombatEndStateFunction {
                NONE_COMBAT_END_STATE = 0,
                ENTER_COMBAT_END_STATE = 1,
                EXIT_COMBAT_END_STATE = 2,
                DO_WORK_COMBAT_END_STATE = 3
            }

            enum CombatPokemonFunction {
                OBSERVE_ACTION = 0,
                EXECUTE_ACTION = 1,
                PAUSE_UPDATES = 2
            }

            enum CombatPresentationDirectorFunction {
                NONE_COMBAT_PRESENTATION_DIRECTOR = 0,
                PLAY_MINI_GAME = 1
            }

            enum CombatReadyStateFunction {
                NONE_COMBAT_READY_STATE = 0,
                ENTER_COMBAT_READY_STATE = 1,
                EXIT_COMBAT_READY_STATE = 2,
                DO_WORK_COMBAT_READY_STATE = 3
            }

            enum CombatSpecialMoveStateFunction {
                NONE_COMBAT_SPECIAL_MOVE_STATE = 0,
                ENTER_COMBAT_SPECIAL_MOVE_STATE = 1,
                EXIT_COMBAT_SPECIAL_MOVE_STATE = 2,
                DO_WORK_COMBAT_SPECIAL_MOVE_STATE = 3,
                PERFORM_FLY_IN = 4,
                PERFORM_FLY_OUT = 5
            }

            enum CombatStateV2Function {
                NONE_COMBAT_STATE_V2 = 0,
                OBSERVE_COMBAT_STATE = 1,
                DELAY_SPECIAL_TRANSITION = 2
            }

            enum CombatSwapStateFunction {
                NONE_COMBAT_SWAP_STATE = 0,
                ENTER_COMBAT_SWAP_STATE = 1,
                EXIT_COMBAT_SWAP_STATE = 2,
                DO_WORK_COMBAT_SWAP_STATE = 3
            }

            enum CombatWaitForPlayerStateFunction {
                NONE_COMBAT_WAIT_FOR_PLAYER_STATE = 0,
                ENTER_COMBAT_WAIT_FOR_PLAYER_STATE = 1,
                EXIT_COMBAT_WAIT_FOR_PLAYER_STATE = 2,
                DO_WORK_COMBAT_WAIT_FOR_PLAYER_STATE = 3
            }
        }

        interface ICombatProto {
            combat_state?: (POGOProtos.Rpc.CombatProto.CombatState|null);
            combat_id?: (string|null);
            player?: (POGOProtos.Rpc.CombatProto.ICombatPlayerProto|null);
            opponent?: (POGOProtos.Rpc.CombatProto.ICombatPlayerProto|null);
            combat_start_ms?: (number|Long|null);
            combat_end_ms?: (number|Long|null);
            server_ms?: (number|Long|null);
            current_turn?: (number|null);
            turn_start_ms?: (number|Long|null);
            minigame_end_ms?: (number|Long|null);
            minigame_submit_score_end_ms?: (number|Long|null);
            change_pokemon_end_ms?: (number|Long|null);
            quick_swap_cooldown_duration_ms?: (number|Long|null);
            state_change_delay_until_turn?: (number|Long|null);
            minigame_data?: (POGOProtos.Rpc.CombatProto.IMinigameProto|null);
            combat_request_counter?: (number|null);
            opponent_triggered?: (boolean|null);
            opponent_request_counter?: (number|null);
        }

        class CombatProto implements ICombatProto {
            constructor(properties?: POGOProtos.Rpc.ICombatProto);
            public combat_state: POGOProtos.Rpc.CombatProto.CombatState;
            public combat_id: string;
            public player?: (POGOProtos.Rpc.CombatProto.ICombatPlayerProto|null);
            public opponent?: (POGOProtos.Rpc.CombatProto.ICombatPlayerProto|null);
            public combat_start_ms: (number|Long);
            public combat_end_ms: (number|Long);
            public server_ms: (number|Long);
            public current_turn: number;
            public turn_start_ms: (number|Long);
            public minigame_end_ms: (number|Long);
            public minigame_submit_score_end_ms: (number|Long);
            public change_pokemon_end_ms: (number|Long);
            public quick_swap_cooldown_duration_ms: (number|Long);
            public state_change_delay_until_turn: (number|Long);
            public minigame_data?: (POGOProtos.Rpc.CombatProto.IMinigameProto|null);
            public combat_request_counter: number;
            public opponent_triggered: boolean;
            public opponent_request_counter: number;
            public static encode(message: POGOProtos.Rpc.ICombatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProto;
            public static toObject(message: POGOProtos.Rpc.CombatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatProto {

            enum CombatState {
                UNSET = 0,
                WAITING_FOR_PLAYERS = 1,
                READY = 2,
                ACTIVE = 3,
                SPECIAL_ATTACK = 4,
                WAITING_FOR_CHANGE_POKEMON = 5,
                FINISHED = 6,
                PLAYER_QUIT = 7,
                TIMEOUT = 8,
                SYNC = 9
            }

            interface ICombatIbfcPokemonFormTrackerProto {
                form?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
                is_shiny?: (boolean|null);
            }

            class CombatIbfcPokemonFormTrackerProto implements ICombatIbfcPokemonFormTrackerProto {
                constructor(properties?: POGOProtos.Rpc.CombatProto.ICombatIbfcPokemonFormTrackerProto);
                public form: POGOProtos.Rpc.PokemonDisplayProto.Form[];
                public is_shiny: boolean;
                public static encode(message: POGOProtos.Rpc.CombatProto.ICombatIbfcPokemonFormTrackerProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProto.CombatIbfcPokemonFormTrackerProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProto.CombatIbfcPokemonFormTrackerProto;
                public static toObject(message: POGOProtos.Rpc.CombatProto.CombatIbfcPokemonFormTrackerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPlayerProto {
                public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                active_pokemon?: (POGOProtos.Rpc.CombatProto.ICombatPokemonProto|null);
                reserve_pokemon?: (POGOProtos.Rpc.CombatProto.ICombatPokemonProto[]|null);
                fainted_pokemon?: (POGOProtos.Rpc.CombatProto.ICombatPokemonProto[]|null);
                current_action?: (POGOProtos.Rpc.ICombatActionProto|null);
                lockstep_ack?: (boolean|null);
                last_updated_turn?: (number|null);
                minigame_action?: (POGOProtos.Rpc.ICombatActionProto|null);
                quick_swap_available_ms?: (number|Long|null);
                minigame_defense_chances_left?: (number|null);
                combat_npc_personality_id?: (string|null);
                times_combat_actions_called?: (number|null);
                lobby_join_time_ms?: (number|Long|null);
                super_effective_charge_attacks_used?: (number|null);
                last_snapshot_action_type?: (POGOProtos.Rpc.CombatActionProto.ActionType|null);
                last_active_pokemon?: (POGOProtos.Rpc.CombatProto.ICombatPokemonProto|null);
                ibfc_form_tracker?: ({ [k: string]: POGOProtos.Rpc.CombatProto.ICombatIbfcPokemonFormTrackerProto }|null);
            }

            class CombatPlayerProto implements ICombatPlayerProto {
                constructor(properties?: POGOProtos.Rpc.CombatProto.ICombatPlayerProto);
                public public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                public active_pokemon?: (POGOProtos.Rpc.CombatProto.ICombatPokemonProto|null);
                public reserve_pokemon: POGOProtos.Rpc.CombatProto.ICombatPokemonProto[];
                public fainted_pokemon: POGOProtos.Rpc.CombatProto.ICombatPokemonProto[];
                public current_action?: (POGOProtos.Rpc.ICombatActionProto|null);
                public lockstep_ack: boolean;
                public last_updated_turn: number;
                public minigame_action?: (POGOProtos.Rpc.ICombatActionProto|null);
                public quick_swap_available_ms: (number|Long);
                public minigame_defense_chances_left: number;
                public combat_npc_personality_id: string;
                public times_combat_actions_called: number;
                public lobby_join_time_ms: (number|Long);
                public super_effective_charge_attacks_used: number;
                public last_snapshot_action_type: POGOProtos.Rpc.CombatActionProto.ActionType;
                public last_active_pokemon?: (POGOProtos.Rpc.CombatProto.ICombatPokemonProto|null);
                public ibfc_form_tracker: { [k: string]: POGOProtos.Rpc.CombatProto.ICombatIbfcPokemonFormTrackerProto };
                public static encode(message: POGOProtos.Rpc.CombatProto.ICombatPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProto.CombatPlayerProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProto.CombatPlayerProto;
                public static toObject(message: POGOProtos.Rpc.CombatProto.CombatPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPokemonProto {
                pokemon_id?: (number|Long|null);
                pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                cp?: (number|null);
                cp_multiplier?: (number|null);
                stamina?: (number|null);
                max_stamina?: (number|null);
                move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
                move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
                move3?: (POGOProtos.Rpc.HoloPokemonMove|null);
                energy?: (number|null);
                pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                individual_attack?: (number|null);
                individual_defense?: (number|null);
                individual_stamina?: (number|null);
                attack_stat_stage?: (number|null);
                defense_stat_stage?: (number|null);
                battles_won?: (number|null);
                battles_lost?: (number|null);
                nickname?: (string|null);
                pokeball?: (POGOProtos.Rpc.Item|null);
                height_m?: (number|null);
                weight_kg?: (number|null);
                pokemon_size?: (POGOProtos.Rpc.HoloPokemonSize|null);
                notable_action_history?: (POGOProtos.Rpc.IVsActionHistory[]|null);
                vs_effect_tag?: (POGOProtos.Rpc.VsEffectTag[]|null);
                combat_pokemon_ibfc?: (POGOProtos.Rpc.CombatProto.ICombatPokemonIbfcProto|null);
            }

            class CombatPokemonProto implements ICombatPokemonProto {
                constructor(properties?: POGOProtos.Rpc.CombatProto.ICombatPokemonProto);
                public pokemon_id: (number|Long);
                public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
                public cp: number;
                public cp_multiplier: number;
                public stamina: number;
                public max_stamina: number;
                public move1: POGOProtos.Rpc.HoloPokemonMove;
                public move2: POGOProtos.Rpc.HoloPokemonMove;
                public move3: POGOProtos.Rpc.HoloPokemonMove;
                public energy: number;
                public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public individual_attack: number;
                public individual_defense: number;
                public individual_stamina: number;
                public attack_stat_stage: number;
                public defense_stat_stage: number;
                public battles_won: number;
                public battles_lost: number;
                public nickname: string;
                public pokeball: POGOProtos.Rpc.Item;
                public height_m: number;
                public weight_kg: number;
                public pokemon_size: POGOProtos.Rpc.HoloPokemonSize;
                public notable_action_history: POGOProtos.Rpc.IVsActionHistory[];
                public vs_effect_tag: POGOProtos.Rpc.VsEffectTag[];
                public combat_pokemon_ibfc?: (POGOProtos.Rpc.CombatProto.ICombatPokemonIbfcProto|null);
                public static encode(message: POGOProtos.Rpc.CombatProto.ICombatPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProto.CombatPokemonProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProto.CombatPokemonProto;
                public static toObject(message: POGOProtos.Rpc.CombatProto.CombatPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPokemonIbfcProto {
                animation_play_turn?: (number|null);
                vfx_key?: (POGOProtos.Rpc.IbfcVfxKey|null);
                player?: (POGOProtos.Rpc.CombatProto.ICombatPlayerProto|null);
                updated_flyout_duration_turns?: (number|null);
                ibfc_trigger_move?: (number|null);
            }

            class CombatPokemonIbfcProto implements ICombatPokemonIbfcProto {
                constructor(properties?: POGOProtos.Rpc.CombatProto.ICombatPokemonIbfcProto);
                public animation_play_turn: number;
                public vfx_key: POGOProtos.Rpc.IbfcVfxKey;
                public player?: (POGOProtos.Rpc.CombatProto.ICombatPlayerProto|null);
                public updated_flyout_duration_turns: number;
                public ibfc_trigger_move: number;
                public static encode(message: POGOProtos.Rpc.CombatProto.ICombatPokemonIbfcProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProto.CombatPokemonIbfcProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProto.CombatPokemonIbfcProto;
                public static toObject(message: POGOProtos.Rpc.CombatProto.CombatPokemonIbfcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMinigameProto {
                minigame_end_ms?: (number|Long|null);
                minigame_submit_score_end_ms?: (number|Long|null);
                fly_in_completion_turn?: (number|null);
                fly_out_completion_turn?: (number|null);
                render_modifiers?: (POGOProtos.Rpc.IFormRenderModifier[]|null);
            }

            class MinigameProto implements IMinigameProto {
                constructor(properties?: POGOProtos.Rpc.CombatProto.IMinigameProto);
                public minigame_end_ms: (number|Long);
                public minigame_submit_score_end_ms: (number|Long);
                public fly_in_completion_turn: number;
                public fly_out_completion_turn: number;
                public render_modifiers: POGOProtos.Rpc.IFormRenderModifier[];
                public static encode(message: POGOProtos.Rpc.CombatProto.IMinigameProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatProto.MinigameProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatProto.MinigameProto;
                public static toObject(message: POGOProtos.Rpc.CombatProto.MinigameProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatPubSubData {
            message_sent?: (POGOProtos.Rpc.CombatPubSubData.MessageType|null);
        }

        class CombatPubSubData implements ICombatPubSubData {
            constructor(properties?: POGOProtos.Rpc.ICombatPubSubData);
            public message_sent: POGOProtos.Rpc.CombatPubSubData.MessageType;
            public static encode(message: POGOProtos.Rpc.ICombatPubSubData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatPubSubData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatPubSubData;
            public static toObject(message: POGOProtos.Rpc.CombatPubSubData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatPubSubData {

            enum MessageType {
                NO_TYPE = 0,
                END_NPC_COMBAT = 1,
                END_INVASION_COMBAT = 2,
                COMBAT_NOTIFY = 3,
                END_PVP_COMBAT = 4,
                VS_SEEKER_MATCH_STARTED = 5,
                COMBAT_CHARGE_ATTACK_ANIMATION_ACTIVE_CHANGE = 6,
                COMBAT_UPDATE_ACTION_UI = 7,
                COMBAT_EXIT_COMBAT_STATE = 8,
                COMBAT_SUPER_EFFECTIVE_CHARGED_ATTACKS_UPDATE = 9,
                COMBAT_STATE_ENTERED = 10,
                COMBAT_STATE_DONE = 11,
                COMBAT_STATE_EXITED = 12,
                COMBAT_INITIALIZE_PRESENTATION_DIRECTOR = 13,
                COMBAT_SHOW_UI = 14,
                COMBAT_HIDE_UI = 15,
                COMBAT_SHOW_MESSAGE = 16,
                COMBAT_SHOW_TOAST = 17,
                COMBAT_SHOW_TUTORIAL = 18,
                COMBAT_UPDATE_IS_SHOWING_CHARGE_ANIM = 19,
                COMBAT_PLAY_MINI_GAME = 20,
                COMBAT_CONTINUE_AFTER_MINI_GAME = 21,
                COMBAT_SHOW_SPECIAL_ATTACK = 22,
                COMBAT_SPECIAL_MOVE_STATE_ENDED = 23,
                COMBAT_CLEAN_UP_SPECIAL_MOVE_STATE = 24,
                COMBAT_HANDLE_SPECIAL_MOVE_CAMERA_ZOOM = 25,
                COMBAT_SHIELD_USED = 26,
                COMBAT_DEFENDER_FLINCH = 27,
                COMBAT_OPPONENT_REACT = 28,
                COMBAT_FOCUS_ON_POKEMON = 29,
                COMBAT_PLAY_START_FADE_TRANSITION = 30,
                COMBAT_PLAY_END_FADE_TRANSITION = 31,
                COMBAT_COUNTDOWN_STARTED = 32,
                COMBAT_PLAY_BACK_BUTTON_SFX = 33,
                COMBAT_SETUP_COMBAT_STAGE_SUBSCRIPTIONS = 34,
                COMBAT_OPPONENT_RETRIEVE_POKEMON = 35,
                COMBAT_HIDE_NAMEPLATE = 36,
                COMBAT_DISPLAY_PHYSICAL_SHIELD = 37,
                COMBAT_UPDATE_TIMER = 38,
                COMBAT_STOP_CHARGE_ATTACK_EFFECTS = 39,
                COMBAT_DEFENSIVE_MINI_GAME_DECIDED = 40,
                COMBAT_DEFENSIVE_MINI_GAME_SERVER_RESPONSE = 41,
                COMBAT_PAUSE_NOTIFY_COMBAT_POKEMON = 42
            }
        }

        interface ICombatQuestUpdateProto {
            super_effective_charged_attacks_update?: (number|null);
            fainted_opponent_pokemon?: (POGOProtos.Rpc.CombatQuestUpdateProto.ICombatQuestPokemonProto[]|null);
        }

        class CombatQuestUpdateProto implements ICombatQuestUpdateProto {
            constructor(properties?: POGOProtos.Rpc.ICombatQuestUpdateProto);
            public super_effective_charged_attacks_update: number;
            public fainted_opponent_pokemon: POGOProtos.Rpc.CombatQuestUpdateProto.ICombatQuestPokemonProto[];
            public static encode(message: POGOProtos.Rpc.ICombatQuestUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatQuestUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatQuestUpdateProto;
            public static toObject(message: POGOProtos.Rpc.CombatQuestUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatQuestUpdateProto {

            interface ICombatQuestPokemonProto {
                pokemon_id?: (number|Long|null);
                pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            }

            class CombatQuestPokemonProto implements ICombatQuestPokemonProto {
                constructor(properties?: POGOProtos.Rpc.CombatQuestUpdateProto.ICombatQuestPokemonProto);
                public pokemon_id: (number|Long);
                public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
                public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public static encode(message: POGOProtos.Rpc.CombatQuestUpdateProto.ICombatQuestPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatQuestUpdateProto.CombatQuestPokemonProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatQuestUpdateProto.CombatQuestPokemonProto;
                public static toObject(message: POGOProtos.Rpc.CombatQuestUpdateProto.CombatQuestPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatRankingSettingsProto {
            rank_level?: (POGOProtos.Rpc.CombatRankingSettingsProto.IRankLevelProto[]|null);
            required_for_rewards?: (POGOProtos.Rpc.CombatRankingSettingsProto.IRankLevelProto|null);
            min_rank_to_display_rating?: (number|null);
            season_number?: (number|null);
        }

        class CombatRankingSettingsProto implements ICombatRankingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatRankingSettingsProto);
            public rank_level: POGOProtos.Rpc.CombatRankingSettingsProto.IRankLevelProto[];
            public required_for_rewards?: (POGOProtos.Rpc.CombatRankingSettingsProto.IRankLevelProto|null);
            public min_rank_to_display_rating: number;
            public season_number: number;
            public static encode(message: POGOProtos.Rpc.ICombatRankingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatRankingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatRankingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatRankingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatRankingSettingsProto {

            interface IRankLevelProto {
                rank_level?: (number|null);
                additional_total_battles_required?: (number|null);
                additional_wins_required?: (number|null);
                min_rating_required?: (number|null);
            }

            class RankLevelProto implements IRankLevelProto {
                constructor(properties?: POGOProtos.Rpc.CombatRankingSettingsProto.IRankLevelProto);
                public rank_level: number;
                public additional_total_battles_required: number;
                public additional_wins_required: number;
                public min_rating_required: number;
                public static encode(message: POGOProtos.Rpc.CombatRankingSettingsProto.IRankLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatRankingSettingsProto.RankLevelProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatRankingSettingsProto.RankLevelProto;
                public static toObject(message: POGOProtos.Rpc.CombatRankingSettingsProto.RankLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICombatSeasonResult {
            season?: (number|null);
            rank?: (number|null);
            total_battles?: (number|null);
            total_wins?: (number|null);
            rating?: (number|null);
            longest_win_streak?: (number|null);
            current_streak?: (number|null);
            stardust_earned?: (number|Long|null);
        }

        class CombatSeasonResult implements ICombatSeasonResult {
            constructor(properties?: POGOProtos.Rpc.ICombatSeasonResult);
            public season: number;
            public rank: number;
            public total_battles: number;
            public total_wins: number;
            public rating: number;
            public longest_win_streak: number;
            public current_streak: number;
            public stardust_earned: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICombatSeasonResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSeasonResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSeasonResult;
            public static toObject(message: POGOProtos.Rpc.CombatSeasonResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatSettingsProto {
            round_duration_seconds?: (number|null);
            turn_duration_seconds?: (number|null);
            minigame_duration_seconds?: (number|null);
            same_type_attack_bonus_multiplier?: (number|null);
            fast_attack_bonus_multiplier?: (number|null);
            charge_attack_bonus_multiplier?: (number|null);
            defense_bonus_multiplier?: (number|null);
            minigame_bonus_base_multiplier?: (number|null);
            minigame_bonus_variable_multiplier?: (number|null);
            max_energy?: (number|null);
            defender_minigame_multiplier?: (number|null);
            change_pokemon_duration_seconds?: (number|null);
            minigame_submit_score_duration_seconds?: (number|null);
            quick_swap_combat_start_available_seconds?: (number|null);
            quick_swap_cooldown_duration_seconds?: (number|null);
            offensive_input_challenge_settings?: (POGOProtos.Rpc.ICombatOffensiveInputChallengeSettings|null);
            defensive_input_challenge_settings?: (POGOProtos.Rpc.ICombatDefensiveInputChallengeSettings|null);
            charge_score_base?: (number|null);
            charge_score_nice?: (number|null);
            charge_score_great?: (number|null);
            charge_score_excellent?: (number|null);
            swap_animation_duration_turns?: (number|null);
            super_effective_flyout_duration_turns?: (number|null);
            not_very_effective_flyout_duration_turns?: (number|null);
            blocked_flyout_duration_turns?: (number|null);
            normal_effective_flyout_duration_turns?: (number|null);
            faint_animation_duration_turns?: (number|null);
            npc_swap_delay_turns?: (number|null);
            npc_charged_attack_delay_turns?: (number|null);
            shadow_pokemon_attack_bonus_multiplier?: (number|null);
            shadow_pokemon_defense_bonus_multiplier?: (number|null);
            purified_pokemon_attack_multiplier_vs_shadow?: (number|null);
            combat_experiment?: (POGOProtos.Rpc.CombatExperiment[]|null);
            show_quick_swap_buttons_during_countdown?: (boolean|null);
            ob_int32_1?: (number|null);
            clock_sync_settings?: (POGOProtos.Rpc.ICombatClockSynchronization|null);
            combat_feature_flags?: (POGOProtos.Rpc.ICombatFeatureFlags|null);
            flyin_duration_turns?: (number|null);
        }

        class CombatSettingsProto implements ICombatSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatSettingsProto);
            public round_duration_seconds: number;
            public turn_duration_seconds: number;
            public minigame_duration_seconds: number;
            public same_type_attack_bonus_multiplier: number;
            public fast_attack_bonus_multiplier: number;
            public charge_attack_bonus_multiplier: number;
            public defense_bonus_multiplier: number;
            public minigame_bonus_base_multiplier: number;
            public minigame_bonus_variable_multiplier: number;
            public max_energy: number;
            public defender_minigame_multiplier: number;
            public change_pokemon_duration_seconds: number;
            public minigame_submit_score_duration_seconds: number;
            public quick_swap_combat_start_available_seconds: number;
            public quick_swap_cooldown_duration_seconds: number;
            public offensive_input_challenge_settings?: (POGOProtos.Rpc.ICombatOffensiveInputChallengeSettings|null);
            public defensive_input_challenge_settings?: (POGOProtos.Rpc.ICombatDefensiveInputChallengeSettings|null);
            public charge_score_base: number;
            public charge_score_nice: number;
            public charge_score_great: number;
            public charge_score_excellent: number;
            public swap_animation_duration_turns: number;
            public super_effective_flyout_duration_turns: number;
            public not_very_effective_flyout_duration_turns: number;
            public blocked_flyout_duration_turns: number;
            public normal_effective_flyout_duration_turns: number;
            public faint_animation_duration_turns: number;
            public npc_swap_delay_turns: number;
            public npc_charged_attack_delay_turns: number;
            public shadow_pokemon_attack_bonus_multiplier: number;
            public shadow_pokemon_defense_bonus_multiplier: number;
            public purified_pokemon_attack_multiplier_vs_shadow: number;
            public combat_experiment: POGOProtos.Rpc.CombatExperiment[];
            public show_quick_swap_buttons_during_countdown: boolean;
            public ob_int32_1: number;
            public clock_sync_settings?: (POGOProtos.Rpc.ICombatClockSynchronization|null);
            public combat_feature_flags?: (POGOProtos.Rpc.ICombatFeatureFlags|null);
            public flyin_duration_turns: number;
            public static encode(message: POGOProtos.Rpc.ICombatSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatSpecialMovePlayerData {
            player?: (POGOProtos.Rpc.ICombatSpecialMovePlayerLogProto|null);
            opponent?: (POGOProtos.Rpc.ICombatSpecialMovePlayerLogProto|null);
            combat_id?: (string|null);
        }

        class CombatSpecialMovePlayerData implements ICombatSpecialMovePlayerData {
            constructor(properties?: POGOProtos.Rpc.ICombatSpecialMovePlayerData);
            public player?: (POGOProtos.Rpc.ICombatSpecialMovePlayerLogProto|null);
            public opponent?: (POGOProtos.Rpc.ICombatSpecialMovePlayerLogProto|null);
            public combat_id: string;
            public static encode(message: POGOProtos.Rpc.ICombatSpecialMovePlayerData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSpecialMovePlayerData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSpecialMovePlayerData;
            public static toObject(message: POGOProtos.Rpc.CombatSpecialMovePlayerData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatSpecialMovePlayerLogProto {
            active_pokemon_id?: (number|null);
            reserve_pokemon_id?: (number[]|null);
            fainted_pokemon_id?: (number[]|null);
            current_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            last_updated_turn?: (number|null);
            minigame_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            minigame_defense_chances_left?: (number|null);
        }

        class CombatSpecialMovePlayerLogProto implements ICombatSpecialMovePlayerLogProto {
            constructor(properties?: POGOProtos.Rpc.ICombatSpecialMovePlayerLogProto);
            public active_pokemon_id: number;
            public reserve_pokemon_id: number[];
            public fainted_pokemon_id: number[];
            public current_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            public last_updated_turn: number;
            public minigame_action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            public minigame_defense_chances_left: number;
            public static encode(message: POGOProtos.Rpc.ICombatSpecialMovePlayerLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSpecialMovePlayerLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSpecialMovePlayerLogProto;
            public static toObject(message: POGOProtos.Rpc.CombatSpecialMovePlayerLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatStatStageSettingsProto {
            minimum_stat_stage?: (number|null);
            maximum_stat_stage?: (number|null);
            attack_buff_multiplier?: (number[]|null);
            defense_buff_multiplier?: (number[]|null);
        }

        class CombatStatStageSettingsProto implements ICombatStatStageSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICombatStatStageSettingsProto);
            public minimum_stat_stage: number;
            public maximum_stat_stage: number;
            public attack_buff_multiplier: number[];
            public defense_buff_multiplier: number[];
            public static encode(message: POGOProtos.Rpc.ICombatStatStageSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatStatStageSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatStatStageSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CombatStatStageSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatSyncServerData {
            rpc_id?: (number|null);
        }

        class CombatSyncServerData implements ICombatSyncServerData {
            constructor(properties?: POGOProtos.Rpc.ICombatSyncServerData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ICombatSyncServerData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSyncServerData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSyncServerData;
            public static toObject(message: POGOProtos.Rpc.CombatSyncServerData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatSyncServerOffsetOutProto {
            server_time_ms?: (number|Long|null);
            result?: (POGOProtos.Rpc.CombatSyncServerOffsetOutProto.Result|null);
        }

        class CombatSyncServerOffsetOutProto implements ICombatSyncServerOffsetOutProto {
            constructor(properties?: POGOProtos.Rpc.ICombatSyncServerOffsetOutProto);
            public server_time_ms: (number|Long);
            public result: POGOProtos.Rpc.CombatSyncServerOffsetOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICombatSyncServerOffsetOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSyncServerOffsetOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSyncServerOffsetOutProto;
            public static toObject(message: POGOProtos.Rpc.CombatSyncServerOffsetOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CombatSyncServerOffsetOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface ICombatSyncServerOffsetProto {
        }

        class CombatSyncServerOffsetProto implements ICombatSyncServerOffsetProto {
            constructor(properties?: POGOProtos.Rpc.ICombatSyncServerOffsetProto);
            public static encode(message: POGOProtos.Rpc.ICombatSyncServerOffsetProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSyncServerOffsetProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSyncServerOffsetProto;
            public static toObject(message: POGOProtos.Rpc.CombatSyncServerOffsetProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatSyncServerResponseData {
            rpc_id?: (number|null);
            result?: (POGOProtos.Rpc.CombatSyncServerOffsetOutProto.Result|null);
            server_time_offset_ms?: (number|null);
        }

        class CombatSyncServerResponseData implements ICombatSyncServerResponseData {
            constructor(properties?: POGOProtos.Rpc.ICombatSyncServerResponseData);
            public rpc_id: number;
            public result: POGOProtos.Rpc.CombatSyncServerOffsetOutProto.Result;
            public server_time_offset_ms: number;
            public static encode(message: POGOProtos.Rpc.ICombatSyncServerResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatSyncServerResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatSyncServerResponseData;
            public static toObject(message: POGOProtos.Rpc.CombatSyncServerResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICombatTypeProto {
            type?: (POGOProtos.Rpc.HoloPokemonType|null);
            nice_level_threshold?: (number|null);
            great_level_threshold?: (number|null);
            excellent_level_threshold?: (number|null);
        }

        class CombatTypeProto implements ICombatTypeProto {
            constructor(properties?: POGOProtos.Rpc.ICombatTypeProto);
            public type: POGOProtos.Rpc.HoloPokemonType;
            public nice_level_threshold: number;
            public great_level_threshold: number;
            public excellent_level_threshold: number;
            public static encode(message: POGOProtos.Rpc.ICombatTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CombatTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CombatTypeProto;
            public static toObject(message: POGOProtos.Rpc.CombatTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICommonMarketingTelemetryMetadata {
            event_timestamp_ms?: (number|Long|null);
            environment_id?: (string|null);
            environment_project_id?: (string|null);
            campaign_experiment_id?: (number|Long|null);
            treatment_group?: (string|null);
            local_send_time?: (string|null);
            campaign_experiment_ids?: ((number|Long)[]|null);
        }

        class CommonMarketingTelemetryMetadata implements ICommonMarketingTelemetryMetadata {
            constructor(properties?: POGOProtos.Rpc.ICommonMarketingTelemetryMetadata);
            public event_timestamp_ms: (number|Long);
            public environment_id: string;
            public environment_project_id: string;
            public campaign_experiment_id: (number|Long);
            public treatment_group: string;
            public local_send_time: string;
            public campaign_experiment_ids: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.ICommonMarketingTelemetryMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonMarketingTelemetryMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonMarketingTelemetryMetadata;
            public static toObject(message: POGOProtos.Rpc.CommonMarketingTelemetryMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICommonTelemetryBootTime {
            boot_phase?: (string|null);
            duration_ms?: (number|Long|null);
        }

        class CommonTelemetryBootTime implements ICommonTelemetryBootTime {
            constructor(properties?: POGOProtos.Rpc.ICommonTelemetryBootTime);
            public boot_phase: string;
            public duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICommonTelemetryBootTime, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonTelemetryBootTime;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonTelemetryBootTime;
            public static toObject(message: POGOProtos.Rpc.CommonTelemetryBootTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICommonTelemetryLogIn {
            timestamp_ms?: (number|Long|null);
            pre_login_user_id?: (string|null);
        }

        class CommonTelemetryLogIn implements ICommonTelemetryLogIn {
            constructor(properties?: POGOProtos.Rpc.ICommonTelemetryLogIn);
            public timestamp_ms: (number|Long);
            public pre_login_user_id: string;
            public static encode(message: POGOProtos.Rpc.ICommonTelemetryLogIn, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonTelemetryLogIn;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonTelemetryLogIn;
            public static toObject(message: POGOProtos.Rpc.CommonTelemetryLogIn, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICommonTelemetryLogOut {
            timestamp_ms?: (number|Long|null);
        }

        class CommonTelemetryLogOut implements ICommonTelemetryLogOut {
            constructor(properties?: POGOProtos.Rpc.ICommonTelemetryLogOut);
            public timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICommonTelemetryLogOut, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonTelemetryLogOut;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonTelemetryLogOut;
            public static toObject(message: POGOProtos.Rpc.CommonTelemetryLogOut, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICommonTelemetryShopClick {
            shopping_page_click_id?: (string|null);
            sku_id?: (string|null);
            item_id?: (string|null);
            consolidated_item_id?: (string|null);
            currency?: (string|null);
            fiat_price?: (number|Long|null);
            in_game_purchase_details?: (POGOProtos.Rpc.IInGamePurchaseDetails[]|null);
            is_item_free_fiat?: (boolean|null);
            is_item_free_ingame?: (boolean|null);
            time_elapsed_since_enter_page?: (number|Long|null);
            root_store_page_session_id?: (string|null);
            pair_id?: (number|Long|null);
            store_page_name?: (string|null);
            root_store_page_name?: (string|null);
            access_type?: (POGOProtos.Rpc.CommonTelemetryShopClick.AccessType|null);
            fiat_formatted_price?: (string|null);
        }

        class CommonTelemetryShopClick implements ICommonTelemetryShopClick {
            constructor(properties?: POGOProtos.Rpc.ICommonTelemetryShopClick);
            public shopping_page_click_id: string;
            public sku_id: string;
            public item_id: string;
            public consolidated_item_id: string;
            public currency: string;
            public fiat_price: (number|Long);
            public in_game_purchase_details: POGOProtos.Rpc.IInGamePurchaseDetails[];
            public is_item_free_fiat: boolean;
            public is_item_free_ingame: boolean;
            public time_elapsed_since_enter_page: (number|Long);
            public root_store_page_session_id: string;
            public pair_id: (number|Long);
            public store_page_name: string;
            public root_store_page_name: string;
            public access_type: POGOProtos.Rpc.CommonTelemetryShopClick.AccessType;
            public fiat_formatted_price: string;
            public static encode(message: POGOProtos.Rpc.ICommonTelemetryShopClick, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonTelemetryShopClick;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonTelemetryShopClick;
            public static toObject(message: POGOProtos.Rpc.CommonTelemetryShopClick, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CommonTelemetryShopClick {

            enum AccessType {
                UNSPECIFIED = 0,
                PASSIVE = 1,
                ACTIVE = 2
            }
        }

        interface ICommonTelemetryShopView {
            shopping_page_view_type_id?: (string|null);
            view_start_timestamp_ms?: (number|Long|null);
            view_end_timestamp_ms?: (number|Long|null);
            consolidated_item_id?: (string[]|null);
            root_store_page_session_id?: (string|null);
        }

        class CommonTelemetryShopView implements ICommonTelemetryShopView {
            constructor(properties?: POGOProtos.Rpc.ICommonTelemetryShopView);
            public shopping_page_view_type_id: string;
            public view_start_timestamp_ms: (number|Long);
            public view_end_timestamp_ms: (number|Long);
            public consolidated_item_id: string[];
            public root_store_page_session_id: string;
            public static encode(message: POGOProtos.Rpc.ICommonTelemetryShopView, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonTelemetryShopView;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonTelemetryShopView;
            public static toObject(message: POGOProtos.Rpc.CommonTelemetryShopView, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICommonTempEvoSettingsProto {
            evolution_length_ms?: (number|Long|null);
            enable_temp_evo_level?: (boolean|null);
            num_temp_evo_levels?: (number|null);
            enable_buddy_walking_temp_evo_energy_award?: (boolean|null);
            client_mega_cooldown_buffer_ms?: (number|null);
        }

        class CommonTempEvoSettingsProto implements ICommonTempEvoSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICommonTempEvoSettingsProto);
            public evolution_length_ms: (number|Long);
            public enable_temp_evo_level: boolean;
            public num_temp_evo_levels: number;
            public enable_buddy_walking_temp_evo_energy_award: boolean;
            public client_mega_cooldown_buffer_ms: number;
            public static encode(message: POGOProtos.Rpc.ICommonTempEvoSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CommonTempEvoSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CommonTempEvoSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CommonTempEvoSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompareAndSwapRequest {
            key?: (POGOProtos.Rpc.IKey|null);
            value?: (POGOProtos.Rpc.IVersionedValue|null);
        }

        class CompareAndSwapRequest implements ICompareAndSwapRequest {
            constructor(properties?: POGOProtos.Rpc.ICompareAndSwapRequest);
            public key?: (POGOProtos.Rpc.IKey|null);
            public value?: (POGOProtos.Rpc.IVersionedValue|null);
            public static encode(message: POGOProtos.Rpc.ICompareAndSwapRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompareAndSwapRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompareAndSwapRequest;
            public static toObject(message: POGOProtos.Rpc.CompareAndSwapRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompareAndSwapResponse {
            updated?: (boolean|null);
            value?: (POGOProtos.Rpc.IVersionedValue|null);
        }

        class CompareAndSwapResponse implements ICompareAndSwapResponse {
            constructor(properties?: POGOProtos.Rpc.ICompareAndSwapResponse);
            public updated: boolean;
            public value?: (POGOProtos.Rpc.IVersionedValue|null);
            public static encode(message: POGOProtos.Rpc.ICompareAndSwapResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompareAndSwapResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompareAndSwapResponse;
            public static toObject(message: POGOProtos.Rpc.CompareAndSwapResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteBreadBattleOutProto {
            result?: (POGOProtos.Rpc.CompleteBreadBattleOutProto.Result|null);
            battle_results?: (POGOProtos.Rpc.IBreadBattleResultsProto|null);
            is_victory?: (boolean|null);
            upgrade_loot_claimed?: (boolean|null);
            active_item?: (POGOProtos.Rpc.Item|null);
        }

        class CompleteBreadBattleOutProto implements ICompleteBreadBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteBreadBattleOutProto);
            public result: POGOProtos.Rpc.CompleteBreadBattleOutProto.Result;
            public battle_results?: (POGOProtos.Rpc.IBreadBattleResultsProto|null);
            public is_victory: boolean;
            public upgrade_loot_claimed: boolean;
            public active_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.ICompleteBreadBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteBreadBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteBreadBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteBreadBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteBreadBattleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BATTLE_NOT_FOUND = 2,
                ERROR_BATTLE_NOT_COMPLETED = 3,
                ERROR_SERVER_FAILURE = 4
            }
        }

        interface ICompleteBreadBattleProto {
            station_id?: (string|null);
            bread_battle_id?: (string|null);
        }

        class CompleteBreadBattleProto implements ICompleteBreadBattleProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteBreadBattleProto);
            public station_id: string;
            public bread_battle_id: string;
            public static encode(message: POGOProtos.Rpc.ICompleteBreadBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteBreadBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteBreadBattleProto;
            public static toObject(message: POGOProtos.Rpc.CompleteBreadBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteCompetitiveSeasonOutProto {
            result?: (POGOProtos.Rpc.CompleteCompetitiveSeasonOutProto.Result|null);
            loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            new_rank?: (number|null);
            new_rating?: (number|null);
            last_season_result?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            was_player_active?: (boolean|null);
        }

        class CompleteCompetitiveSeasonOutProto implements ICompleteCompetitiveSeasonOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteCompetitiveSeasonOutProto);
            public result: POGOProtos.Rpc.CompleteCompetitiveSeasonOutProto.Result;
            public loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            public new_rank: number;
            public new_rating: number;
            public last_season_result?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            public was_player_active: boolean;
            public static encode(message: POGOProtos.Rpc.ICompleteCompetitiveSeasonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteCompetitiveSeasonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteCompetitiveSeasonOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteCompetitiveSeasonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteCompetitiveSeasonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_HAS_NO_VS_SEEKER = 2,
                ERROR_REWARDS_ALREADY_COLLECTED = 3
            }
        }

        interface ICompleteCompetitiveSeasonProto {
        }

        class CompleteCompetitiveSeasonProto implements ICompleteCompetitiveSeasonProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteCompetitiveSeasonProto);
            public static encode(message: POGOProtos.Rpc.ICompleteCompetitiveSeasonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteCompetitiveSeasonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteCompetitiveSeasonProto;
            public static toObject(message: POGOProtos.Rpc.CompleteCompetitiveSeasonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteInvasionDialogueOutProto {
            status?: (POGOProtos.Rpc.InvasionStatus.Status|null);
            granted_loot?: (POGOProtos.Rpc.ILootProto|null);
        }

        class CompleteInvasionDialogueOutProto implements ICompleteInvasionDialogueOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteInvasionDialogueOutProto);
            public status: POGOProtos.Rpc.InvasionStatus.Status;
            public granted_loot?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.ICompleteInvasionDialogueOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteInvasionDialogueOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteInvasionDialogueOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteInvasionDialogueOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteInvasionDialogueProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            step?: (number|null);
        }

        class CompleteInvasionDialogueProto implements ICompleteInvasionDialogueProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteInvasionDialogueProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public step: number;
            public static encode(message: POGOProtos.Rpc.ICompleteInvasionDialogueProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteInvasionDialogueProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteInvasionDialogueProto;
            public static toObject(message: POGOProtos.Rpc.CompleteInvasionDialogueProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteMilestoneOutProto {
            status?: (POGOProtos.Rpc.CompleteMilestoneOutProto.Status|null);
        }

        class CompleteMilestoneOutProto implements ICompleteMilestoneOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteMilestoneOutProto);
            public status: POGOProtos.Rpc.CompleteMilestoneOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ICompleteMilestoneOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteMilestoneOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteMilestoneOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteMilestoneOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteMilestoneOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2,
                ERROR_MILESTONE_NOT_FOUND = 3,
                ERROR_MILESTONE_COMPLETE = 4,
                ERROR_MILESTONE_NOT_ACHIEVED = 5,
                ERROR_POKEMON_INVENTORY_FULL = 6
            }
        }

        interface ICompleteMilestoneProto {
            milestone_id?: (string|null);
        }

        class CompleteMilestoneProto implements ICompleteMilestoneProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteMilestoneProto);
            public milestone_id: string;
            public static encode(message: POGOProtos.Rpc.ICompleteMilestoneProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteMilestoneProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteMilestoneProto;
            public static toObject(message: POGOProtos.Rpc.CompleteMilestoneProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompletePartyQuestOutProto {
            result?: (POGOProtos.Rpc.CompletePartyQuestOutProto.Result|null);
            claimed_quest?: (POGOProtos.Rpc.IPartyQuestStateProto|null);
            updated_party_quest?: (POGOProtos.Rpc.IPartyQuestRpcProto|null);
        }

        class CompletePartyQuestOutProto implements ICompletePartyQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompletePartyQuestOutProto);
            public result: POGOProtos.Rpc.CompletePartyQuestOutProto.Result;
            public claimed_quest?: (POGOProtos.Rpc.IPartyQuestStateProto|null);
            public updated_party_quest?: (POGOProtos.Rpc.IPartyQuestRpcProto|null);
            public static encode(message: POGOProtos.Rpc.ICompletePartyQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompletePartyQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompletePartyQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.CompletePartyQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompletePartyQuestOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                ERROR_FEATURE_DISABLED = 2,
                ERROR_PLAYER_NOT_IN_PARTY = 3,
                ERROR_PARTY_NOT_FOUND = 4,
                ERROR_PARTY_STATUS_INVALID = 5,
                ERROR_QUEST_NOT_FOUND = 6,
                ERROR_QUEST_STILL_IN_PROGRESS = 7,
                ERROR_PLAYER_STATE_NOT_FOUND = 9,
                ERROR_PLAYER_ALREADY_AWARDED = 10,
                ERROR_REWARD_ITEM_REACH_LIMIT = 11,
                SUCCESS = 12,
                ERROR_PLFE_REDIRECT_NEEDED = 13
            }
        }

        interface ICompletePartyQuestProto {
            unclaimed_quest_id?: (string|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
        }

        class CompletePartyQuestProto implements ICompletePartyQuestProto {
            constructor(properties?: POGOProtos.Rpc.ICompletePartyQuestProto);
            public unclaimed_quest_id: string;
            public party_type: POGOProtos.Rpc.PartyType;
            public static encode(message: POGOProtos.Rpc.ICompletePartyQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompletePartyQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompletePartyQuestProto;
            public static toObject(message: POGOProtos.Rpc.CompletePartyQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteQuestLogEntry {
            result?: (POGOProtos.Rpc.CompleteQuestLogEntry.Result|null);
            quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            stamp?: (POGOProtos.Rpc.IQuestStampProto[]|null);
        }

        class CompleteQuestLogEntry implements ICompleteQuestLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestLogEntry);
            public result: POGOProtos.Rpc.CompleteQuestLogEntry.Result;
            public quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            public stamp: POGOProtos.Rpc.IQuestStampProto[];
            public static encode(message: POGOProtos.Rpc.ICompleteQuestLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestLogEntry;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteQuestLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ICompleteQuestOutProto {
            status?: (POGOProtos.Rpc.CompleteQuestOutProto.Status|null);
            quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            stamp?: (POGOProtos.Rpc.IQuestStampProto[]|null);
            party_quest_candidates?: (POGOProtos.Rpc.IClientQuestProto[]|null);
        }

        class CompleteQuestOutProto implements ICompleteQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestOutProto);
            public status: POGOProtos.Rpc.CompleteQuestOutProto.Status;
            public quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            public stamp: POGOProtos.Rpc.IQuestStampProto[];
            public party_quest_candidates: POGOProtos.Rpc.IClientQuestProto[];
            public static encode(message: POGOProtos.Rpc.ICompleteQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteQuestOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_QUEST_NOT_FOUND = 2,
                ERROR_QUEST_STILL_IN_PROGRESS = 3,
                ERROR_QUEST_ALREADY_COMPLETED = 4,
                ERROR_SUBQUEST_NOT_FOUND = 5,
                ERROR_SUBQUEST_STILL_IN_PROGRESS = 6,
                ERROR_SUBQUEST_ALREADY_COMPLETED = 7,
                ERROR_MULTIPART_STILL_IN_PROGRESS = 8,
                ERROR_MULTIPART_ALREADY_COMPLETED = 9,
                ERROR_REDEEM_COMPLETED_QUEST_STAMP_CARD_FIRST = 10,
                ERROR_INVENTORY_FULL = 11,
                ERROR_INVALID_BRANCH = 12,
                ERROR_REWARD_ITEM_REACH_LIMIT = 13,
                SUCCESS_PARTY_QUEST_CONCLUDED = 14,
                ERROR_PARTY_QUEST_CLAIM_REWARDS_DEADLINE_EXCEEDED = 15,
                SUCCESS_PARTY_QUEST_FORCE_CONCLUDED = 16,
                SUCCESS_PARTY_QUEST_FORCE_CONCLUDE_IGNORED = 17,
                ERROR_PARTY_QUEST_FORCE_CONCLUDE_STILL_AWARDING = 18,
                ERROR_PARTY_QUEST_FORCE_CONCLUDE_ALREADY_CONCLUDED = 19,
                ERROR_CURRENT_TIME_LT_MIN_COMPLETE_TIME = 20,
                ERROR_MP_DAILY_CAP_REACHED = 21
            }
        }

        interface ICompleteQuestPokemonEncounterLogEntry {
            result?: (POGOProtos.Rpc.CompleteQuestPokemonEncounterLogEntry.Result|null);
            pokedex_number?: (number|null);
            combat_points?: (number|null);
            pokemon_id?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            encounter_type?: (POGOProtos.Rpc.EncounterType|null);
        }

        class CompleteQuestPokemonEncounterLogEntry implements ICompleteQuestPokemonEncounterLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestPokemonEncounterLogEntry);
            public result: POGOProtos.Rpc.CompleteQuestPokemonEncounterLogEntry.Result;
            public pokedex_number: number;
            public combat_points: number;
            public pokemon_id: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public encounter_type: POGOProtos.Rpc.EncounterType;
            public static encode(message: POGOProtos.Rpc.ICompleteQuestPokemonEncounterLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestPokemonEncounterLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestPokemonEncounterLogEntry;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestPokemonEncounterLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteQuestPokemonEncounterLogEntry {

            enum Result {
                UNSET = 0,
                POKEMON_CAPTURED = 1,
                POKEMON_FLED = 2
            }
        }

        interface ICompleteQuestProto {
            quest_id?: (string|null);
            sub_quest_id?: (string|null);
            choice_id?: (number|null);
            force_conclude_party_quest?: (boolean|null);
            pokemon_id?: (number|Long|null);
        }

        class CompleteQuestProto implements ICompleteQuestProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestProto);
            public quest_id: string;
            public sub_quest_id: string;
            public choice_id: number;
            public force_conclude_party_quest: boolean;
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICompleteQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestProto;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteQuestStampCardLogEntry {
            result?: (POGOProtos.Rpc.CompleteQuestStampCardLogEntry.Result|null);
            reward?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class CompleteQuestStampCardLogEntry implements ICompleteQuestStampCardLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestStampCardLogEntry);
            public result: POGOProtos.Rpc.CompleteQuestStampCardLogEntry.Result;
            public reward: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.ICompleteQuestStampCardLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestStampCardLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestStampCardLogEntry;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestStampCardLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteQuestStampCardLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ICompleteQuestStampCardOutProto {
            status?: (POGOProtos.Rpc.CompleteQuestStampCardOutProto.Status|null);
            reward?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class CompleteQuestStampCardOutProto implements ICompleteQuestStampCardOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestStampCardOutProto);
            public status: POGOProtos.Rpc.CompleteQuestStampCardOutProto.Status;
            public reward: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.ICompleteQuestStampCardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestStampCardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestStampCardOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestStampCardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteQuestStampCardOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_STILL_IN_PROGRESS = 2
            }
        }

        interface ICompleteQuestStampCardProto {
        }

        class CompleteQuestStampCardProto implements ICompleteQuestStampCardProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteQuestStampCardProto);
            public static encode(message: POGOProtos.Rpc.ICompleteQuestStampCardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteQuestStampCardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteQuestStampCardProto;
            public static toObject(message: POGOProtos.Rpc.CompleteQuestStampCardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteRaidBattleOutProto {
            result?: (POGOProtos.Rpc.CompleteRaidBattleOutProto.Result|null);
            battle_results?: (POGOProtos.Rpc.IBattleResultsProto|null);
            is_victory?: (boolean|null);
        }

        class CompleteRaidBattleOutProto implements ICompleteRaidBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteRaidBattleOutProto);
            public result: POGOProtos.Rpc.CompleteRaidBattleOutProto.Result;
            public battle_results?: (POGOProtos.Rpc.IBattleResultsProto|null);
            public is_victory: boolean;
            public static encode(message: POGOProtos.Rpc.ICompleteRaidBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteRaidBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteRaidBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteRaidBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteRaidBattleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BATTLE_NOT_FOUND = 2,
                ERROR_BATTLE_NOT_COMPLETED = 3,
                ERROR_SERVER_FAILURE = 4,
                ERROR_NOT_RVN = 5,
                ERROR_BATTLE_NOT_RAID = 6
            }
        }

        interface ICompleteRaidBattleProto {
            gym_id?: (string|null);
            battle_id?: (string|null);
        }

        class CompleteRaidBattleProto implements ICompleteRaidBattleProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteRaidBattleProto);
            public gym_id: string;
            public battle_id: string;
            public static encode(message: POGOProtos.Rpc.ICompleteRaidBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteRaidBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteRaidBattleProto;
            public static toObject(message: POGOProtos.Rpc.CompleteRaidBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteReferralMilestoneLogEntry {
            milestone_completed?: (POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.IMilestoneLogEntryProto|null);
            reward?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class CompleteReferralMilestoneLogEntry implements ICompleteReferralMilestoneLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICompleteReferralMilestoneLogEntry);
            public milestone_completed?: (POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.IMilestoneLogEntryProto|null);
            public reward: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.ICompleteReferralMilestoneLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteReferralMilestoneLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteReferralMilestoneLogEntry;
            public static toObject(message: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteReferralMilestoneLogEntry {

            interface IMilestoneLogEntryProto {
                name_key?: (string|null);
                name_template_variable?: (POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.ITemplateVariableProto[]|null);
            }

            class MilestoneLogEntryProto implements IMilestoneLogEntryProto {
                constructor(properties?: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.IMilestoneLogEntryProto);
                public name_key: string;
                public name_template_variable: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.ITemplateVariableProto[];
                public static encode(message: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.IMilestoneLogEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.MilestoneLogEntryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.MilestoneLogEntryProto;
                public static toObject(message: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.MilestoneLogEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITemplateVariableProto {
                name?: (string|null);
                literal?: (string|null);
            }

            class TemplateVariableProto implements ITemplateVariableProto {
                constructor(properties?: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.ITemplateVariableProto);
                public name: string;
                public literal: string;
                public static encode(message: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.ITemplateVariableProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.TemplateVariableProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.TemplateVariableProto;
                public static toObject(message: POGOProtos.Rpc.CompleteReferralMilestoneLogEntry.TemplateVariableProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ICompleteRoutePlayLogEntry {
            badge_level?: (POGOProtos.Rpc.RouteBadgeLevel.BadgeLevel|null);
            route_image_url?: (string|null);
            awarded_items?: (POGOProtos.Rpc.ILootProto|null);
            bonus_awarded_items?: (POGOProtos.Rpc.ILootProto|null);
            route_name?: (string|null);
            route_visuals?: (POGOProtos.Rpc.IRouteImageProto|null);
        }

        class CompleteRoutePlayLogEntry implements ICompleteRoutePlayLogEntry {
            constructor(properties?: POGOProtos.Rpc.ICompleteRoutePlayLogEntry);
            public badge_level: POGOProtos.Rpc.RouteBadgeLevel.BadgeLevel;
            public route_image_url: string;
            public awarded_items?: (POGOProtos.Rpc.ILootProto|null);
            public bonus_awarded_items?: (POGOProtos.Rpc.ILootProto|null);
            public route_name: string;
            public route_visuals?: (POGOProtos.Rpc.IRouteImageProto|null);
            public static encode(message: POGOProtos.Rpc.ICompleteRoutePlayLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteRoutePlayLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteRoutePlayLogEntry;
            public static toObject(message: POGOProtos.Rpc.CompleteRoutePlayLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteSnapshotSessionOutProto {
            status?: (POGOProtos.Rpc.CompleteSnapshotSessionOutProto.Status|null);
        }

        class CompleteSnapshotSessionOutProto implements ICompleteSnapshotSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteSnapshotSessionOutProto);
            public status: POGOProtos.Rpc.CompleteSnapshotSessionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ICompleteSnapshotSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteSnapshotSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteSnapshotSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteSnapshotSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteSnapshotSessionOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PHOTO_POKEMON_INVALID = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface ICompleteSnapshotSessionProto {
            photo_pokemon_id?: (number|Long|null);
            num_photos_taken?: (number|null);
            snapshot_session_start_time?: (number|Long|null);
        }

        class CompleteSnapshotSessionProto implements ICompleteSnapshotSessionProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteSnapshotSessionProto);
            public photo_pokemon_id: (number|Long);
            public num_photos_taken: number;
            public snapshot_session_start_time: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICompleteSnapshotSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteSnapshotSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteSnapshotSessionProto;
            public static toObject(message: POGOProtos.Rpc.CompleteSnapshotSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteVisitPageQuestOutProto {
            status?: (POGOProtos.Rpc.CompleteVisitPageQuestOutProto.Status|null);
        }

        class CompleteVisitPageQuestOutProto implements ICompleteVisitPageQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteVisitPageQuestOutProto);
            public status: POGOProtos.Rpc.CompleteVisitPageQuestOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ICompleteVisitPageQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteVisitPageQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteVisitPageQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteVisitPageQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteVisitPageQuestOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAIL = 2
            }
        }

        interface ICompleteVisitPageQuestProto {
            page_type?: (POGOProtos.Rpc.PageType|null);
        }

        class CompleteVisitPageQuestProto implements ICompleteVisitPageQuestProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteVisitPageQuestProto);
            public page_type: POGOProtos.Rpc.PageType;
            public static encode(message: POGOProtos.Rpc.ICompleteVisitPageQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteVisitPageQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteVisitPageQuestProto;
            public static toObject(message: POGOProtos.Rpc.CompleteVisitPageQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteVsSeekerAndRestartChargingOutProto {
            result?: (POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingOutProto.Result|null);
            vs_seeker?: (POGOProtos.Rpc.IVsSeekerAttributesProto|null);
            loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            current_season_result?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            previous_rank?: (number|null);
            previous_rating?: (number|null);
            stats_at_rank_start?: (POGOProtos.Rpc.ICombatBaseStatsProto|null);
            avatar_template_id_rewarded?: (string[]|null);
        }

        class CompleteVsSeekerAndRestartChargingOutProto implements ICompleteVsSeekerAndRestartChargingOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingOutProto);
            public result: POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingOutProto.Result;
            public vs_seeker?: (POGOProtos.Rpc.IVsSeekerAttributesProto|null);
            public loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            public current_season_result?: (POGOProtos.Rpc.ICombatSeasonResult|null);
            public previous_rank: number;
            public previous_rating: number;
            public stats_at_rank_start?: (POGOProtos.Rpc.ICombatBaseStatsProto|null);
            public avatar_template_id_rewarded: string[];
            public static encode(message: POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteVsSeekerAndRestartChargingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_VS_SEEKER_NOT_FOUND = 2,
                ERROR_VS_SEEKER_ALREADY_STARTED_CHARGING = 3,
                ERROR_VS_SEEKER_ALREADY_FULLY_CHARGED = 4,
                ERROR_VS_SEEKER_PLAYER_IN_WRONG_SEASON = 5,
                ERROR_PLAYER_INVENTORY_FULL = 6,
                ERROR_PLAYER_HAS_UNCLAIMED_REWARDS = 7
            }
        }

        interface ICompleteVsSeekerAndRestartChargingProto {
        }

        class CompleteVsSeekerAndRestartChargingProto implements ICompleteVsSeekerAndRestartChargingProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingProto);
            public static encode(message: POGOProtos.Rpc.ICompleteVsSeekerAndRestartChargingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingProto;
            public static toObject(message: POGOProtos.Rpc.CompleteVsSeekerAndRestartChargingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICompleteWildSnapshotSessionOutProto {
            status?: (POGOProtos.Rpc.CompleteWildSnapshotSessionOutProto.Status|null);
        }

        class CompleteWildSnapshotSessionOutProto implements ICompleteWildSnapshotSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteWildSnapshotSessionOutProto);
            public status: POGOProtos.Rpc.CompleteWildSnapshotSessionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ICompleteWildSnapshotSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteWildSnapshotSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteWildSnapshotSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.CompleteWildSnapshotSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CompleteWildSnapshotSessionOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PHOTO_POKEMON_INVALID = 2,
                ERROR_NO_PHOTOS_TAKEN = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface ICompleteWildSnapshotSessionProto {
            photo_pokedex_id?: (number|null);
            num_photos_taken?: (number|null);
            type_1?: (POGOProtos.Rpc.HoloPokemonType|null);
            type_2?: (POGOProtos.Rpc.HoloPokemonType|null);
            spawn_point_id?: (string|null);
            encounter_id?: (number|Long|null);
        }

        class CompleteWildSnapshotSessionProto implements ICompleteWildSnapshotSessionProto {
            constructor(properties?: POGOProtos.Rpc.ICompleteWildSnapshotSessionProto);
            public photo_pokedex_id: number;
            public num_photos_taken: number;
            public type_1: POGOProtos.Rpc.HoloPokemonType;
            public type_2: POGOProtos.Rpc.HoloPokemonType;
            public spawn_point_id: string;
            public encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICompleteWildSnapshotSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CompleteWildSnapshotSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CompleteWildSnapshotSessionProto;
            public static toObject(message: POGOProtos.Rpc.CompleteWildSnapshotSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IComponentPokemonDetailsProto {
            fusion_pokemon_id?: (number|Long|null);
        }

        class ComponentPokemonDetailsProto implements IComponentPokemonDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IComponentPokemonDetailsProto);
            public fusion_pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IComponentPokemonDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ComponentPokemonDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ComponentPokemonDetailsProto;
            public static toObject(message: POGOProtos.Rpc.ComponentPokemonDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IComponentPokemonSettingsProto {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            component_candy_cost?: (number|null);
            form_change_type?: (POGOProtos.Rpc.ComponentPokemonSettingsProto.FormChangeType|null);
            fusion_move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
            fusion_move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
            location_card_settings?: (POGOProtos.Rpc.IFormChangeLocationCardSettingsProto[]|null);
            family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
        }

        class ComponentPokemonSettingsProto implements IComponentPokemonSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IComponentPokemonSettingsProto);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public component_candy_cost: number;
            public form_change_type: POGOProtos.Rpc.ComponentPokemonSettingsProto.FormChangeType;
            public fusion_move1: POGOProtos.Rpc.HoloPokemonMove;
            public fusion_move2: POGOProtos.Rpc.HoloPokemonMove;
            public location_card_settings: POGOProtos.Rpc.IFormChangeLocationCardSettingsProto[];
            public family_id: POGOProtos.Rpc.HoloPokemonFamilyId;
            public static encode(message: POGOProtos.Rpc.IComponentPokemonSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ComponentPokemonSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ComponentPokemonSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ComponentPokemonSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ComponentPokemonSettingsProto {

            enum FormChangeType {
                UNSET = 0,
                FUSE = 1,
                UNFUSE = 2
            }
        }

        interface IConfirmPhotobombOutProto {
            status?: (POGOProtos.Rpc.ConfirmPhotobombOutProto.Status|null);
        }

        class ConfirmPhotobombOutProto implements IConfirmPhotobombOutProto {
            constructor(properties?: POGOProtos.Rpc.IConfirmPhotobombOutProto);
            public status: POGOProtos.Rpc.ConfirmPhotobombOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IConfirmPhotobombOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConfirmPhotobombOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConfirmPhotobombOutProto;
            public static toObject(message: POGOProtos.Rpc.ConfirmPhotobombOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConfirmPhotobombOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PHOTOBOMB_NOT_FOUND = 2,
                ERROR_PHOTOBOMB_ALREADY_CONFIRMED = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface IConfirmPhotobombProto {
            encounter_id?: (number|Long|null);
        }

        class ConfirmPhotobombProto implements IConfirmPhotobombProto {
            constructor(properties?: POGOProtos.Rpc.IConfirmPhotobombProto);
            public encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IConfirmPhotobombProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConfirmPhotobombProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConfirmPhotobombProto;
            public static toObject(message: POGOProtos.Rpc.ConfirmPhotobombProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IConfirmTradingOutProto {
            result?: (POGOProtos.Rpc.ConfirmTradingOutProto.Result|null);
            trading?: (POGOProtos.Rpc.ITradingProto|null);
        }

        class ConfirmTradingOutProto implements IConfirmTradingOutProto {
            constructor(properties?: POGOProtos.Rpc.IConfirmTradingOutProto);
            public result: POGOProtos.Rpc.ConfirmTradingOutProto.Result;
            public trading?: (POGOProtos.Rpc.ITradingProto|null);
            public static encode(message: POGOProtos.Rpc.IConfirmTradingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConfirmTradingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConfirmTradingOutProto;
            public static toObject(message: POGOProtos.Rpc.ConfirmTradingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConfirmTradingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FRIEND_NOT_FOUND = 3,
                ERROR_INVALID_PLAYER_ID = 4,
                ERROR_INVALID_STATE = 5,
                ERROR_STATE_HANDLER = 6,
                ERROR_INVALID_POKEMON = 7,
                ERROR_INSUFFICIENT_PAYMENT = 8,
                ERROR_NO_PLAYER_POKEMON = 9,
                ERROR_NO_FRIEND_POKEMON = 10,
                ERROR_PLAYER_ALREADY_CONFIRMED = 11,
                ERROR_TRANSACTION_LOG_NOT_MATCH = 12,
                ERROR_TRADING_EXPIRED = 13,
                ERROR_TRANSACTION = 14,
                ERROR_DAILY_LIMIT_REACHED = 15
            }
        }

        interface IConfirmTradingProto {
            player_id?: (string|null);
            transaction_log?: (string|null);
        }

        class ConfirmTradingProto implements IConfirmTradingProto {
            constructor(properties?: POGOProtos.Rpc.IConfirmTradingProto);
            public player_id: string;
            public transaction_log: string;
            public static encode(message: POGOProtos.Rpc.IConfirmTradingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConfirmTradingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConfirmTradingProto;
            public static toObject(message: POGOProtos.Rpc.ConfirmTradingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IConsumePartyItemsOutProto {
            result?: (POGOProtos.Rpc.ConsumePartyItemsOutProto.Result|null);
            applied_items?: (POGOProtos.Rpc.IAppliedItemProto[]|null);
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
        }

        class ConsumePartyItemsOutProto implements IConsumePartyItemsOutProto {
            constructor(properties?: POGOProtos.Rpc.IConsumePartyItemsOutProto);
            public result: POGOProtos.Rpc.ConsumePartyItemsOutProto.Result;
            public applied_items: POGOProtos.Rpc.IAppliedItemProto[];
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public static encode(message: POGOProtos.Rpc.IConsumePartyItemsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConsumePartyItemsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConsumePartyItemsOutProto;
            public static toObject(message: POGOProtos.Rpc.ConsumePartyItemsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConsumePartyItemsOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_PLAYER_NOT_IN_PARTY = 3
            }
        }

        interface IConsumePartyItemsProto {
        }

        class ConsumePartyItemsProto implements IConsumePartyItemsProto {
            constructor(properties?: POGOProtos.Rpc.IConsumePartyItemsProto);
            public static encode(message: POGOProtos.Rpc.IConsumePartyItemsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConsumePartyItemsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConsumePartyItemsProto;
            public static toObject(message: POGOProtos.Rpc.ConsumePartyItemsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IConsumeStickersLogEntry {
            usage?: (POGOProtos.Rpc.ConsumeStickersProto.Usage|null);
            sticker_id?: (string[]|null);
        }

        class ConsumeStickersLogEntry implements IConsumeStickersLogEntry {
            constructor(properties?: POGOProtos.Rpc.IConsumeStickersLogEntry);
            public usage: POGOProtos.Rpc.ConsumeStickersProto.Usage;
            public sticker_id: string[];
            public static encode(message: POGOProtos.Rpc.IConsumeStickersLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConsumeStickersLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConsumeStickersLogEntry;
            public static toObject(message: POGOProtos.Rpc.ConsumeStickersLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IConsumeStickersOutProto {
            result?: (POGOProtos.Rpc.ConsumeStickersOutProto.Result|null);
        }

        class ConsumeStickersOutProto implements IConsumeStickersOutProto {
            constructor(properties?: POGOProtos.Rpc.IConsumeStickersOutProto);
            public result: POGOProtos.Rpc.ConsumeStickersOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IConsumeStickersOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConsumeStickersOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConsumeStickersOutProto;
            public static toObject(message: POGOProtos.Rpc.ConsumeStickersOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConsumeStickersOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_ENOUGH_STICKERS = 2
            }
        }

        interface IConsumeStickersProto {
            usage?: (POGOProtos.Rpc.ConsumeStickersProto.Usage|null);
            sticker_id?: (string[]|null);
        }

        class ConsumeStickersProto implements IConsumeStickersProto {
            constructor(properties?: POGOProtos.Rpc.IConsumeStickersProto);
            public usage: POGOProtos.Rpc.ConsumeStickersProto.Usage;
            public sticker_id: string[];
            public static encode(message: POGOProtos.Rpc.IConsumeStickersProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConsumeStickersProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConsumeStickersProto;
            public static toObject(message: POGOProtos.Rpc.ConsumeStickersProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConsumeStickersProto {

            enum Usage {
                UNSET = 0,
                PHOTO_STICKERS = 1
            }
        }

        interface IContactSettingsProto {
            send_marketing_emails?: (boolean|null);
            send_push_notifications?: (boolean|null);
        }

        class ContactSettingsProto implements IContactSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IContactSettingsProto);
            public send_marketing_emails: boolean;
            public send_push_notifications: boolean;
            public static encode(message: POGOProtos.Rpc.IContactSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContactSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContactSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ContactSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestBadgeData {
            number_of_first_place_wins?: (number|null);
            contest_data?: (POGOProtos.Rpc.IContestWinDataProto[]|null);
        }

        class ContestBadgeData implements IContestBadgeData {
            constructor(properties?: POGOProtos.Rpc.IContestBadgeData);
            public number_of_first_place_wins: number;
            public contest_data: POGOProtos.Rpc.IContestWinDataProto[];
            public static encode(message: POGOProtos.Rpc.IContestBadgeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestBadgeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestBadgeData;
            public static toObject(message: POGOProtos.Rpc.ContestBadgeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestBuddyFocusProto {
            min_buddy_level?: (POGOProtos.Rpc.BuddyLevel|null);
        }

        class ContestBuddyFocusProto implements IContestBuddyFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestBuddyFocusProto);
            public min_buddy_level: POGOProtos.Rpc.BuddyLevel;
            public static encode(message: POGOProtos.Rpc.IContestBuddyFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestBuddyFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestBuddyFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestBuddyFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestCycleProto {
            start_time_ms?: (number|Long|null);
            end_time_ms?: (number|Long|null);
            contest_occurrence?: (POGOProtos.Rpc.ContestOccurrence|null);
            custom_cycle_warmup_duration_ms?: (number|Long|null);
            custom_cycle_cooldown_duration_ms?: (number|Long|null);
            activate_early_termination?: (boolean|null);
        }

        class ContestCycleProto implements IContestCycleProto {
            constructor(properties?: POGOProtos.Rpc.IContestCycleProto);
            public start_time_ms: (number|Long);
            public end_time_ms: (number|Long);
            public contest_occurrence: POGOProtos.Rpc.ContestOccurrence;
            public custom_cycle_warmup_duration_ms: (number|Long);
            public custom_cycle_cooldown_duration_ms: (number|Long);
            public activate_early_termination: boolean;
            public static encode(message: POGOProtos.Rpc.IContestCycleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestCycleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestCycleProto;
            public static toObject(message: POGOProtos.Rpc.ContestCycleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestDisplayProto {
            style?: (POGOProtos.Rpc.EnumWrapper.PokestopStyle|null);
        }

        class ContestDisplayProto implements IContestDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IContestDisplayProto);
            public style: POGOProtos.Rpc.EnumWrapper.PokestopStyle;
            public static encode(message: POGOProtos.Rpc.IContestDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestDisplayProto;
            public static toObject(message: POGOProtos.Rpc.ContestDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestEntryProto {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            score?: (number|null);
            rank?: (number|null);
            player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            trainer_name?: (string|null);
            team?: (POGOProtos.Rpc.Team|null);
            pokemon_id?: (number|Long|null);
            player_id?: (string|null);
            pokemon_nickname?: (string|null);
            player_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class ContestEntryProto implements IContestEntryProto {
            constructor(properties?: POGOProtos.Rpc.IContestEntryProto);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public score: number;
            public rank: number;
            public player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public trainer_name: string;
            public team: POGOProtos.Rpc.Team;
            public pokemon_id: (number|Long);
            public player_id: string;
            public pokemon_nickname: string;
            public player_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.IContestEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestEntryProto;
            public static toObject(message: POGOProtos.Rpc.ContestEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestFocusProto {
            pokemon?: (POGOProtos.Rpc.IContestPokemonFocusProto|null);
            generation?: (POGOProtos.Rpc.IContestGenerationFocusProto|null);
            hatched?: (POGOProtos.Rpc.IContestHatchedFocusProto|null);
            mega?: (POGOProtos.Rpc.IContestTemporaryEvolutionFocusProto|null);
            shiny?: (POGOProtos.Rpc.IContestShinyFocusProto|null);
            type?: (POGOProtos.Rpc.IContestPokemonTypeFocusProto|null);
            buddy?: (POGOProtos.Rpc.IContestBuddyFocusProto|null);
            pokemon_class?: (POGOProtos.Rpc.IContestPokemonClassFocusProto|null);
            pokemon_family?: (POGOProtos.Rpc.IContestPokemonFamilyFocusProto|null);
            alignment?: (POGOProtos.Rpc.IContestPokemonAlignmentFocusProto|null);
        }

        class ContestFocusProto implements IContestFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestFocusProto);
            public pokemon?: (POGOProtos.Rpc.IContestPokemonFocusProto|null);
            public generation?: (POGOProtos.Rpc.IContestGenerationFocusProto|null);
            public hatched?: (POGOProtos.Rpc.IContestHatchedFocusProto|null);
            public mega?: (POGOProtos.Rpc.IContestTemporaryEvolutionFocusProto|null);
            public shiny?: (POGOProtos.Rpc.IContestShinyFocusProto|null);
            public type?: (POGOProtos.Rpc.IContestPokemonTypeFocusProto|null);
            public buddy?: (POGOProtos.Rpc.IContestBuddyFocusProto|null);
            public pokemon_class?: (POGOProtos.Rpc.IContestPokemonClassFocusProto|null);
            public pokemon_family?: (POGOProtos.Rpc.IContestPokemonFamilyFocusProto|null);
            public alignment?: (POGOProtos.Rpc.IContestPokemonAlignmentFocusProto|null);
            public ContestFocus?: ("pokemon"|"generation"|"hatched"|"mega"|"shiny"|"type"|"buddy"|"pokemon_class"|"pokemon_family"|"alignment");
            public static encode(message: POGOProtos.Rpc.IContestFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestFriendEntryProto {
            trainer_name?: (string|null);
            friendship_level_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            rank?: (number|null);
            player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            team?: (POGOProtos.Rpc.Team|null);
            player_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class ContestFriendEntryProto implements IContestFriendEntryProto {
            constructor(properties?: POGOProtos.Rpc.IContestFriendEntryProto);
            public trainer_name: string;
            public friendship_level_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public rank: number;
            public player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public team: POGOProtos.Rpc.Team;
            public player_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.IContestFriendEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestFriendEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestFriendEntryProto;
            public static toObject(message: POGOProtos.Rpc.ContestFriendEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestGenerationFocusProto {
            pokemon_generation?: (POGOProtos.Rpc.PokedexGenerationId|null);
        }

        class ContestGenerationFocusProto implements IContestGenerationFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestGenerationFocusProto);
            public pokemon_generation: POGOProtos.Rpc.PokedexGenerationId;
            public static encode(message: POGOProtos.Rpc.IContestGenerationFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestGenerationFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestGenerationFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestGenerationFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestHatchedFocusProto {
            require_to_be_hatched?: (boolean|null);
        }

        class ContestHatchedFocusProto implements IContestHatchedFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestHatchedFocusProto);
            public require_to_be_hatched: boolean;
            public static encode(message: POGOProtos.Rpc.IContestHatchedFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestHatchedFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestHatchedFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestHatchedFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestInfoProto {
            contest_id?: (string|null);
            pokemon_id?: (number|Long|null);
            ranking?: (number|null);
            fort_image_url?: (string|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            fort_name?: (string|null);
            rewards_template_id?: (string|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            local_end_time_ms?: (number|Long|null);
            is_ranking_locked?: (boolean|null);
            evolved_pokemon_id?: (number|Long|null);
        }

        class ContestInfoProto implements IContestInfoProto {
            constructor(properties?: POGOProtos.Rpc.IContestInfoProto);
            public contest_id: string;
            public pokemon_id: (number|Long);
            public ranking: number;
            public fort_image_url: string;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public fort_name: string;
            public rewards_template_id: string;
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public local_end_time_ms: (number|Long);
            public is_ranking_locked: boolean;
            public evolved_pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IContestInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestInfoProto;
            public static toObject(message: POGOProtos.Rpc.ContestInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestInfoSummaryProto {
            contest_info?: (POGOProtos.Rpc.IContestInfoProto[]|null);
            traded_contest_pokemon_id?: ((number|Long)[]|null);
            is_ranking_locked?: (boolean|null);
            end_time_ms?: (number|Long|null);
            metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            num_contests_entered?: (number|null);
        }

        class ContestInfoSummaryProto implements IContestInfoSummaryProto {
            constructor(properties?: POGOProtos.Rpc.IContestInfoSummaryProto);
            public contest_info: POGOProtos.Rpc.IContestInfoProto[];
            public traded_contest_pokemon_id: (number|Long)[];
            public is_ranking_locked: boolean;
            public end_time_ms: (number|Long);
            public metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public num_contests_entered: number;
            public static encode(message: POGOProtos.Rpc.IContestInfoSummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestInfoSummaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestInfoSummaryProto;
            public static toObject(message: POGOProtos.Rpc.ContestInfoSummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestLengthThresholdsProto {
            length?: (string|null);
            min_duration_ms?: (number|Long|null);
            max_duration_ms?: (number|Long|null);
        }

        class ContestLengthThresholdsProto implements IContestLengthThresholdsProto {
            constructor(properties?: POGOProtos.Rpc.IContestLengthThresholdsProto);
            public length: string;
            public min_duration_ms: (number|Long);
            public max_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IContestLengthThresholdsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestLengthThresholdsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestLengthThresholdsProto;
            public static toObject(message: POGOProtos.Rpc.ContestLengthThresholdsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestLimitProto {
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            contest_occurrence?: (POGOProtos.Rpc.ContestOccurrence|null);
            per_contest_max_entries?: (number|null);
        }

        class ContestLimitProto implements IContestLimitProto {
            constructor(properties?: POGOProtos.Rpc.IContestLimitProto);
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public contest_occurrence: POGOProtos.Rpc.ContestOccurrence;
            public per_contest_max_entries: number;
            public static encode(message: POGOProtos.Rpc.IContestLimitProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestLimitProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestLimitProto;
            public static toObject(message: POGOProtos.Rpc.ContestLimitProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestMetricProto {
            pokemon_metric?: (POGOProtos.Rpc.ContestPokemonMetric|null);
            ranking_standard?: (POGOProtos.Rpc.ContestRankingStandard|null);
        }

        class ContestMetricProto implements IContestMetricProto {
            constructor(properties?: POGOProtos.Rpc.IContestMetricProto);
            public pokemon_metric?: (POGOProtos.Rpc.ContestPokemonMetric|null);
            public ranking_standard: POGOProtos.Rpc.ContestRankingStandard;
            public Metric?: "pokemon_metric";
            public static encode(message: POGOProtos.Rpc.IContestMetricProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestMetricProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestMetricProto;
            public static toObject(message: POGOProtos.Rpc.ContestMetricProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestPokemonAlignmentFocusProto {
            required_alignment?: (POGOProtos.Rpc.ContestPokemonAlignmentFocusProto.alignment|null);
        }

        class ContestPokemonAlignmentFocusProto implements IContestPokemonAlignmentFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestPokemonAlignmentFocusProto);
            public required_alignment: POGOProtos.Rpc.ContestPokemonAlignmentFocusProto.alignment;
            public static encode(message: POGOProtos.Rpc.IContestPokemonAlignmentFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestPokemonAlignmentFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestPokemonAlignmentFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestPokemonAlignmentFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ContestPokemonAlignmentFocusProto {

            enum alignment {
                UNSET = 0,
                PURIFIED = 1,
                SHADOW = 2
            }
        }

        interface IContestPokemonClassFocusProto {
            required_class?: (POGOProtos.Rpc.HoloPokemonClass|null);
        }

        class ContestPokemonClassFocusProto implements IContestPokemonClassFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestPokemonClassFocusProto);
            public required_class: POGOProtos.Rpc.HoloPokemonClass;
            public static encode(message: POGOProtos.Rpc.IContestPokemonClassFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestPokemonClassFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestPokemonClassFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestPokemonClassFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestPokemonFamilyFocusProto {
            required_family?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
        }

        class ContestPokemonFamilyFocusProto implements IContestPokemonFamilyFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestPokemonFamilyFocusProto);
            public required_family: POGOProtos.Rpc.HoloPokemonFamilyId;
            public static encode(message: POGOProtos.Rpc.IContestPokemonFamilyFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestPokemonFamilyFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestPokemonFamilyFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestPokemonFamilyFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestPokemonFocusProto {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            require_form_to_match?: (boolean|null);
        }

        class ContestPokemonFocusProto implements IContestPokemonFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestPokemonFocusProto);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public require_form_to_match: boolean;
            public static encode(message: POGOProtos.Rpc.IContestPokemonFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestPokemonFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestPokemonFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestPokemonFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestPokemonSectionProto {
        }

        class ContestPokemonSectionProto implements IContestPokemonSectionProto {
            constructor(properties?: POGOProtos.Rpc.IContestPokemonSectionProto);
            public static encode(message: POGOProtos.Rpc.IContestPokemonSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestPokemonSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestPokemonSectionProto;
            public static toObject(message: POGOProtos.Rpc.ContestPokemonSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestPokemonTypeFocusProto {
            pokemon_type1?: (POGOProtos.Rpc.HoloPokemonType|null);
            pokemon_type2?: (POGOProtos.Rpc.HoloPokemonType|null);
        }

        class ContestPokemonTypeFocusProto implements IContestPokemonTypeFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestPokemonTypeFocusProto);
            public pokemon_type1: POGOProtos.Rpc.HoloPokemonType;
            public pokemon_type2: POGOProtos.Rpc.HoloPokemonType;
            public static encode(message: POGOProtos.Rpc.IContestPokemonTypeFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestPokemonTypeFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestPokemonTypeFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestPokemonTypeFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestProto {
            contest_id?: (string|null);
            focus?: (POGOProtos.Rpc.IContestFocusProto|null);
            metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            rewards_template_id?: (string|null);
            focuses?: (POGOProtos.Rpc.IContestFocusProto[]|null);
            focus_string_key?: (string|null);
            scalar_score_reference_pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            scalar_score_reference_pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class ContestProto implements IContestProto {
            constructor(properties?: POGOProtos.Rpc.IContestProto);
            public contest_id: string;
            public focus?: (POGOProtos.Rpc.IContestFocusProto|null);
            public metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public rewards_template_id: string;
            public focuses: POGOProtos.Rpc.IContestFocusProto[];
            public focus_string_key: string;
            public scalar_score_reference_pokemon: POGOProtos.Rpc.HoloPokemonId;
            public scalar_score_reference_pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IContestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestProto;
            public static toObject(message: POGOProtos.Rpc.ContestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestScheduleProto {
            contest_cycle?: (POGOProtos.Rpc.IContestCycleProto|null);
        }

        class ContestScheduleProto implements IContestScheduleProto {
            constructor(properties?: POGOProtos.Rpc.IContestScheduleProto);
            public contest_cycle?: (POGOProtos.Rpc.IContestCycleProto|null);
            public static encode(message: POGOProtos.Rpc.IContestScheduleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestScheduleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestScheduleProto;
            public static toObject(message: POGOProtos.Rpc.ContestScheduleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestScoreCoefficientProto {
            pokemon_size?: (POGOProtos.Rpc.ContestScoreCoefficientProto.IPokemonSize|null);
        }

        class ContestScoreCoefficientProto implements IContestScoreCoefficientProto {
            constructor(properties?: POGOProtos.Rpc.IContestScoreCoefficientProto);
            public pokemon_size?: (POGOProtos.Rpc.ContestScoreCoefficientProto.IPokemonSize|null);
            public ContestType?: "pokemon_size";
            public static encode(message: POGOProtos.Rpc.IContestScoreCoefficientProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestScoreCoefficientProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestScoreCoefficientProto;
            public static toObject(message: POGOProtos.Rpc.ContestScoreCoefficientProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ContestScoreCoefficientProto {

            interface IPokemonSize {
                height_coefficient?: (number|null);
                weight_coefficient?: (number|null);
                iv_coefficient?: (number|null);
                xxl_adjustment_factor?: (number|null);
            }

            class PokemonSize implements IPokemonSize {
                constructor(properties?: POGOProtos.Rpc.ContestScoreCoefficientProto.IPokemonSize);
                public height_coefficient: number;
                public weight_coefficient: number;
                public iv_coefficient: number;
                public xxl_adjustment_factor: number;
                public static encode(message: POGOProtos.Rpc.ContestScoreCoefficientProto.IPokemonSize, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestScoreCoefficientProto.PokemonSize;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestScoreCoefficientProto.PokemonSize;
                public static toObject(message: POGOProtos.Rpc.ContestScoreCoefficientProto.PokemonSize, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IContestScoreComponentProto {
            component_type?: (POGOProtos.Rpc.ContestScoreComponentType|null);
            coefficient_value?: (number|null);
            is_visible?: (boolean|null);
        }

        class ContestScoreComponentProto implements IContestScoreComponentProto {
            constructor(properties?: POGOProtos.Rpc.IContestScoreComponentProto);
            public component_type: POGOProtos.Rpc.ContestScoreComponentType;
            public coefficient_value: number;
            public is_visible: boolean;
            public static encode(message: POGOProtos.Rpc.IContestScoreComponentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestScoreComponentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestScoreComponentProto;
            public static toObject(message: POGOProtos.Rpc.ContestScoreComponentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestScoreFormulaProto {
            contest_type?: (POGOProtos.Rpc.IContestMetricProto|null);
            score_components?: (POGOProtos.Rpc.IContestScoreComponentProto[]|null);
        }

        class ContestScoreFormulaProto implements IContestScoreFormulaProto {
            constructor(properties?: POGOProtos.Rpc.IContestScoreFormulaProto);
            public contest_type?: (POGOProtos.Rpc.IContestMetricProto|null);
            public score_components: POGOProtos.Rpc.IContestScoreComponentProto[];
            public static encode(message: POGOProtos.Rpc.IContestScoreFormulaProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestScoreFormulaProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestScoreFormulaProto;
            public static toObject(message: POGOProtos.Rpc.ContestScoreFormulaProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestSettingsProto {
            is_feature_enabled?: (boolean|null);
            player_contest_max_entries?: (number|null);
            contest_limits?: (POGOProtos.Rpc.IContestLimitProto[]|null);
            default_contest_max_entries?: (number|null);
            min_cooldown_before_season_end_ms?: (number|Long|null);
            contest_warmup_and_cooldown_durations_ms?: (POGOProtos.Rpc.IContestWarmupAndCooldownDurationSettingsProto[]|null);
            default_cycle_warmup_duration_ms?: (number|Long|null);
            default_cycle_cooldown_duration_ms?: (number|Long|null);
            max_catch_prompt_range?: (number|null);
            catch_prompt_timeout_ms?: (number|null);
            contest_score_coefficient?: (POGOProtos.Rpc.IContestScoreCoefficientProto[]|null);
            contest_length_thresholds?: (POGOProtos.Rpc.IContestLengthThresholdsProto[]|null);
            is_friends_display_enabled?: (boolean|null);
            leaderboard_card_display_count?: (number|null);
            postcontest_leaderboard_card_display_count?: (number|null);
            contest_score_formulas?: (POGOProtos.Rpc.IContestScoreFormulaProto[]|null);
            is_v2_feature_enabled?: (boolean|null);
            is_anticheat_removal_enabled?: (boolean|null);
            is_normalized_score_to_species?: (boolean|null);
            is_v2_focuses_enabled?: (boolean|null);
            is_contest_in_nearby_menu?: (boolean|null);
            is_pokemon_scalar_enabled?: (boolean|null);
        }

        class ContestSettingsProto implements IContestSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IContestSettingsProto);
            public is_feature_enabled: boolean;
            public player_contest_max_entries: number;
            public contest_limits: POGOProtos.Rpc.IContestLimitProto[];
            public default_contest_max_entries: number;
            public min_cooldown_before_season_end_ms: (number|Long);
            public contest_warmup_and_cooldown_durations_ms: POGOProtos.Rpc.IContestWarmupAndCooldownDurationSettingsProto[];
            public default_cycle_warmup_duration_ms: (number|Long);
            public default_cycle_cooldown_duration_ms: (number|Long);
            public max_catch_prompt_range: number;
            public catch_prompt_timeout_ms: number;
            public contest_score_coefficient: POGOProtos.Rpc.IContestScoreCoefficientProto[];
            public contest_length_thresholds: POGOProtos.Rpc.IContestLengthThresholdsProto[];
            public is_friends_display_enabled: boolean;
            public leaderboard_card_display_count: number;
            public postcontest_leaderboard_card_display_count: number;
            public contest_score_formulas: POGOProtos.Rpc.IContestScoreFormulaProto[];
            public is_v2_feature_enabled: boolean;
            public is_anticheat_removal_enabled: boolean;
            public is_normalized_score_to_species: boolean;
            public is_v2_focuses_enabled: boolean;
            public is_contest_in_nearby_menu: boolean;
            public is_pokemon_scalar_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IContestSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ContestSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestShinyFocusProto {
            require_to_be_shiny?: (boolean|null);
        }

        class ContestShinyFocusProto implements IContestShinyFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestShinyFocusProto);
            public require_to_be_shiny: boolean;
            public static encode(message: POGOProtos.Rpc.IContestShinyFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestShinyFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestShinyFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestShinyFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestTemporaryEvolutionFocusProto {
            temporary_evolution_required?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            restriction?: (POGOProtos.Rpc.ContestTemporaryEvolutionFocusProto.Restriction|null);
        }

        class ContestTemporaryEvolutionFocusProto implements IContestTemporaryEvolutionFocusProto {
            constructor(properties?: POGOProtos.Rpc.IContestTemporaryEvolutionFocusProto);
            public temporary_evolution_required: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public restriction: POGOProtos.Rpc.ContestTemporaryEvolutionFocusProto.Restriction;
            public static encode(message: POGOProtos.Rpc.IContestTemporaryEvolutionFocusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestTemporaryEvolutionFocusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestTemporaryEvolutionFocusProto;
            public static toObject(message: POGOProtos.Rpc.ContestTemporaryEvolutionFocusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ContestTemporaryEvolutionFocusProto {

            enum Restriction {
                UNSET = 0,
                MEGA = 1,
                NOT_TEMP_EVO = 2
            }
        }

        interface IContestWarmupAndCooldownDurationSettingsProto {
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            contest_occurrence?: (POGOProtos.Rpc.ContestOccurrence|null);
            cycle_warmup_duration_ms?: (number|Long|null);
            cycle_cooldown_duration_ms?: (number|Long|null);
        }

        class ContestWarmupAndCooldownDurationSettingsProto implements IContestWarmupAndCooldownDurationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IContestWarmupAndCooldownDurationSettingsProto);
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public contest_occurrence: POGOProtos.Rpc.ContestOccurrence;
            public cycle_warmup_duration_ms: (number|Long);
            public cycle_cooldown_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IContestWarmupAndCooldownDurationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestWarmupAndCooldownDurationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestWarmupAndCooldownDurationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ContestWarmupAndCooldownDurationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContestWinDataProto {
            fort_name?: (string|null);
            pokemon_id?: (number|Long|null);
            contest_end_ms?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
        }

        class ContestWinDataProto implements IContestWinDataProto {
            constructor(properties?: POGOProtos.Rpc.IContestWinDataProto);
            public fort_name: string;
            public pokemon_id: (number|Long);
            public contest_end_ms: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public static encode(message: POGOProtos.Rpc.IContestWinDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContestWinDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContestWinDataProto;
            public static toObject(message: POGOProtos.Rpc.ContestWinDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IContributePartyItemOutProto {
            result?: (POGOProtos.Rpc.ContributePartyItemOutProto.Result|null);
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            rpc_result?: (POGOProtos.Rpc.ContributePartyItemResult|null);
        }

        class ContributePartyItemOutProto implements IContributePartyItemOutProto {
            constructor(properties?: POGOProtos.Rpc.IContributePartyItemOutProto);
            public result: POGOProtos.Rpc.ContributePartyItemOutProto.Result;
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public rpc_result: POGOProtos.Rpc.ContributePartyItemResult;
            public static encode(message: POGOProtos.Rpc.IContributePartyItemOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContributePartyItemOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContributePartyItemOutProto;
            public static toObject(message: POGOProtos.Rpc.ContributePartyItemOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ContributePartyItemOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_INSUFFICIENT_INVENTORY = 3,
                ERROR_PLAYER_NOT_IN_PARTY = 4,
                ERROR_UNSANCTIONED_ITEM_TYPE = 5,
                ERROR_PARTY_UNABLE_TO_RECEIVE = 6
            }
        }

        interface IContributePartyItemProto {
            contributed_items?: (POGOProtos.Rpc.IItemProto[]|null);
            items?: (POGOProtos.Rpc.IItemProto|null);
        }

        class ContributePartyItemProto implements IContributePartyItemProto {
            constructor(properties?: POGOProtos.Rpc.IContributePartyItemProto);
            public contributed_items: POGOProtos.Rpc.IItemProto[];
            public items?: (POGOProtos.Rpc.IItemProto|null);
            public static encode(message: POGOProtos.Rpc.IContributePartyItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ContributePartyItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ContributePartyItemProto;
            public static toObject(message: POGOProtos.Rpc.ContributePartyItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IConversationSettingsProto {
            appraisal_conv_override_config?: (string|null);
            pokemon_form_appraisal_overrides?: (POGOProtos.Rpc.ConversationSettingsProto.IPokemonFormAppraisalOverrides[]|null);
        }

        class ConversationSettingsProto implements IConversationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IConversationSettingsProto);
            public appraisal_conv_override_config: string;
            public pokemon_form_appraisal_overrides: POGOProtos.Rpc.ConversationSettingsProto.IPokemonFormAppraisalOverrides[];
            public static encode(message: POGOProtos.Rpc.IConversationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConversationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConversationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ConversationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConversationSettingsProto {

            interface IPokemonFormAppraisalOverrides {
                id?: (POGOProtos.Rpc.HoloPokemonId|null);
                form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
                appraisal_key?: (string|null);
                add_to_start?: (boolean|null);
            }

            class PokemonFormAppraisalOverrides implements IPokemonFormAppraisalOverrides {
                constructor(properties?: POGOProtos.Rpc.ConversationSettingsProto.IPokemonFormAppraisalOverrides);
                public id: POGOProtos.Rpc.HoloPokemonId;
                public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
                public appraisal_key: string;
                public add_to_start: boolean;
                public static encode(message: POGOProtos.Rpc.ConversationSettingsProto.IPokemonFormAppraisalOverrides, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConversationSettingsProto.PokemonFormAppraisalOverrides;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConversationSettingsProto.PokemonFormAppraisalOverrides;
                public static toObject(message: POGOProtos.Rpc.ConversationSettingsProto.PokemonFormAppraisalOverrides, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IConvertCandyToXlCandyOutProto {
            status?: (POGOProtos.Rpc.ConvertCandyToXlCandyOutProto.Status|null);
        }

        class ConvertCandyToXlCandyOutProto implements IConvertCandyToXlCandyOutProto {
            constructor(properties?: POGOProtos.Rpc.IConvertCandyToXlCandyOutProto);
            public status: POGOProtos.Rpc.ConvertCandyToXlCandyOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IConvertCandyToXlCandyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConvertCandyToXlCandyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConvertCandyToXlCandyOutProto;
            public static toObject(message: POGOProtos.Rpc.ConvertCandyToXlCandyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ConvertCandyToXlCandyOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_ENOUGH_CANDY = 2,
                ERROR_PLAYER_LEVEL_TOO_LOW = 3
            }
        }

        interface IConvertCandyToXlCandyProto {
            family?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            num_xl_candy?: (number|null);
        }

        class ConvertCandyToXlCandyProto implements IConvertCandyToXlCandyProto {
            constructor(properties?: POGOProtos.Rpc.IConvertCandyToXlCandyProto);
            public family: POGOProtos.Rpc.HoloPokemonFamilyId;
            public num_xl_candy: number;
            public static encode(message: POGOProtos.Rpc.IConvertCandyToXlCandyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ConvertCandyToXlCandyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ConvertCandyToXlCandyProto;
            public static toObject(message: POGOProtos.Rpc.ConvertCandyToXlCandyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICoreHandshakeTelemetryEvent {
            handshake_time_ms?: (number|Long|null);
            session_init_time_ms?: (number|Long|null);
            authentication_rpc_time_ms?: (number|Long|null);
            success?: (boolean|null);
        }

        class CoreHandshakeTelemetryEvent implements ICoreHandshakeTelemetryEvent {
            constructor(properties?: POGOProtos.Rpc.ICoreHandshakeTelemetryEvent);
            public handshake_time_ms: (number|Long);
            public session_init_time_ms: (number|Long);
            public authentication_rpc_time_ms: (number|Long);
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.ICoreHandshakeTelemetryEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CoreHandshakeTelemetryEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CoreHandshakeTelemetryEvent;
            public static toObject(message: POGOProtos.Rpc.CoreHandshakeTelemetryEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICoreSafetynetTelemetryEvent {
            safetynet_time_ms?: (number|Long|null);
            attestation_time_ms?: (number|Long|null);
            rpc_time_ms?: (number|Long|null);
            retries?: (number|Long|null);
            success?: (boolean|null);
        }

        class CoreSafetynetTelemetryEvent implements ICoreSafetynetTelemetryEvent {
            constructor(properties?: POGOProtos.Rpc.ICoreSafetynetTelemetryEvent);
            public safetynet_time_ms: (number|Long);
            public attestation_time_ms: (number|Long);
            public rpc_time_ms: (number|Long);
            public retries: (number|Long);
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.ICoreSafetynetTelemetryEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CoreSafetynetTelemetryEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CoreSafetynetTelemetryEvent;
            public static toObject(message: POGOProtos.Rpc.CoreSafetynetTelemetryEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICostSettingsProto {
            candy_cost?: (number|null);
            stardust_cost?: (number|null);
        }

        class CostSettingsProto implements ICostSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICostSettingsProto);
            public candy_cost: number;
            public stardust_cost: number;
            public static encode(message: POGOProtos.Rpc.ICostSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CostSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CostSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CostSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICoveringProto {
        }

        class CoveringProto implements ICoveringProto {
            constructor(properties?: POGOProtos.Rpc.ICoveringProto);
            public static encode(message: POGOProtos.Rpc.ICoveringProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CoveringProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CoveringProto;
            public static toObject(message: POGOProtos.Rpc.CoveringProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICrashlyticsSettingsProto {
            enabled?: (boolean|null);
            session_sampling_fraction?: (number|null);
        }

        class CrashlyticsSettingsProto implements ICrashlyticsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICrashlyticsSettingsProto);
            public enabled: boolean;
            public session_sampling_fraction: number;
            public static encode(message: POGOProtos.Rpc.ICrashlyticsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CrashlyticsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CrashlyticsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CrashlyticsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateBreadInstanceOutProto {
            result?: (POGOProtos.Rpc.CreateBreadInstanceOutProto.Result|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            session_player_id?: (string|null);
            session_id?: (string|null);
        }

        class CreateBreadInstanceOutProto implements ICreateBreadInstanceOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateBreadInstanceOutProto);
            public result: POGOProtos.Rpc.CreateBreadInstanceOutProto.Result;
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public session_player_id: string;
            public session_id: string;
            public static encode(message: POGOProtos.Rpc.ICreateBreadInstanceOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateBreadInstanceOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateBreadInstanceOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateBreadInstanceOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateBreadInstanceOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ICreateBreadInstanceProto {
            roster?: ((number|Long)[]|null);
            cp_multiplier?: (number|null);
            stamina?: (number|null);
        }

        class CreateBreadInstanceProto implements ICreateBreadInstanceProto {
            constructor(properties?: POGOProtos.Rpc.ICreateBreadInstanceProto);
            public roster: (number|Long)[];
            public cp_multiplier: number;
            public stamina: number;
            public static encode(message: POGOProtos.Rpc.ICreateBreadInstanceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateBreadInstanceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateBreadInstanceProto;
            public static toObject(message: POGOProtos.Rpc.CreateBreadInstanceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateBuddyMultiplayerSessionOutProto {
            plfe_session_id?: (string|null);
            arbe_join_token?: (Uint8Array|null);
            generation_timestamp?: (number|Long|null);
            max_players?: (number|null);
            result?: (POGOProtos.Rpc.CreateBuddyMultiplayerSessionOutProto.Result|null);
        }

        class CreateBuddyMultiplayerSessionOutProto implements ICreateBuddyMultiplayerSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateBuddyMultiplayerSessionOutProto);
            public plfe_session_id: string;
            public arbe_join_token: Uint8Array;
            public generation_timestamp: (number|Long);
            public max_players: number;
            public result: POGOProtos.Rpc.CreateBuddyMultiplayerSessionOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICreateBuddyMultiplayerSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateBuddyMultiplayerSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateBuddyMultiplayerSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateBuddyMultiplayerSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateBuddyMultiplayerSessionOutProto {

            enum Result {
                CREATE_SUCCESS = 0,
                CREATE_BUDDY_NOT_SET = 1,
                CREATE_BUDDY_NOT_FOUND = 2,
                CREATE_BAD_BUDDY = 3,
                CREATE_BUDDY_V2_NOT_ENABLED = 4,
                CREATE_PLAYER_LEVEL_TOO_LOW = 5,
                CREATE_UNKNOWN_ERROR = 6,
                CREATE_U13_NO_PERMISSION = 7
            }
        }

        interface ICreateBuddyMultiplayerSessionProto {
        }

        class CreateBuddyMultiplayerSessionProto implements ICreateBuddyMultiplayerSessionProto {
            constructor(properties?: POGOProtos.Rpc.ICreateBuddyMultiplayerSessionProto);
            public static encode(message: POGOProtos.Rpc.ICreateBuddyMultiplayerSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateBuddyMultiplayerSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateBuddyMultiplayerSessionProto;
            public static toObject(message: POGOProtos.Rpc.CreateBuddyMultiplayerSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateCombatChallengeData {
            rpc_id?: (number|null);
        }

        class CreateCombatChallengeData implements ICreateCombatChallengeData {
            constructor(properties?: POGOProtos.Rpc.ICreateCombatChallengeData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ICreateCombatChallengeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateCombatChallengeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateCombatChallengeData;
            public static toObject(message: POGOProtos.Rpc.CreateCombatChallengeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateCombatChallengeOutProto {
            result?: (POGOProtos.Rpc.CreateCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
        }

        class CreateCombatChallengeOutProto implements ICreateCombatChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateCombatChallengeOutProto);
            public result: POGOProtos.Rpc.CreateCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public static encode(message: POGOProtos.Rpc.ICreateCombatChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateCombatChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateCombatChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateCombatChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateCombatChallengeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_CHALLENGE_STATE = 2,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 3,
                ERROR_ACCESS_DENIED = 4
            }
        }

        interface ICreateCombatChallengeProto {
            challenge_id?: (string|null);
        }

        class CreateCombatChallengeProto implements ICreateCombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.ICreateCombatChallengeProto);
            public challenge_id: string;
            public static encode(message: POGOProtos.Rpc.ICreateCombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateCombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateCombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.CreateCombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateCombatChallengeResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.CreateCombatChallengeOutProto.Result|null);
        }

        class CreateCombatChallengeResponseData implements ICreateCombatChallengeResponseData {
            constructor(properties?: POGOProtos.Rpc.ICreateCombatChallengeResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.CreateCombatChallengeOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICreateCombatChallengeResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateCombatChallengeResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateCombatChallengeResponseData;
            public static toObject(message: POGOProtos.Rpc.CreateCombatChallengeResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateEventRsvpOutProto {
            status?: (POGOProtos.Rpc.CreateEventRsvpOutProto.Result|null);
            rsvp?: (POGOProtos.Rpc.IEventRsvpProto|null);
        }

        class CreateEventRsvpOutProto implements ICreateEventRsvpOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateEventRsvpOutProto);
            public status: POGOProtos.Rpc.CreateEventRsvpOutProto.Result;
            public rsvp?: (POGOProtos.Rpc.IEventRsvpProto|null);
            public static encode(message: POGOProtos.Rpc.ICreateEventRsvpOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateEventRsvpOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateEventRsvpOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateEventRsvpOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateEventRsvpOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_TIME_CONFLICT = 3,
                ERROR_LIMIT_REACHED = 4
            }
        }

        interface ICreateEventRsvpProto {
            location_id?: (string|null);
            timestamp_ms?: (number|Long|null);
            rsvp_selection?: (POGOProtos.Rpc.RsvpSelection|null);
        }

        class CreateEventRsvpProto implements ICreateEventRsvpProto {
            constructor(properties?: POGOProtos.Rpc.ICreateEventRsvpProto);
            public location_id: string;
            public timestamp_ms: (number|Long);
            public rsvp_selection: POGOProtos.Rpc.RsvpSelection;
            public static encode(message: POGOProtos.Rpc.ICreateEventRsvpProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateEventRsvpProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateEventRsvpProto;
            public static toObject(message: POGOProtos.Rpc.CreateEventRsvpProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateGuestLoginSecretTokenRequestProto {
            api_key?: (string|null);
            device_id?: (string|null);
        }

        class CreateGuestLoginSecretTokenRequestProto implements ICreateGuestLoginSecretTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.ICreateGuestLoginSecretTokenRequestProto);
            public api_key: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.ICreateGuestLoginSecretTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateGuestLoginSecretTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateGuestLoginSecretTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.CreateGuestLoginSecretTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateGuestLoginSecretTokenResponseProto {
            status?: (POGOProtos.Rpc.CreateGuestLoginSecretTokenResponseProto.Status|null);
            secret?: (Uint8Array|null);
        }

        class CreateGuestLoginSecretTokenResponseProto implements ICreateGuestLoginSecretTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.ICreateGuestLoginSecretTokenResponseProto);
            public status: POGOProtos.Rpc.CreateGuestLoginSecretTokenResponseProto.Status;
            public secret: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ICreateGuestLoginSecretTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateGuestLoginSecretTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateGuestLoginSecretTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.CreateGuestLoginSecretTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateGuestLoginSecretTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                UNKNOWN_ERROR = 2,
                UNAUTHORIZED = 3,
                DISABLED = 4,
                EXCEEDED_RATE_LIMIT = 5
            }
        }

        interface ICreatePartyOutProto {
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            result?: (POGOProtos.Rpc.CreatePartyOutProto.Result|null);
        }

        class CreatePartyOutProto implements ICreatePartyOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreatePartyOutProto);
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public result: POGOProtos.Rpc.CreatePartyOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ICreatePartyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatePartyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatePartyOutProto;
            public static toObject(message: POGOProtos.Rpc.CreatePartyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreatePartyOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_ALREADY_IN_PARTY = 3,
                ERROR_PLAYER_LEVEL_TOO_LOW = 4,
                ERROR_FEATURE_DISABLED = 5,
                ERROR_DARK_LAUNCH_NOT_ENABLED_FOR_PLAYER = 6,
                ERROR_REDIS_EXCEPTION = 7,
                ERROR_U13_NO_PERMISSION = 8,
                ERROR_NO_LOCATION = 9,
                ERROR_PLFE_REDIRECT_NEEDED = 10,
                ERROR_PARTY_QUEST_ENCOUNTER_INCOMPLETE = 11,
                ERROR_QUEST_ID_NEEDED_FOR_PARTY_CREATION = 12,
                ERROR_WEEKLY_CHALLENGE_NOT_AVAILABLE = 13
            }
        }

        interface ICreatePartyProto {
            is_dark_launch_request?: (boolean|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
            quest_id?: (string|null);
        }

        class CreatePartyProto implements ICreatePartyProto {
            constructor(properties?: POGOProtos.Rpc.ICreatePartyProto);
            public is_dark_launch_request: boolean;
            public party_type: POGOProtos.Rpc.PartyType;
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.ICreatePartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatePartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatePartyProto;
            public static toObject(message: POGOProtos.Rpc.CreatePartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreatePokemonTagOutProto {
            result?: (POGOProtos.Rpc.CreatePokemonTagOutProto.Result|null);
            created_tag?: (POGOProtos.Rpc.IPokemonTagProto|null);
        }

        class CreatePokemonTagOutProto implements ICreatePokemonTagOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreatePokemonTagOutProto);
            public result: POGOProtos.Rpc.CreatePokemonTagOutProto.Result;
            public created_tag?: (POGOProtos.Rpc.IPokemonTagProto|null);
            public static encode(message: POGOProtos.Rpc.ICreatePokemonTagOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatePokemonTagOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatePokemonTagOutProto;
            public static toObject(message: POGOProtos.Rpc.CreatePokemonTagOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreatePokemonTagOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                TAG_ALREADY_EXISTS = 3,
                PLAYER_HAS_MAXIMUM_NUMBER_OF_TAGS = 4,
                TAG_NAME_CONTAINS_PROFANITY = 5
            }
        }

        interface ICreatePokemonTagProto {
            name?: (string|null);
            color?: (POGOProtos.Rpc.PokemonTagColor|null);
        }

        class CreatePokemonTagProto implements ICreatePokemonTagProto {
            constructor(properties?: POGOProtos.Rpc.ICreatePokemonTagProto);
            public name: string;
            public color: POGOProtos.Rpc.PokemonTagColor;
            public static encode(message: POGOProtos.Rpc.ICreatePokemonTagProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatePokemonTagProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatePokemonTagProto;
            public static toObject(message: POGOProtos.Rpc.CreatePokemonTagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreatePostcardOutProto {
            result?: (POGOProtos.Rpc.CreatePostcardOutProto.Result|null);
            postcard?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
            butterfly_collector_updated_region?: (POGOProtos.Rpc.IButterflyCollectorRegionMedal|null);
        }

        class CreatePostcardOutProto implements ICreatePostcardOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreatePostcardOutProto);
            public result: POGOProtos.Rpc.CreatePostcardOutProto.Result;
            public postcard?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
            public butterfly_collector_updated_region?: (POGOProtos.Rpc.IButterflyCollectorRegionMedal|null);
            public static encode(message: POGOProtos.Rpc.ICreatePostcardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatePostcardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatePostcardOutProto;
            public static toObject(message: POGOProtos.Rpc.CreatePostcardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreatePostcardOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_SENDER_DOES_NOT_EXIST = 2,
                ERROR_GIFT_DOES_NOT_EXIST = 3,
                ERROR_POSTCARD_ALREADY_CREATED = 4,
                ERROR_POSTCARD_INVENTORY_FULL = 5,
                ERROR_NOT_ENABLED = 6,
                ERROR_RATE_LIMITED = 7,
                ERROR_PLAYER_HAS_NO_STICKERS = 8,
                SUCCESS_INVENTORY_DAILY_BUTTERFLY_LIMIT = 9
            }
        }

        interface ICreatePostcardProto {
            giftbox_id?: (number|Long|null);
            sender_id?: (string|null);
            sticker_id?: (string[]|null);
            encounter_id?: (string|null);
        }

        class CreatePostcardProto implements ICreatePostcardProto {
            constructor(properties?: POGOProtos.Rpc.ICreatePostcardProto);
            public giftbox_id: (number|Long);
            public sender_id: string;
            public sticker_id: string[];
            public encounter_id: string;
            public static encode(message: POGOProtos.Rpc.ICreatePostcardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatePostcardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatePostcardProto;
            public static toObject(message: POGOProtos.Rpc.CreatePostcardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateRoomRequest {
            experience_id?: (string|null);
            name?: (string|null);
            description?: (string|null);
            capacity?: (number|null);
            reconnect_timeout_seconds?: (number|null);
            passcode?: (string|null);
            region?: (string|null);
        }

        class CreateRoomRequest implements ICreateRoomRequest {
            constructor(properties?: POGOProtos.Rpc.ICreateRoomRequest);
            public experience_id: string;
            public name: string;
            public description: string;
            public capacity: number;
            public reconnect_timeout_seconds: number;
            public passcode: string;
            public region: string;
            public static encode(message: POGOProtos.Rpc.ICreateRoomRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRoomRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRoomRequest;
            public static toObject(message: POGOProtos.Rpc.CreateRoomRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateRoomResponse {
            room?: (POGOProtos.Rpc.IRoom|null);
        }

        class CreateRoomResponse implements ICreateRoomResponse {
            constructor(properties?: POGOProtos.Rpc.ICreateRoomResponse);
            public room?: (POGOProtos.Rpc.IRoom|null);
            public static encode(message: POGOProtos.Rpc.ICreateRoomResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRoomResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRoomResponse;
            public static toObject(message: POGOProtos.Rpc.CreateRoomResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateRouteDraftOutProto {
            result?: (POGOProtos.Rpc.CreateRouteDraftOutProto.Result|null);
            updated_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
        }

        class CreateRouteDraftOutProto implements ICreateRouteDraftOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateRouteDraftOutProto);
            public result: POGOProtos.Rpc.CreateRouteDraftOutProto.Result;
            public updated_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            public static encode(message: POGOProtos.Rpc.ICreateRouteDraftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRouteDraftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRouteDraftOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateRouteDraftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateRouteDraftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_TOO_MANY_IN_PROGRESS = 3,
                ERROR_MINOR = 4,
                ERROR_LEVEL_TOO_LOW = 5,
                ERROR_INVALID_START_ANCHOR = 6,
                ERROR_CREATION_LIMIT = 7
            }
        }

        interface ICreateRouteDraftProto {
            start_anchor?: (POGOProtos.Rpc.IRouteWaypointProto|null);
        }

        class CreateRouteDraftProto implements ICreateRouteDraftProto {
            constructor(properties?: POGOProtos.Rpc.ICreateRouteDraftProto);
            public start_anchor?: (POGOProtos.Rpc.IRouteWaypointProto|null);
            public static encode(message: POGOProtos.Rpc.ICreateRouteDraftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRouteDraftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRouteDraftProto;
            public static toObject(message: POGOProtos.Rpc.CreateRouteDraftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateRoutePinOutProto {
            result?: (POGOProtos.Rpc.CreateRoutePinOutProto.Result|null);
            updated_route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            new_pin?: (POGOProtos.Rpc.IRoutePin|null);
        }

        class CreateRoutePinOutProto implements ICreateRoutePinOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateRoutePinOutProto);
            public result: POGOProtos.Rpc.CreateRoutePinOutProto.Result;
            public updated_route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public new_pin?: (POGOProtos.Rpc.IRoutePin|null);
            public static encode(message: POGOProtos.Rpc.ICreateRoutePinOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRoutePinOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRoutePinOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateRoutePinOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateRoutePinOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ROUTE_NOT_FOUND = 3,
                ERROR_INVALID_LAT_LNG = 4,
                ERROR_LEVEL_TOO_LOW = 5,
                ERROR_CREATION_LIMIT = 6,
                ERROR_INVALID_MESSAGE = 7,
                ERROR_DISABLED = 8,
                ERROR_CHEATER = 9,
                ERROR_MINOR = 10,
                ERROR_STICKER_NOT_FOUND = 11,
                ERROR_NOT_ENOUGH_STICKERS = 12
            }
        }

        interface ICreateRoutePinProto {
            route_id?: (string|null);
            lat_degrees?: (number|null);
            lng_degrees?: (number|null);
            message?: (string|null);
            sticker_id?: (string|null);
        }

        class CreateRoutePinProto implements ICreateRoutePinProto {
            constructor(properties?: POGOProtos.Rpc.ICreateRoutePinProto);
            public route_id: string;
            public lat_degrees: number;
            public lng_degrees: number;
            public message: string;
            public sticker_id: string;
            public static encode(message: POGOProtos.Rpc.ICreateRoutePinProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRoutePinProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRoutePinProto;
            public static toObject(message: POGOProtos.Rpc.CreateRoutePinProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreateRouteShortcodeOutProto {
            result?: (POGOProtos.Rpc.CreateRouteShortcodeOutProto.Result|null);
            short_code?: (string|null);
        }

        class CreateRouteShortcodeOutProto implements ICreateRouteShortcodeOutProto {
            constructor(properties?: POGOProtos.Rpc.ICreateRouteShortcodeOutProto);
            public result: POGOProtos.Rpc.CreateRouteShortcodeOutProto.Result;
            public short_code: string;
            public static encode(message: POGOProtos.Rpc.ICreateRouteShortcodeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRouteShortcodeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRouteShortcodeOutProto;
            public static toObject(message: POGOProtos.Rpc.CreateRouteShortcodeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CreateRouteShortcodeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ROUTE_NOT_FOUND = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface ICreateRouteShortcodeProto {
            route_id?: (string|null);
            long_lived?: (boolean|null);
        }

        class CreateRouteShortcodeProto implements ICreateRouteShortcodeProto {
            constructor(properties?: POGOProtos.Rpc.ICreateRouteShortcodeProto);
            public route_id: string;
            public long_lived: boolean;
            public static encode(message: POGOProtos.Rpc.ICreateRouteShortcodeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreateRouteShortcodeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreateRouteShortcodeProto;
            public static toObject(message: POGOProtos.Rpc.CreateRouteShortcodeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICreatorInfo {
            creator_player_id?: (string|null);
            creator_codename?: (string|null);
            show_creator_name?: (boolean|null);
            public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
        }

        class CreatorInfo implements ICreatorInfo {
            constructor(properties?: POGOProtos.Rpc.ICreatorInfo);
            public creator_player_id: string;
            public creator_codename: string;
            public show_creator_name: boolean;
            public public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public static encode(message: POGOProtos.Rpc.ICreatorInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CreatorInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CreatorInfo;
            public static toObject(message: POGOProtos.Rpc.CreatorInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICriticalReticleSettingsProto {
            critical_reticle_settings_enabled?: (boolean|null);
        }

        class CriticalReticleSettingsProto implements ICriticalReticleSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICriticalReticleSettingsProto);
            public critical_reticle_settings_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ICriticalReticleSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CriticalReticleSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CriticalReticleSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CriticalReticleSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICrmProxyRequestProto {
            action?: (number|null);
            payload?: (Uint8Array|null);
        }

        class CrmProxyRequestProto implements ICrmProxyRequestProto {
            constructor(properties?: POGOProtos.Rpc.ICrmProxyRequestProto);
            public action: number;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ICrmProxyRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CrmProxyRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CrmProxyRequestProto;
            public static toObject(message: POGOProtos.Rpc.CrmProxyRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICrmProxyResponseProto {
            status?: (POGOProtos.Rpc.CrmProxyResponseProto.Status|null);
            error_message?: (string|null);
            payload?: (Uint8Array|null);
        }

        class CrmProxyResponseProto implements ICrmProxyResponseProto {
            constructor(properties?: POGOProtos.Rpc.ICrmProxyResponseProto);
            public status: POGOProtos.Rpc.CrmProxyResponseProto.Status;
            public error_message: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ICrmProxyResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CrmProxyResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CrmProxyResponseProto;
            public static toObject(message: POGOProtos.Rpc.CrmProxyResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace CrmProxyResponseProto {

            enum Status {
                UNSET = 0,
                OK = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PERMISSION_DENIED = 3,
                ERROR_UNAVAILABLE = 4,
                ERROR_UNAUTHENTICATED = 5
            }
        }

        interface ICrossGameSocialGlobalSettingsProto {
            online_status_min_level?: (number|null);
            niantic_profile_min_level?: (number|null);
            friends_list_min_level?: (number|null);
            max_friends_per_detail_page?: (number|null);
        }

        class CrossGameSocialGlobalSettingsProto implements ICrossGameSocialGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICrossGameSocialGlobalSettingsProto);
            public online_status_min_level: number;
            public niantic_profile_min_level: number;
            public friends_list_min_level: number;
            public max_friends_per_detail_page: number;
            public static encode(message: POGOProtos.Rpc.ICrossGameSocialGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CrossGameSocialGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CrossGameSocialGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CrossGameSocialGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICrossGameSocialSettingsProto {
            online_status_enabled_override_level?: (boolean|null);
            niantic_profile_enabled_override_level?: (boolean|null);
            friends_list_enabled_override_level?: (boolean|null);
        }

        class CrossGameSocialSettingsProto implements ICrossGameSocialSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ICrossGameSocialSettingsProto);
            public online_status_enabled_override_level: boolean;
            public niantic_profile_enabled_override_level: boolean;
            public friends_list_enabled_override_level: boolean;
            public static encode(message: POGOProtos.Rpc.ICrossGameSocialSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CrossGameSocialSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CrossGameSocialSettingsProto;
            public static toObject(message: POGOProtos.Rpc.CrossGameSocialSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICurrencyQuantityProto {
            currency_type?: (string|null);
            quantity?: (number|null);
            fiat_purchased_quantity?: (number|null);
            fiat_currency_type?: (string|null);
            fiat_currency_cost_e6?: (number|Long|null);
        }

        class CurrencyQuantityProto implements ICurrencyQuantityProto {
            constructor(properties?: POGOProtos.Rpc.ICurrencyQuantityProto);
            public currency_type: string;
            public quantity: number;
            public fiat_purchased_quantity: number;
            public fiat_currency_type: string;
            public fiat_currency_cost_e6: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICurrencyQuantityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CurrencyQuantityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CurrencyQuantityProto;
            public static toObject(message: POGOProtos.Rpc.CurrencyQuantityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICurrentEventsSectionProto {
            events?: (POGOProtos.Rpc.IEventSectionProto[]|null);
        }

        class CurrentEventsSectionProto implements ICurrentEventsSectionProto {
            constructor(properties?: POGOProtos.Rpc.ICurrentEventsSectionProto);
            public events: POGOProtos.Rpc.IEventSectionProto[];
            public static encode(message: POGOProtos.Rpc.ICurrentEventsSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CurrentEventsSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CurrentEventsSectionProto;
            public static toObject(message: POGOProtos.Rpc.CurrentEventsSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICurrentNewsProto {
            news_articles?: (POGOProtos.Rpc.INewsArticleProto[]|null);
            news_strings_url?: (string|null);
            last_updated_timestamp?: (number|Long|null);
        }

        class CurrentNewsProto implements ICurrentNewsProto {
            constructor(properties?: POGOProtos.Rpc.ICurrentNewsProto);
            public news_articles: POGOProtos.Rpc.INewsArticleProto[];
            public news_strings_url: string;
            public last_updated_timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.ICurrentNewsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CurrentNewsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CurrentNewsProto;
            public static toObject(message: POGOProtos.Rpc.CurrentNewsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ICustomizeQuestTabProto {
            sections?: (POGOProtos.Rpc.ITodayViewSectionProto[]|null);
        }

        class CustomizeQuestTabProto implements ICustomizeQuestTabProto {
            constructor(properties?: POGOProtos.Rpc.ICustomizeQuestTabProto);
            public sections: POGOProtos.Rpc.ITodayViewSectionProto[];
            public static encode(message: POGOProtos.Rpc.ICustomizeQuestTabProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.CustomizeQuestTabProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.CustomizeQuestTabProto;
            public static toObject(message: POGOProtos.Rpc.CustomizeQuestTabProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyAdventureIncenseLogEntry {
            day_bucket?: (number|Long|null);
        }

        class DailyAdventureIncenseLogEntry implements IDailyAdventureIncenseLogEntry {
            constructor(properties?: POGOProtos.Rpc.IDailyAdventureIncenseLogEntry);
            public day_bucket: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDailyAdventureIncenseLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyAdventureIncenseLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyAdventureIncenseLogEntry;
            public static toObject(message: POGOProtos.Rpc.DailyAdventureIncenseLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyAdventureIncenseRecapDayDisplayProto {
            distance_walked_km?: (number|null);
            pokemon_captured?: (POGOProtos.Rpc.IPokemonDisplayProto[]|null);
            pokemon_fled?: (POGOProtos.Rpc.IPokemonDisplayProto[]|null);
            distinct_pokestops_visited?: (number|null);
        }

        class DailyAdventureIncenseRecapDayDisplayProto implements IDailyAdventureIncenseRecapDayDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IDailyAdventureIncenseRecapDayDisplayProto);
            public distance_walked_km: number;
            public pokemon_captured: POGOProtos.Rpc.IPokemonDisplayProto[];
            public pokemon_fled: POGOProtos.Rpc.IPokemonDisplayProto[];
            public distinct_pokestops_visited: number;
            public static encode(message: POGOProtos.Rpc.IDailyAdventureIncenseRecapDayDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyAdventureIncenseRecapDayDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyAdventureIncenseRecapDayDisplayProto;
            public static toObject(message: POGOProtos.Rpc.DailyAdventureIncenseRecapDayDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyAdventureIncenseSettingsProto {
            enabled?: (boolean|null);
            pokeball_grant_threshold?: (number|null);
            pokeball_grant?: (POGOProtos.Rpc.ILootProto|null);
            local_delivery_time?: (string|null);
            enable_push_notification?: (boolean|null);
            push_notification_hour_of_day?: (number|null);
            can_be_paused?: (boolean|null);
            push_notification_after_time_of_day_minutes?: (number|null);
            push_notification_before_time_of_day_minutes?: (number|null);
        }

        class DailyAdventureIncenseSettingsProto implements IDailyAdventureIncenseSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDailyAdventureIncenseSettingsProto);
            public enabled: boolean;
            public pokeball_grant_threshold: number;
            public pokeball_grant?: (POGOProtos.Rpc.ILootProto|null);
            public local_delivery_time: string;
            public enable_push_notification: boolean;
            public push_notification_hour_of_day: number;
            public can_be_paused: boolean;
            public push_notification_after_time_of_day_minutes: number;
            public push_notification_before_time_of_day_minutes: number;
            public static encode(message: POGOProtos.Rpc.IDailyAdventureIncenseSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyAdventureIncenseSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyAdventureIncenseSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DailyAdventureIncenseSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyAdventureIncenseTelemetry {
            event_id?: (POGOProtos.Rpc.DailyAdventureIncenseTelemetry.TelemetryIds|null);
            from_journal?: (boolean|null);
        }

        class DailyAdventureIncenseTelemetry implements IDailyAdventureIncenseTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDailyAdventureIncenseTelemetry);
            public event_id: POGOProtos.Rpc.DailyAdventureIncenseTelemetry.TelemetryIds;
            public from_journal: boolean;
            public static encode(message: POGOProtos.Rpc.IDailyAdventureIncenseTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyAdventureIncenseTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyAdventureIncenseTelemetry;
            public static toObject(message: POGOProtos.Rpc.DailyAdventureIncenseTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DailyAdventureIncenseTelemetry {

            enum TelemetryIds {
                UNSET = 0,
                VIEW_RECAP = 1,
                CLICK_SHARE_FROM_RECAP = 2,
                CLICK_SHARE_FROM_PHOTO_COLLECTION = 3
            }
        }

        interface IDailyBonusProto {
            next_collect_timestamp_ms?: (number|Long|null);
            next_defender_bonus_collect_timestamp_ms?: (number|Long|null);
        }

        class DailyBonusProto implements IDailyBonusProto {
            constructor(properties?: POGOProtos.Rpc.IDailyBonusProto);
            public next_collect_timestamp_ms: (number|Long);
            public next_defender_bonus_collect_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDailyBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyBonusProto;
            public static toObject(message: POGOProtos.Rpc.DailyBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyBuddyAffectionQuestProto {
            daily_affection_counter?: (POGOProtos.Rpc.IDailyCounterProto|null);
        }

        class DailyBuddyAffectionQuestProto implements IDailyBuddyAffectionQuestProto {
            constructor(properties?: POGOProtos.Rpc.IDailyBuddyAffectionQuestProto);
            public daily_affection_counter?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public static encode(message: POGOProtos.Rpc.IDailyBuddyAffectionQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyBuddyAffectionQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyBuddyAffectionQuestProto;
            public static toObject(message: POGOProtos.Rpc.DailyBuddyAffectionQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyCounterProto {
            window?: (number|Long|null);
            count?: (number|null);
            buckets_per_day?: (number|null);
        }

        class DailyCounterProto implements IDailyCounterProto {
            constructor(properties?: POGOProtos.Rpc.IDailyCounterProto);
            public window: (number|Long);
            public count: number;
            public buckets_per_day: number;
            public static encode(message: POGOProtos.Rpc.IDailyCounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyCounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyCounterProto;
            public static toObject(message: POGOProtos.Rpc.DailyCounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyEncounterGlobalSettingsProto {
            enabled?: (boolean|null);
        }

        class DailyEncounterGlobalSettingsProto implements IDailyEncounterGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDailyEncounterGlobalSettingsProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IDailyEncounterGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyEncounterGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyEncounterGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DailyEncounterGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyEncounterOutProto {
            result?: (POGOProtos.Rpc.DailyEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class DailyEncounterOutProto implements IDailyEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IDailyEncounterOutProto);
            public result: POGOProtos.Rpc.DailyEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IDailyEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.DailyEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DailyEncounterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ENCOUNTER_NOT_AVAILABLE = 2,
                POKEMON_INVENTORY_FULL = 3
            }
        }

        interface IDailyEncounterProto {
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
        }

        class DailyEncounterProto implements IDailyEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IDailyEncounterProto);
            public encounter_id: (number|Long);
            public encounter_location: string;
            public static encode(message: POGOProtos.Rpc.IDailyEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyEncounterProto;
            public static toObject(message: POGOProtos.Rpc.DailyEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyQuestProto {
            current_period_bucket?: (number|null);
            current_streak_count?: (number|null);
            prev_streak_notification_timestamp_ms?: (number|Long|null);
        }

        class DailyQuestProto implements IDailyQuestProto {
            constructor(properties?: POGOProtos.Rpc.IDailyQuestProto);
            public current_period_bucket: number;
            public current_streak_count: number;
            public prev_streak_notification_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDailyQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyQuestProto;
            public static toObject(message: POGOProtos.Rpc.DailyQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyQuestSettings {
            buckets_per_day?: (number|null);
            streak_length?: (number|null);
            bonus_multiplier?: (number|null);
            streak_bonus_multiplier?: (number|null);
            disable?: (boolean|null);
            prevent_streak_broken?: (boolean|null);
        }

        class DailyQuestSettings implements IDailyQuestSettings {
            constructor(properties?: POGOProtos.Rpc.IDailyQuestSettings);
            public buckets_per_day: number;
            public streak_length: number;
            public bonus_multiplier: number;
            public streak_bonus_multiplier: number;
            public disable: boolean;
            public prevent_streak_broken: boolean;
            public static encode(message: POGOProtos.Rpc.IDailyQuestSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyQuestSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyQuestSettings;
            public static toObject(message: POGOProtos.Rpc.DailyQuestSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDailyStreaksProto {
            streaks?: (POGOProtos.Rpc.DailyStreaksProto.IStreakProto[]|null);
        }

        class DailyStreaksProto implements IDailyStreaksProto {
            constructor(properties?: POGOProtos.Rpc.IDailyStreaksProto);
            public streaks: POGOProtos.Rpc.DailyStreaksProto.IStreakProto[];
            public static encode(message: POGOProtos.Rpc.IDailyStreaksProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyStreaksProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyStreaksProto;
            public static toObject(message: POGOProtos.Rpc.DailyStreaksProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DailyStreaksProto {

            interface IStreakProto {
                quest_type?: (POGOProtos.Rpc.QuestType|null);
                count?: (number|null);
                target?: (number|null);
                remaining_today?: (number|null);
            }

            class StreakProto implements IStreakProto {
                constructor(properties?: POGOProtos.Rpc.DailyStreaksProto.IStreakProto);
                public quest_type: POGOProtos.Rpc.QuestType;
                public count: number;
                public target: number;
                public remaining_today: number;
                public static encode(message: POGOProtos.Rpc.DailyStreaksProto.IStreakProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyStreaksProto.StreakProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyStreaksProto.StreakProto;
                public static toObject(message: POGOProtos.Rpc.DailyStreaksProto.StreakProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IDailyStreaksWidgetProto {
            streaks?: (POGOProtos.Rpc.DailyStreaksWidgetProto.IStreakProto[]|null);
            timestamp_ms?: (number|Long|null);
        }

        class DailyStreaksWidgetProto implements IDailyStreaksWidgetProto {
            constructor(properties?: POGOProtos.Rpc.IDailyStreaksWidgetProto);
            public streaks: POGOProtos.Rpc.DailyStreaksWidgetProto.IStreakProto[];
            public timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDailyStreaksWidgetProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyStreaksWidgetProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyStreaksWidgetProto;
            public static toObject(message: POGOProtos.Rpc.DailyStreaksWidgetProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DailyStreaksWidgetProto {

            enum QuestType {
                QUEST_UNSET = 0,
                QUEST_FIRST_CATCH_OF_THE_DAY = 1,
                QUEST_FIRST_POKESTOP_OF_THE_DAY = 2
            }

            interface IStreakProto {
                quest_type?: (POGOProtos.Rpc.DailyStreaksWidgetProto.QuestType|null);
                count?: (number|null);
                target?: (number|null);
                remaining_today?: (number|null);
            }

            class StreakProto implements IStreakProto {
                constructor(properties?: POGOProtos.Rpc.DailyStreaksWidgetProto.IStreakProto);
                public quest_type: POGOProtos.Rpc.DailyStreaksWidgetProto.QuestType;
                public count: number;
                public target: number;
                public remaining_today: number;
                public static encode(message: POGOProtos.Rpc.DailyStreaksWidgetProto.IStreakProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DailyStreaksWidgetProto.StreakProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DailyStreaksWidgetProto.StreakProto;
                public static toObject(message: POGOProtos.Rpc.DailyStreaksWidgetProto.StreakProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IDamagePropertyProto {
            super_effective_charge_move?: (boolean|null);
            weather_boosted?: (boolean|null);
        }

        class DamagePropertyProto implements IDamagePropertyProto {
            constructor(properties?: POGOProtos.Rpc.IDamagePropertyProto);
            public super_effective_charge_move: boolean;
            public weather_boosted: boolean;
            public static encode(message: POGOProtos.Rpc.IDamagePropertyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DamagePropertyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DamagePropertyProto;
            public static toObject(message: POGOProtos.Rpc.DamagePropertyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDatapoint {
            long?: (number|Long|null);
            double?: (number|null);
            boolean?: (boolean|null);
            kind?: (POGOProtos.Rpc.Datapoint.Kind|null);
        }

        class Datapoint implements IDatapoint {
            constructor(properties?: POGOProtos.Rpc.IDatapoint);
            public long?: (number|Long|null);
            public double?: (number|null);
            public boolean?: (boolean|null);
            public kind: POGOProtos.Rpc.Datapoint.Kind;
            public Value?: ("long"|"double"|"boolean");
            public static encode(message: POGOProtos.Rpc.IDatapoint, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Datapoint;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Datapoint;
            public static toObject(message: POGOProtos.Rpc.Datapoint, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Datapoint {

            enum Kind {
                unspecified = 0,
                gauge = 1,
                delta = 2,
                cumulative = 3
            }
        }

        interface IDawnDuskSettingsProto {
            dawn_start_offset_before_sunrise_ms?: (number|Long|null);
            dawn_end_offset_after_sunrise_ms?: (number|Long|null);
            dusk_start_offset_before_sunset_ms?: (number|Long|null);
            dusk_end_offset_after_sunset_ms?: (number|Long|null);
        }

        class DawnDuskSettingsProto implements IDawnDuskSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDawnDuskSettingsProto);
            public dawn_start_offset_before_sunrise_ms: (number|Long);
            public dawn_end_offset_after_sunrise_ms: (number|Long);
            public dusk_start_offset_before_sunset_ms: (number|Long);
            public dusk_end_offset_after_sunset_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDawnDuskSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DawnDuskSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DawnDuskSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DawnDuskSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDayNightBonusSettingsProto {
            incense_item?: (POGOProtos.Rpc.Item|null);
        }

        class DayNightBonusSettingsProto implements IDayNightBonusSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDayNightBonusSettingsProto);
            public incense_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IDayNightBonusSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DayNightBonusSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DayNightBonusSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DayNightBonusSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDayOfWeekAndTimeProto {
            day_of_week?: (number|null);
            hour_of_day?: (number|null);
        }

        class DayOfWeekAndTimeProto implements IDayOfWeekAndTimeProto {
            constructor(properties?: POGOProtos.Rpc.IDayOfWeekAndTimeProto);
            public day_of_week: number;
            public hour_of_day: number;
            public static encode(message: POGOProtos.Rpc.IDayOfWeekAndTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DayOfWeekAndTimeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DayOfWeekAndTimeProto;
            public static toObject(message: POGOProtos.Rpc.DayOfWeekAndTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDaysWithARowQuestProto {
            last_window?: (number|null);
        }

        class DaysWithARowQuestProto implements IDaysWithARowQuestProto {
            constructor(properties?: POGOProtos.Rpc.IDaysWithARowQuestProto);
            public last_window: number;
            public static encode(message: POGOProtos.Rpc.IDaysWithARowQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DaysWithARowQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DaysWithARowQuestProto;
            public static toObject(message: POGOProtos.Rpc.DaysWithARowQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDebugCreateNpcBattleInstanceOutProto {
            result?: (POGOProtos.Rpc.DebugCreateNpcBattleInstanceOutProto.Result|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            session_player_id?: (string|null);
            session_id?: (string|null);
        }

        class DebugCreateNpcBattleInstanceOutProto implements IDebugCreateNpcBattleInstanceOutProto {
            constructor(properties?: POGOProtos.Rpc.IDebugCreateNpcBattleInstanceOutProto);
            public result: POGOProtos.Rpc.DebugCreateNpcBattleInstanceOutProto.Result;
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public session_player_id: string;
            public session_id: string;
            public static encode(message: POGOProtos.Rpc.IDebugCreateNpcBattleInstanceOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DebugCreateNpcBattleInstanceOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DebugCreateNpcBattleInstanceOutProto;
            public static toObject(message: POGOProtos.Rpc.DebugCreateNpcBattleInstanceOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DebugCreateNpcBattleInstanceOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IDebugCreateNpcBattleInstanceProto {
            roster?: ((number|Long)[]|null);
            cp_multiplier?: (number|null);
            stamina?: (number|null);
            character?: (POGOProtos.Rpc.NpcBattle.Character|null);
            optional_feature?: (POGOProtos.Rpc.DebugCreateNpcBattleInstanceProto.AddedFeature[]|null);
        }

        class DebugCreateNpcBattleInstanceProto implements IDebugCreateNpcBattleInstanceProto {
            constructor(properties?: POGOProtos.Rpc.IDebugCreateNpcBattleInstanceProto);
            public roster: (number|Long)[];
            public cp_multiplier: number;
            public stamina: number;
            public character: POGOProtos.Rpc.NpcBattle.Character;
            public optional_feature: POGOProtos.Rpc.DebugCreateNpcBattleInstanceProto.AddedFeature[];
            public static encode(message: POGOProtos.Rpc.IDebugCreateNpcBattleInstanceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DebugCreateNpcBattleInstanceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DebugCreateNpcBattleInstanceProto;
            public static toObject(message: POGOProtos.Rpc.DebugCreateNpcBattleInstanceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DebugCreateNpcBattleInstanceProto {

            enum AddedFeature {
                UNSET = 0,
                ENABLE_IBFC = 1
            }
        }

        interface IDebugEvolvePreviewProto {
            expected_buddy_km_walked?: (number|null);
            expected_distance_progress_km_since_set_or_candy_award?: (number|null);
        }

        class DebugEvolvePreviewProto implements IDebugEvolvePreviewProto {
            constructor(properties?: POGOProtos.Rpc.IDebugEvolvePreviewProto);
            public expected_buddy_km_walked: number;
            public expected_distance_progress_km_since_set_or_candy_award: number;
            public static encode(message: POGOProtos.Rpc.IDebugEvolvePreviewProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DebugEvolvePreviewProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DebugEvolvePreviewProto;
            public static toObject(message: POGOProtos.Rpc.DebugEvolvePreviewProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDebugInfoProto {
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class DebugInfoProto implements IDebugInfoProto {
            constructor(properties?: POGOProtos.Rpc.IDebugInfoProto);
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IDebugInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DebugInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DebugInfoProto;
            public static toObject(message: POGOProtos.Rpc.DebugInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDebugResetDailyMpProgressOutProto {
            result?: (POGOProtos.Rpc.DebugResetDailyMpProgressOutProto.Result|null);
        }

        class DebugResetDailyMpProgressOutProto implements IDebugResetDailyMpProgressOutProto {
            constructor(properties?: POGOProtos.Rpc.IDebugResetDailyMpProgressOutProto);
            public result: POGOProtos.Rpc.DebugResetDailyMpProgressOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDebugResetDailyMpProgressOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DebugResetDailyMpProgressOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DebugResetDailyMpProgressOutProto;
            public static toObject(message: POGOProtos.Rpc.DebugResetDailyMpProgressOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DebugResetDailyMpProgressOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_ACTION_NEEDED = 2,
                ERROR_DEBUG_FLAG_DISABLED = 3
            }
        }

        interface IDebugResetDailyMpProgressProto {
        }

        class DebugResetDailyMpProgressProto implements IDebugResetDailyMpProgressProto {
            constructor(properties?: POGOProtos.Rpc.IDebugResetDailyMpProgressProto);
            public static encode(message: POGOProtos.Rpc.IDebugResetDailyMpProgressProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DebugResetDailyMpProgressProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DebugResetDailyMpProgressProto;
            public static toObject(message: POGOProtos.Rpc.DebugResetDailyMpProgressProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeclineCombatChallengeData {
            rpc_id?: (number|null);
        }

        class DeclineCombatChallengeData implements IDeclineCombatChallengeData {
            constructor(properties?: POGOProtos.Rpc.IDeclineCombatChallengeData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IDeclineCombatChallengeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeclineCombatChallengeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeclineCombatChallengeData;
            public static toObject(message: POGOProtos.Rpc.DeclineCombatChallengeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeclineCombatChallengeOutProto {
            result?: (POGOProtos.Rpc.DeclineCombatChallengeOutProto.Result|null);
        }

        class DeclineCombatChallengeOutProto implements IDeclineCombatChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeclineCombatChallengeOutProto);
            public result: POGOProtos.Rpc.DeclineCombatChallengeOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeclineCombatChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeclineCombatChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeclineCombatChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.DeclineCombatChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeclineCombatChallengeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_CHALLENGE_STATE = 2,
                ERROR_CHALLENGE_NOT_FOUND = 3,
                ERROR_ALREADY_TIMEDOUT = 4,
                ERROR_ALREADY_CANCELLED = 5
            }
        }

        interface IDeclineCombatChallengeProto {
            challenge_id?: (string|null);
        }

        class DeclineCombatChallengeProto implements IDeclineCombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.IDeclineCombatChallengeProto);
            public challenge_id: string;
            public static encode(message: POGOProtos.Rpc.IDeclineCombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeclineCombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeclineCombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.DeclineCombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeclineCombatChallengeResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.DeclineCombatChallengeOutProto.Result|null);
        }

        class DeclineCombatChallengeResponseData implements IDeclineCombatChallengeResponseData {
            constructor(properties?: POGOProtos.Rpc.IDeclineCombatChallengeResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.DeclineCombatChallengeOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeclineCombatChallengeResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeclineCombatChallengeResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeclineCombatChallengeResponseData;
            public static toObject(message: POGOProtos.Rpc.DeclineCombatChallengeResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeclinePartyInviteOutProto {
            result?: (POGOProtos.Rpc.DeclinePartyInviteOutProto.Result|null);
        }

        class DeclinePartyInviteOutProto implements IDeclinePartyInviteOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeclinePartyInviteOutProto);
            public result: POGOProtos.Rpc.DeclinePartyInviteOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeclinePartyInviteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeclinePartyInviteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeclinePartyInviteOutProto;
            public static toObject(message: POGOProtos.Rpc.DeclinePartyInviteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeclinePartyInviteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVITE_NOT_FOUND = 3,
                ERROR_ALREADY_DECLINED = 4
            }
        }

        interface IDeclinePartyInviteProto {
            party_id?: (number|Long|null);
            inviter_id?: (string|null);
        }

        class DeclinePartyInviteProto implements IDeclinePartyInviteProto {
            constructor(properties?: POGOProtos.Rpc.IDeclinePartyInviteProto);
            public party_id: (number|Long);
            public inviter_id: string;
            public static encode(message: POGOProtos.Rpc.IDeclinePartyInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeclinePartyInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeclinePartyInviteProto;
            public static toObject(message: POGOProtos.Rpc.DeclinePartyInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeepLinkingEnumWrapperProto {
        }

        class DeepLinkingEnumWrapperProto implements IDeepLinkingEnumWrapperProto {
            constructor(properties?: POGOProtos.Rpc.IDeepLinkingEnumWrapperProto);
            public static encode(message: POGOProtos.Rpc.IDeepLinkingEnumWrapperProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeepLinkingEnumWrapperProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeepLinkingEnumWrapperProto;
            public static toObject(message: POGOProtos.Rpc.DeepLinkingEnumWrapperProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeepLinkingEnumWrapperProto {

            enum DeepLinkingActionName {
                UNSET = 0,
                OPEN_SHOP = 1,
                OPEN_NEWS = 2,
                OPEN_BATTLE_LEAGUE = 3,
                OPEN_SETTINGS = 4,
                OPEN_PLAYER_PROFILE = 5,
                OPEN_BUDDY = 6,
                OPEN_AVATAR_ITEMS = 7,
                OPEN_QUEST_LIST = 8,
                OPEN_POKEMON_INVENTORY = 9,
                OPEN_NEARBY_POKEMON = 10,
                OPEN_POKEDEX = 11,
                OPEN_EVENTS = 12,
                OPEN_JOURNAL = 13,
                OPEN_TIPS = 14,
                OPEN_ITEM_INVENTORY = 15,
                FILL_REFERRAL_CODE = 16,
                OPEN_ADDRESS_BOOK = 17,
                OPEN_EGG_HATCH = 18,
                OPEN_GYM = 19,
                OPEN_RAID = 20,
                USE_DAILY_INCENSE = 21,
                OPEN_DEFENDING_GYM = 22,
                OPEN_NEARBY_GYM = 23,
                REDEEM_PASSCODE = 24,
                OPEN_CONTEST_REWARD = 25,
                ADD_FRIEND = 26,
                OPEN_CAMPFIRE = 27,
                OPEN_PARTY = 28,
                OPEN_NEARBY_POWERSPOT = 29,
                BEGIN_PERMISSIONS_FLOW = 30,
                OPEN_NEARBY_POI = 31,
                OPEN_UPLOADS_SETTINGS = 32,
                OPEN_PLANNER_NOTIFICATION = 33,
                PASSWORDLESS_LOGIN_TO_WEBSTORE = 34,
                OPEN_MAX_BATTLE = 35
            }

            enum PermissionsFlow {
                SMART_GLASSES_SYNC_SETTINGS = 0
            }

            enum NearbyPokemonTab {
                NEARBY_POKEMON = 0,
                RAIDS = 1,
                ROUTES = 2,
                STATIONS = 3,
                RSVPS = 4
            }

            enum PlayerProfileTab {
                PROFILE = 0,
                FRIENDS = 1,
                PARTY_PLAY = 2
            }

            enum PokemonInventoryTab {
                COMBAT_PARTY = 0,
                POKEMON = 1,
                EGGS = 2
            }

            enum QuestListTab {
                TODAY_VIEW = 0,
                FIELD_RESEARCH = 1,
                SPECIAL_RESEARCH = 2
            }

            enum NotificationsNewsTab {
                NEWS = 0,
                NOTIFICATIONS = 1
            }
        }

        interface IDeepLinkingSettingsProto {
            min_player_level_for_external_link?: (number|null);
            min_player_level_for_notification_link?: (number|null);
            actions_that_ignore_min_level?: (POGOProtos.Rpc.DeepLinkingEnumWrapperProto.DeepLinkingActionName[]|null);
            actions_that_execute_before_map_loads?: (POGOProtos.Rpc.DeepLinkingEnumWrapperProto.DeepLinkingActionName[]|null);
            ios_action_button_enabled?: (boolean|null);
        }

        class DeepLinkingSettingsProto implements IDeepLinkingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDeepLinkingSettingsProto);
            public min_player_level_for_external_link: number;
            public min_player_level_for_notification_link: number;
            public actions_that_ignore_min_level: POGOProtos.Rpc.DeepLinkingEnumWrapperProto.DeepLinkingActionName[];
            public actions_that_execute_before_map_loads: POGOProtos.Rpc.DeepLinkingEnumWrapperProto.DeepLinkingActionName[];
            public ios_action_button_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IDeepLinkingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeepLinkingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeepLinkingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DeepLinkingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeepLinkingTelemetry {
            action_name?: (string|null);
            link_source?: (POGOProtos.Rpc.DeepLinkingTelemetry.LinkSource|null);
        }

        class DeepLinkingTelemetry implements IDeepLinkingTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDeepLinkingTelemetry);
            public action_name: string;
            public link_source: POGOProtos.Rpc.DeepLinkingTelemetry.LinkSource;
            public static encode(message: POGOProtos.Rpc.IDeepLinkingTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeepLinkingTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeepLinkingTelemetry;
            public static toObject(message: POGOProtos.Rpc.DeepLinkingTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeepLinkingTelemetry {

            enum LinkSource {
                UNKNOWN = 0,
                URL = 1,
                NOTIFICATION = 2
            }
        }

        interface IDeleteGiftFromInventoryOutProto {
            result?: (POGOProtos.Rpc.DeleteGiftFromInventoryOutProto.Result|null);
        }

        class DeleteGiftFromInventoryOutProto implements IDeleteGiftFromInventoryOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeleteGiftFromInventoryOutProto);
            public result: POGOProtos.Rpc.DeleteGiftFromInventoryOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeleteGiftFromInventoryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteGiftFromInventoryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteGiftFromInventoryOutProto;
            public static toObject(message: POGOProtos.Rpc.DeleteGiftFromInventoryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeleteGiftFromInventoryOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_GIFT_DOES_NOT_EXIST = 3
            }
        }

        interface IDeleteGiftFromInventoryProto {
            giftbox_id?: ((number|Long)[]|null);
        }

        class DeleteGiftFromInventoryProto implements IDeleteGiftFromInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IDeleteGiftFromInventoryProto);
            public giftbox_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IDeleteGiftFromInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteGiftFromInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteGiftFromInventoryProto;
            public static toObject(message: POGOProtos.Rpc.DeleteGiftFromInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeleteGiftOutProto {
            result?: (POGOProtos.Rpc.DeleteGiftOutProto.Result|null);
        }

        class DeleteGiftOutProto implements IDeleteGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeleteGiftOutProto);
            public result: POGOProtos.Rpc.DeleteGiftOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeleteGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.DeleteGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeleteGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_PLAYER_ID = 3,
                ERROR_FRIEND_NOT_FOUND = 4,
                ERROR_GIFT_DOES_NOT_EXIST = 5,
                ERROR_FRIEND_UPDATE = 6
            }
        }

        interface IDeleteGiftProto {
            player_id?: (string|null);
            giftbox_id?: (number|Long|null);
        }

        class DeleteGiftProto implements IDeleteGiftProto {
            constructor(properties?: POGOProtos.Rpc.IDeleteGiftProto);
            public player_id: string;
            public giftbox_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDeleteGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteGiftProto;
            public static toObject(message: POGOProtos.Rpc.DeleteGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeleteNewsfeedRequest {
            app_id?: (string|null);
            campaign_id?: (number|Long|null);
        }

        class DeleteNewsfeedRequest implements IDeleteNewsfeedRequest {
            constructor(properties?: POGOProtos.Rpc.IDeleteNewsfeedRequest);
            public app_id: string;
            public campaign_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDeleteNewsfeedRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteNewsfeedRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteNewsfeedRequest;
            public static toObject(message: POGOProtos.Rpc.DeleteNewsfeedRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeleteNewsfeedResponse {
            result?: (POGOProtos.Rpc.DeleteNewsfeedResponse.Result|null);
        }

        class DeleteNewsfeedResponse implements IDeleteNewsfeedResponse {
            constructor(properties?: POGOProtos.Rpc.IDeleteNewsfeedResponse);
            public result: POGOProtos.Rpc.DeleteNewsfeedResponse.Result;
            public static encode(message: POGOProtos.Rpc.IDeleteNewsfeedResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteNewsfeedResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteNewsfeedResponse;
            public static toObject(message: POGOProtos.Rpc.DeleteNewsfeedResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeleteNewsfeedResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILED = 2,
                NOT_FOUND = 3
            }
        }

        interface IDeletePokemonTagOutProto {
            result?: (POGOProtos.Rpc.DeletePokemonTagOutProto.Result|null);
        }

        class DeletePokemonTagOutProto implements IDeletePokemonTagOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeletePokemonTagOutProto);
            public result: POGOProtos.Rpc.DeletePokemonTagOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeletePokemonTagOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeletePokemonTagOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeletePokemonTagOutProto;
            public static toObject(message: POGOProtos.Rpc.DeletePokemonTagOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeletePokemonTagOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                TAG_DOES_NOT_EXIST = 3
            }
        }

        interface IDeletePokemonTagProto {
            tag_id?: (number|Long|null);
        }

        class DeletePokemonTagProto implements IDeletePokemonTagProto {
            constructor(properties?: POGOProtos.Rpc.IDeletePokemonTagProto);
            public tag_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDeletePokemonTagProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeletePokemonTagProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeletePokemonTagProto;
            public static toObject(message: POGOProtos.Rpc.DeletePokemonTagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeletePostcardOutProto {
            result?: (POGOProtos.Rpc.DeletePostcardOutProto.Result|null);
            postcard?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
        }

        class DeletePostcardOutProto implements IDeletePostcardOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeletePostcardOutProto);
            public result: POGOProtos.Rpc.DeletePostcardOutProto.Result;
            public postcard?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IDeletePostcardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeletePostcardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeletePostcardOutProto;
            public static toObject(message: POGOProtos.Rpc.DeletePostcardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeletePostcardOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POSTCARD_DOES_NOT_EXIST = 2,
                ERROR_POSTCARD_FAVORITED = 3,
                ERROR_NOT_ENABLED = 4
            }
        }

        interface IDeletePostcardProto {
            postcard_id?: (string|null);
        }

        class DeletePostcardProto implements IDeletePostcardProto {
            constructor(properties?: POGOProtos.Rpc.IDeletePostcardProto);
            public postcard_id: string;
            public static encode(message: POGOProtos.Rpc.IDeletePostcardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeletePostcardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeletePostcardProto;
            public static toObject(message: POGOProtos.Rpc.DeletePostcardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeletePostcardsOutProto {
            result?: (POGOProtos.Rpc.DeletePostcardsOutProto.Result|null);
            postcards?: (POGOProtos.Rpc.IPostcardDisplayProto[]|null);
        }

        class DeletePostcardsOutProto implements IDeletePostcardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeletePostcardsOutProto);
            public result: POGOProtos.Rpc.DeletePostcardsOutProto.Result;
            public postcards: POGOProtos.Rpc.IPostcardDisplayProto[];
            public static encode(message: POGOProtos.Rpc.IDeletePostcardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeletePostcardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeletePostcardsOutProto;
            public static toObject(message: POGOProtos.Rpc.DeletePostcardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeletePostcardsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POSTCARD_DOES_NOT_EXIST = 2,
                ERROR_POSTCARD_FAVORITED = 3,
                ERROR_NOT_ENABLED = 4
            }
        }

        interface IDeletePostcardsProto {
            postcard_ids?: (string[]|null);
        }

        class DeletePostcardsProto implements IDeletePostcardsProto {
            constructor(properties?: POGOProtos.Rpc.IDeletePostcardsProto);
            public postcard_ids: string[];
            public static encode(message: POGOProtos.Rpc.IDeletePostcardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeletePostcardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeletePostcardsProto;
            public static toObject(message: POGOProtos.Rpc.DeletePostcardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeleteRouteDraftOutProto {
            result?: (POGOProtos.Rpc.DeleteRouteDraftOutProto.Result|null);
        }

        class DeleteRouteDraftOutProto implements IDeleteRouteDraftOutProto {
            constructor(properties?: POGOProtos.Rpc.IDeleteRouteDraftOutProto);
            public result: POGOProtos.Rpc.DeleteRouteDraftOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IDeleteRouteDraftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteRouteDraftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteRouteDraftOutProto;
            public static toObject(message: POGOProtos.Rpc.DeleteRouteDraftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeleteRouteDraftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                SUCCESS_ROUTE_NOT_FOUND = -1,
                ERROR_UNKNOWN = 3,
                ERROR_ROUTE_NOT_EDITABLE = 4
            }
        }

        interface IDeleteRouteDraftProto {
            route_id?: (string|null);
        }

        class DeleteRouteDraftProto implements IDeleteRouteDraftProto {
            constructor(properties?: POGOProtos.Rpc.IDeleteRouteDraftProto);
            public route_id: string;
            public static encode(message: POGOProtos.Rpc.IDeleteRouteDraftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteRouteDraftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteRouteDraftProto;
            public static toObject(message: POGOProtos.Rpc.DeleteRouteDraftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeleteValueRequest {
            key?: (POGOProtos.Rpc.IKey|null);
        }

        class DeleteValueRequest implements IDeleteValueRequest {
            constructor(properties?: POGOProtos.Rpc.IDeleteValueRequest);
            public key?: (POGOProtos.Rpc.IKey|null);
            public static encode(message: POGOProtos.Rpc.IDeleteValueRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteValueRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteValueRequest;
            public static toObject(message: POGOProtos.Rpc.DeleteValueRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeleteValueResponse {
        }

        class DeleteValueResponse implements IDeleteValueResponse {
            constructor(properties?: POGOProtos.Rpc.IDeleteValueResponse);
            public static encode(message: POGOProtos.Rpc.IDeleteValueResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeleteValueResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeleteValueResponse;
            public static toObject(message: POGOProtos.Rpc.DeleteValueResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeployPokemonTelemetry {
            status?: (number|null);
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            gym_id?: (string|null);
            team?: (POGOProtos.Rpc.Team|null);
            defender_count?: (number|null);
        }

        class DeployPokemonTelemetry implements IDeployPokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDeployPokemonTelemetry);
            public status: number;
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public gym_id: string;
            public team: POGOProtos.Rpc.Team;
            public defender_count: number;
            public static encode(message: POGOProtos.Rpc.IDeployPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeployPokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeployPokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.DeployPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeploymentTotalsProto {
            times_fed?: (number|null);
            battles_won?: (number|null);
            battles_lost?: (number|null);
            deployment_duration_ms?: (number|Long|null);
        }

        class DeploymentTotalsProto implements IDeploymentTotalsProto {
            constructor(properties?: POGOProtos.Rpc.IDeploymentTotalsProto);
            public times_fed: number;
            public battles_won: number;
            public battles_lost: number;
            public deployment_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDeploymentTotalsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeploymentTotalsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeploymentTotalsProto;
            public static toObject(message: POGOProtos.Rpc.DeploymentTotalsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeprecatedCaptureInfoProto {
            small_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            large_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            depth_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            grid_size?: (number|null);
            min_weight?: (number|null);
            point_count?: (number|null);
            capture_build?: (number|Long|null);
            device?: (string|null);
        }

        class DeprecatedCaptureInfoProto implements IDeprecatedCaptureInfoProto {
            constructor(properties?: POGOProtos.Rpc.IDeprecatedCaptureInfoProto);
            public small_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public large_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public depth_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public grid_size: number;
            public min_weight: number;
            public point_count: number;
            public capture_build: (number|Long);
            public device: string;
            public static encode(message: POGOProtos.Rpc.IDeprecatedCaptureInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeprecatedCaptureInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeprecatedCaptureInfoProto;
            public static toObject(message: POGOProtos.Rpc.DeprecatedCaptureInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDepthStartEvent {
            empty_field?: (boolean|null);
        }

        class DepthStartEvent implements IDepthStartEvent {
            constructor(properties?: POGOProtos.Rpc.IDepthStartEvent);
            public empty_field: boolean;
            public static encode(message: POGOProtos.Rpc.IDepthStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DepthStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DepthStartEvent;
            public static toObject(message: POGOProtos.Rpc.DepthStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDepthStopEvent {
            time_elapsed_ms?: (number|null);
        }

        class DepthStopEvent implements IDepthStopEvent {
            constructor(properties?: POGOProtos.Rpc.IDepthStopEvent);
            public time_elapsed_ms: number;
            public static encode(message: POGOProtos.Rpc.IDepthStopEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DepthStopEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DepthStopEvent;
            public static toObject(message: POGOProtos.Rpc.DepthStopEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDescriptorProto {
            name?: (string|null);
            field?: (POGOProtos.Rpc.IFieldDescriptorProto[]|null);
            nested_type?: (POGOProtos.Rpc.IDescriptorProto[]|null);
            enum_type?: (POGOProtos.Rpc.IEnumDescriptorProto[]|null);
            oneof_decl?: (POGOProtos.Rpc.IOneofDescriptorProto[]|null);
            options?: (POGOProtos.Rpc.IMessageOptions|null);
        }

        class DescriptorProto implements IDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IDescriptorProto);
            public name: string;
            public field: POGOProtos.Rpc.IFieldDescriptorProto[];
            public nested_type: POGOProtos.Rpc.IDescriptorProto[];
            public enum_type: POGOProtos.Rpc.IEnumDescriptorProto[];
            public oneof_decl: POGOProtos.Rpc.IOneofDescriptorProto[];
            public options?: (POGOProtos.Rpc.IMessageOptions|null);
            public static encode(message: POGOProtos.Rpc.IDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DescriptorProto;
            public static toObject(message: POGOProtos.Rpc.DescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DescriptorProto {

            interface IExtensionRange {
                start?: (number|null);
                end?: (number|null);
            }

            class ExtensionRange implements IExtensionRange {
                constructor(properties?: POGOProtos.Rpc.DescriptorProto.IExtensionRange);
                public start: number;
                public end: number;
                public static encode(message: POGOProtos.Rpc.DescriptorProto.IExtensionRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DescriptorProto.ExtensionRange;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DescriptorProto.ExtensionRange;
                public static toObject(message: POGOProtos.Rpc.DescriptorProto.ExtensionRange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IReservedRange {
                start?: (number|null);
                end?: (number|null);
            }

            class ReservedRange implements IReservedRange {
                constructor(properties?: POGOProtos.Rpc.DescriptorProto.IReservedRange);
                public start: number;
                public end: number;
                public static encode(message: POGOProtos.Rpc.DescriptorProto.IReservedRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DescriptorProto.ReservedRange;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DescriptorProto.ReservedRange;
                public static toObject(message: POGOProtos.Rpc.DescriptorProto.ReservedRange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IDestroyRoomRequest {
            room_id?: (string|null);
        }

        class DestroyRoomRequest implements IDestroyRoomRequest {
            constructor(properties?: POGOProtos.Rpc.IDestroyRoomRequest);
            public room_id: string;
            public static encode(message: POGOProtos.Rpc.IDestroyRoomRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DestroyRoomRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DestroyRoomRequest;
            public static toObject(message: POGOProtos.Rpc.DestroyRoomRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDestroyRoomResponse {
        }

        class DestroyRoomResponse implements IDestroyRoomResponse {
            constructor(properties?: POGOProtos.Rpc.IDestroyRoomResponse);
            public static encode(message: POGOProtos.Rpc.IDestroyRoomResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DestroyRoomResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DestroyRoomResponse;
            public static toObject(message: POGOProtos.Rpc.DestroyRoomResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeviceMap {
            device_map_nodes?: (POGOProtos.Rpc.IDeviceMapNode[]|null);
            graphs?: (POGOProtos.Rpc.IGraphs|null);
            anchor_payload?: (Uint8Array|null);
        }

        class DeviceMap implements IDeviceMap {
            constructor(properties?: POGOProtos.Rpc.IDeviceMap);
            public device_map_nodes: POGOProtos.Rpc.IDeviceMapNode[];
            public graphs?: (POGOProtos.Rpc.IGraphs|null);
            public anchor_payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IDeviceMap, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeviceMap;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeviceMap;
            public static toObject(message: POGOProtos.Rpc.DeviceMap, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeviceMapNode {
            sub_id1?: (number|Long|null);
            sub_id2?: (number|Long|null);
            algorithm?: (POGOProtos.Rpc.DeviceMappingAlgorithm|null);
            map_node_data_type?: (POGOProtos.Rpc.MapNodeDataType|null);
            map_data_type_version?: (number|null);
            map_data?: (Uint8Array|null);
            configs_json?: (string|null);
            map_anchor_payload?: (Uint8Array|null);
        }

        class DeviceMapNode implements IDeviceMapNode {
            constructor(properties?: POGOProtos.Rpc.IDeviceMapNode);
            public sub_id1: (number|Long);
            public sub_id2: (number|Long);
            public algorithm: POGOProtos.Rpc.DeviceMappingAlgorithm;
            public map_node_data_type: POGOProtos.Rpc.MapNodeDataType;
            public map_data_type_version: number;
            public map_data: Uint8Array;
            public configs_json: string;
            public map_anchor_payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IDeviceMapNode, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeviceMapNode;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeviceMapNode;
            public static toObject(message: POGOProtos.Rpc.DeviceMapNode, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeviceOSTelemetry {
            architecture?: (POGOProtos.Rpc.DeviceOSTelemetry.OSArchitecture|null);
        }

        class DeviceOSTelemetry implements IDeviceOSTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDeviceOSTelemetry);
            public architecture: POGOProtos.Rpc.DeviceOSTelemetry.OSArchitecture;
            public static encode(message: POGOProtos.Rpc.IDeviceOSTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeviceOSTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeviceOSTelemetry;
            public static toObject(message: POGOProtos.Rpc.DeviceOSTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DeviceOSTelemetry {

            enum OSArchitecture {
                UNSET = 0,
                arch32_bit = 1,
                arch64_bit = 2
            }
        }

        interface IDeviceServiceToggleTelemetry {
            device_service_telemetry_id?: (POGOProtos.Rpc.DeviceServiceTelemetryIds|null);
            was_enabled?: (boolean|null);
            was_subsequent?: (boolean|null);
        }

        class DeviceServiceToggleTelemetry implements IDeviceServiceToggleTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDeviceServiceToggleTelemetry);
            public device_service_telemetry_id: POGOProtos.Rpc.DeviceServiceTelemetryIds;
            public was_enabled: boolean;
            public was_subsequent: boolean;
            public static encode(message: POGOProtos.Rpc.IDeviceServiceToggleTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeviceServiceToggleTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeviceServiceToggleTelemetry;
            public static toObject(message: POGOProtos.Rpc.DeviceServiceToggleTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDeviceSpecificationsTelemetry {
            device_width?: (number|null);
            device_height?: (number|null);
            camera_width?: (number|null);
            camera_height?: (number|null);
            camera_focal_length_fx?: (number|null);
            camera_focal_length_fy?: (number|null);
            camera_refresh_rate?: (number|null);
        }

        class DeviceSpecificationsTelemetry implements IDeviceSpecificationsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDeviceSpecificationsTelemetry);
            public device_width: number;
            public device_height: number;
            public camera_width: number;
            public camera_height: number;
            public camera_focal_length_fx: number;
            public camera_focal_length_fy: number;
            public camera_refresh_rate: number;
            public static encode(message: POGOProtos.Rpc.IDeviceSpecificationsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DeviceSpecificationsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DeviceSpecificationsTelemetry;
            public static toObject(message: POGOProtos.Rpc.DeviceSpecificationsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDiffInventoryProto {
            compacted_item?: (POGOProtos.Rpc.IInventoryItemProto[]|null);
            last_compaction_ms?: (number|Long|null);
        }

        class DiffInventoryProto implements IDiffInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IDiffInventoryProto);
            public compacted_item: POGOProtos.Rpc.IInventoryItemProto[];
            public last_compaction_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IDiffInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DiffInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DiffInventoryProto;
            public static toObject(message: POGOProtos.Rpc.DiffInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDiskCreateDetail {
            disk_type?: (POGOProtos.Rpc.Item|null);
            fort_id?: (string|null);
        }

        class DiskCreateDetail implements IDiskCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IDiskCreateDetail);
            public disk_type: POGOProtos.Rpc.Item;
            public fort_id: string;
            public static encode(message: POGOProtos.Rpc.IDiskCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DiskCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DiskCreateDetail;
            public static toObject(message: POGOProtos.Rpc.DiskCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDiskEncounterOutProto {
            result?: (POGOProtos.Rpc.DiskEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class DiskEncounterOutProto implements IDiskEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IDiskEncounterOutProto);
            public result: POGOProtos.Rpc.DiskEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IDiskEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DiskEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DiskEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.DiskEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DiskEncounterOutProto {

            enum Result {
                UNKNOWN = 0,
                SUCCESS = 1,
                NOT_AVAILABLE = 2,
                NOT_IN_RANGE = 3,
                ENCOUNTER_ALREADY_FINISHED = 4,
                POKEMON_INVENTORY_FULL = 5
            }
        }

        interface IDiskEncounterProto {
            encounter_id?: (number|Long|null);
            fort_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
            disk_item_id?: (POGOProtos.Rpc.Item|null);
        }

        class DiskEncounterProto implements IDiskEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IDiskEncounterProto);
            public encounter_id: (number|Long);
            public fort_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public disk_item_id: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IDiskEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DiskEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DiskEncounterProto;
            public static toObject(message: POGOProtos.Rpc.DiskEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDisplayWeatherProto {
            cloud_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
            rain_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
            wind_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
            snow_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
            fog_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
            wind_direction?: (number|null);
            special_effect_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
        }

        class DisplayWeatherProto implements IDisplayWeatherProto {
            constructor(properties?: POGOProtos.Rpc.IDisplayWeatherProto);
            public cloud_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
            public rain_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
            public wind_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
            public snow_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
            public fog_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
            public wind_direction: number;
            public special_effect_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
            public static encode(message: POGOProtos.Rpc.IDisplayWeatherProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DisplayWeatherProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DisplayWeatherProto;
            public static toObject(message: POGOProtos.Rpc.DisplayWeatherProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DisplayWeatherProto {

            enum DisplayLevel {
                LEVEL_0 = 0,
                LEVEL_1 = 1,
                LEVEL_2 = 2,
                LEVEL_3 = 3
            }
        }

        interface IDistribution {
            count?: (number|Long|null);
            mean?: (number|null);
            sum_of_squared_deviation?: (number|null);
            range?: (POGOProtos.Rpc.Distribution.IRange|null);
            bucket_options?: (POGOProtos.Rpc.Distribution.IBucketOptions|null);
            bucket_counts?: ((number|Long)[]|null);
        }

        class Distribution implements IDistribution {
            constructor(properties?: POGOProtos.Rpc.IDistribution);
            public count: (number|Long);
            public mean: number;
            public sum_of_squared_deviation: number;
            public range?: (POGOProtos.Rpc.Distribution.IRange|null);
            public bucket_options?: (POGOProtos.Rpc.Distribution.IBucketOptions|null);
            public bucket_counts: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IDistribution, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Distribution;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Distribution;
            public static toObject(message: POGOProtos.Rpc.Distribution, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Distribution {

            interface IBucketOptions {
                linear_buckets?: (POGOProtos.Rpc.Distribution.BucketOptions.ILinearBuckets|null);
                exponential_buckets?: (POGOProtos.Rpc.Distribution.BucketOptions.IExponentialBuckets|null);
                explicit_buckets?: (POGOProtos.Rpc.Distribution.BucketOptions.IExplicitBuckets|null);
            }

            class BucketOptions implements IBucketOptions {
                constructor(properties?: POGOProtos.Rpc.Distribution.IBucketOptions);
                public linear_buckets?: (POGOProtos.Rpc.Distribution.BucketOptions.ILinearBuckets|null);
                public exponential_buckets?: (POGOProtos.Rpc.Distribution.BucketOptions.IExponentialBuckets|null);
                public explicit_buckets?: (POGOProtos.Rpc.Distribution.BucketOptions.IExplicitBuckets|null);
                public BucketType?: ("linear_buckets"|"exponential_buckets"|"explicit_buckets");
                public static encode(message: POGOProtos.Rpc.Distribution.IBucketOptions, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Distribution.BucketOptions;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Distribution.BucketOptions;
                public static toObject(message: POGOProtos.Rpc.Distribution.BucketOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BucketOptions {

                interface IExplicitBuckets {
                    bounds?: ((number|Long)[]|null);
                }

                class ExplicitBuckets implements IExplicitBuckets {
                    constructor(properties?: POGOProtos.Rpc.Distribution.BucketOptions.IExplicitBuckets);
                    public bounds: (number|Long)[];
                    public static encode(message: POGOProtos.Rpc.Distribution.BucketOptions.IExplicitBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Distribution.BucketOptions.ExplicitBuckets;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Distribution.BucketOptions.ExplicitBuckets;
                    public static toObject(message: POGOProtos.Rpc.Distribution.BucketOptions.ExplicitBuckets, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IExponentialBuckets {
                    num_finite_buckets?: (number|Long|null);
                    growth_factor?: (number|null);
                    scale?: (number|null);
                }

                class ExponentialBuckets implements IExponentialBuckets {
                    constructor(properties?: POGOProtos.Rpc.Distribution.BucketOptions.IExponentialBuckets);
                    public num_finite_buckets: (number|Long);
                    public growth_factor: number;
                    public scale: number;
                    public static encode(message: POGOProtos.Rpc.Distribution.BucketOptions.IExponentialBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Distribution.BucketOptions.ExponentialBuckets;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Distribution.BucketOptions.ExponentialBuckets;
                    public static toObject(message: POGOProtos.Rpc.Distribution.BucketOptions.ExponentialBuckets, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ILinearBuckets {
                    num_finite_buckets?: (number|Long|null);
                    width?: (number|Long|null);
                    offset?: (number|Long|null);
                }

                class LinearBuckets implements ILinearBuckets {
                    constructor(properties?: POGOProtos.Rpc.Distribution.BucketOptions.ILinearBuckets);
                    public num_finite_buckets: (number|Long);
                    public width: (number|Long);
                    public offset: (number|Long);
                    public static encode(message: POGOProtos.Rpc.Distribution.BucketOptions.ILinearBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Distribution.BucketOptions.LinearBuckets;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Distribution.BucketOptions.LinearBuckets;
                    public static toObject(message: POGOProtos.Rpc.Distribution.BucketOptions.LinearBuckets, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IRange {
                min?: (number|Long|null);
                max?: (number|Long|null);
            }

            class Range implements IRange {
                constructor(properties?: POGOProtos.Rpc.Distribution.IRange);
                public min: (number|Long);
                public max: (number|Long);
                public static encode(message: POGOProtos.Rpc.Distribution.IRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Distribution.Range;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Distribution.Range;
                public static toObject(message: POGOProtos.Rpc.Distribution.Range, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IDojoSettingsProto {
            dojo_enabled?: (boolean|null);
        }

        class DojoSettingsProto implements IDojoSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDojoSettingsProto);
            public dojo_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IDojoSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DojoSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DojoSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DojoSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDoubleValue {
            value?: (number|null);
        }

        class DoubleValue implements IDoubleValue {
            constructor(properties?: POGOProtos.Rpc.IDoubleValue);
            public value: number;
            public static encode(message: POGOProtos.Rpc.IDoubleValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DoubleValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DoubleValue;
            public static toObject(message: POGOProtos.Rpc.DoubleValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadAllAssetsSettingsProto {
            enabled?: (boolean|null);
        }

        class DownloadAllAssetsSettingsProto implements IDownloadAllAssetsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadAllAssetsSettingsProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IDownloadAllAssetsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadAllAssetsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadAllAssetsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.DownloadAllAssetsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadAllAssetsTelemetry {
            download_all_assets_event_id?: (POGOProtos.Rpc.DownloadAllAssetsTelemetry.DownloadAllAssetsEventId|null);
        }

        class DownloadAllAssetsTelemetry implements IDownloadAllAssetsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IDownloadAllAssetsTelemetry);
            public download_all_assets_event_id: POGOProtos.Rpc.DownloadAllAssetsTelemetry.DownloadAllAssetsEventId;
            public static encode(message: POGOProtos.Rpc.IDownloadAllAssetsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadAllAssetsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadAllAssetsTelemetry;
            public static toObject(message: POGOProtos.Rpc.DownloadAllAssetsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DownloadAllAssetsTelemetry {

            enum DownloadAllAssetsEventId {
                UNSET = 0,
                DOWNLOAD_STARTED = 1,
                DOWNLOAD_PAUSED = 2,
                DOWNLOAD_COMPLETED = 3
            }
        }

        interface IDownloadGmTemplatesRequestProto {
            basis_batch_id?: (number|Long|null);
            batch_id?: (number|Long|null);
            page_offset?: (number|null);
            apply_experiments?: (boolean|null);
            basis_experiment_id?: (number[]|null);
            experiment_id?: (number[]|null);
        }

        class DownloadGmTemplatesRequestProto implements IDownloadGmTemplatesRequestProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadGmTemplatesRequestProto);
            public basis_batch_id: (number|Long);
            public batch_id: (number|Long);
            public page_offset: number;
            public apply_experiments: boolean;
            public basis_experiment_id: number[];
            public experiment_id: number[];
            public static encode(message: POGOProtos.Rpc.IDownloadGmTemplatesRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadGmTemplatesRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadGmTemplatesRequestProto;
            public static toObject(message: POGOProtos.Rpc.DownloadGmTemplatesRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadGmTemplatesResponseProto {
            result?: (POGOProtos.Rpc.DownloadGmTemplatesResponseProto.Result|null);
            template?: (POGOProtos.Rpc.IClientGameMasterTemplateProto[]|null);
            deleted_template?: (string[]|null);
            batch_id?: (number|Long|null);
            page_offset?: (number|null);
            experiment_id?: (number[]|null);
        }

        class DownloadGmTemplatesResponseProto implements IDownloadGmTemplatesResponseProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadGmTemplatesResponseProto);
            public result: POGOProtos.Rpc.DownloadGmTemplatesResponseProto.Result;
            public template: POGOProtos.Rpc.IClientGameMasterTemplateProto[];
            public deleted_template: string[];
            public batch_id: (number|Long);
            public page_offset: number;
            public experiment_id: number[];
            public static encode(message: POGOProtos.Rpc.IDownloadGmTemplatesResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadGmTemplatesResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadGmTemplatesResponseProto;
            public static toObject(message: POGOProtos.Rpc.DownloadGmTemplatesResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DownloadGmTemplatesResponseProto {

            enum Result {
                UNSET = 0,
                COMPLETE = 1,
                MORE_RESULTS = 2,
                BATCH_ID_NOT_LIVE = 3,
                INVALID_BASIS_BATCH_ID = 4,
                WRONG_EXPERIMENTS = 5
            }
        }

        interface IDownloadSettingsActionProto {
            sha1?: (string|null);
        }

        class DownloadSettingsActionProto implements IDownloadSettingsActionProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadSettingsActionProto);
            public sha1: string;
            public static encode(message: POGOProtos.Rpc.IDownloadSettingsActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadSettingsActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadSettingsActionProto;
            public static toObject(message: POGOProtos.Rpc.DownloadSettingsActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadSettingsResponseProto {
            error?: (string|null);
            sha1?: (string|null);
            values?: (POGOProtos.Rpc.IGlobalSettingsProto|null);
        }

        class DownloadSettingsResponseProto implements IDownloadSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadSettingsResponseProto);
            public error: string;
            public sha1: string;
            public values?: (POGOProtos.Rpc.IGlobalSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IDownloadSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.DownloadSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadUrlEntryProto {
            asset_id?: (string|null);
            url?: (string|null);
            size?: (number|null);
            checksum?: (number|null);
        }

        class DownloadUrlEntryProto implements IDownloadUrlEntryProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadUrlEntryProto);
            public asset_id: string;
            public url: string;
            public size: number;
            public checksum: number;
            public static encode(message: POGOProtos.Rpc.IDownloadUrlEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadUrlEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadUrlEntryProto;
            public static toObject(message: POGOProtos.Rpc.DownloadUrlEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadUrlOutProto {
            download_urls?: (POGOProtos.Rpc.IDownloadUrlEntryProto[]|null);
        }

        class DownloadUrlOutProto implements IDownloadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadUrlOutProto);
            public download_urls: POGOProtos.Rpc.IDownloadUrlEntryProto[];
            public static encode(message: POGOProtos.Rpc.IDownloadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.DownloadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownloadUrlRequestProto {
            asset_id?: (string[]|null);
        }

        class DownloadUrlRequestProto implements IDownloadUrlRequestProto {
            constructor(properties?: POGOProtos.Rpc.IDownloadUrlRequestProto);
            public asset_id: string[];
            public static encode(message: POGOProtos.Rpc.IDownloadUrlRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownloadUrlRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownloadUrlRequestProto;
            public static toObject(message: POGOProtos.Rpc.DownloadUrlRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownstream {
            downstream?: (POGOProtos.Rpc.IDownstreamActionMessages|null);
            response?: (POGOProtos.Rpc.Downstream.IResponseWithStatus|null);
            probe?: (POGOProtos.Rpc.Downstream.IProbeRequest|null);
            drain?: (POGOProtos.Rpc.Downstream.IDrain|null);
            connected?: (POGOProtos.Rpc.Downstream.IConnected|null);
        }

        class Downstream implements IDownstream {
            constructor(properties?: POGOProtos.Rpc.IDownstream);
            public downstream?: (POGOProtos.Rpc.IDownstreamActionMessages|null);
            public response?: (POGOProtos.Rpc.Downstream.IResponseWithStatus|null);
            public probe?: (POGOProtos.Rpc.Downstream.IProbeRequest|null);
            public drain?: (POGOProtos.Rpc.Downstream.IDrain|null);
            public connected?: (POGOProtos.Rpc.Downstream.IConnected|null);
            public Message?: ("downstream"|"response"|"probe"|"drain"|"connected");
            public static encode(message: POGOProtos.Rpc.IDownstream, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Downstream;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Downstream;
            public static toObject(message: POGOProtos.Rpc.Downstream, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Downstream {

            interface IConnected {
                debug_message?: (string|null);
                ttl_seconds?: (number|null);
            }

            class Connected implements IConnected {
                constructor(properties?: POGOProtos.Rpc.Downstream.IConnected);
                public debug_message: string;
                public ttl_seconds: number;
                public static encode(message: POGOProtos.Rpc.Downstream.IConnected, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Downstream.Connected;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Downstream.Connected;
                public static toObject(message: POGOProtos.Rpc.Downstream.Connected, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDrain {
            }

            class Drain implements IDrain {
                constructor(properties?: POGOProtos.Rpc.Downstream.IDrain);
                public static encode(message: POGOProtos.Rpc.Downstream.IDrain, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Downstream.Drain;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Downstream.Drain;
                public static toObject(message: POGOProtos.Rpc.Downstream.Drain, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IProbeRequest {
                probe_start_ms?: (number|Long|null);
            }

            class ProbeRequest implements IProbeRequest {
                constructor(properties?: POGOProtos.Rpc.Downstream.IProbeRequest);
                public probe_start_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.Downstream.IProbeRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Downstream.ProbeRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Downstream.ProbeRequest;
                public static toObject(message: POGOProtos.Rpc.Downstream.ProbeRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IResponseWithStatus {
                subscribe?: (POGOProtos.Rpc.Downstream.ISubscriptionResponse|null);
                request_id?: (number|Long|null);
                response_status?: (POGOProtos.Rpc.Downstream.ResponseWithStatus.Status|null);
                debug_message?: (string|null);
            }

            class ResponseWithStatus implements IResponseWithStatus {
                constructor(properties?: POGOProtos.Rpc.Downstream.IResponseWithStatus);
                public subscribe?: (POGOProtos.Rpc.Downstream.ISubscriptionResponse|null);
                public request_id: (number|Long);
                public response_status: POGOProtos.Rpc.Downstream.ResponseWithStatus.Status;
                public debug_message: string;
                public Response?: "subscribe";
                public static encode(message: POGOProtos.Rpc.Downstream.IResponseWithStatus, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Downstream.ResponseWithStatus;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Downstream.ResponseWithStatus;
                public static toObject(message: POGOProtos.Rpc.Downstream.ResponseWithStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ResponseWithStatus {

                enum Status {
                    UNSET = 0,
                    OK = 1,
                    UNKNOWN = 2,
                    UNAUTHENTICATED = 3,
                    UNAUTHORIZED = 4,
                    BAD_REQUEST = 5,
                    UNIMPLEMENTED = 6,
                    RATE_LIMITED = 7,
                    CONNECTION_LIMITED = 8
                }
            }

            interface ISubscriptionResponse {
                status?: (POGOProtos.Rpc.Downstream.SubscriptionResponse.Status|null);
            }

            class SubscriptionResponse implements ISubscriptionResponse {
                constructor(properties?: POGOProtos.Rpc.Downstream.ISubscriptionResponse);
                public status: POGOProtos.Rpc.Downstream.SubscriptionResponse.Status;
                public static encode(message: POGOProtos.Rpc.Downstream.ISubscriptionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Downstream.SubscriptionResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Downstream.SubscriptionResponse;
                public static toObject(message: POGOProtos.Rpc.Downstream.SubscriptionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SubscriptionResponse {

                enum Status {
                    UNSET = 0,
                    OK = 1,
                    UNKNOWN = 2,
                    TOPIC_LIMITED = 3,
                    MAXIMUM_TOPIC_ID_LENGTH_EXCEEDED = 4,
                    TOPIC_ID_INVALID = 5
                }
            }
        }

        interface IDownstreamAction {
            method?: (number|null);
            payload?: (Uint8Array|null);
        }

        class DownstreamAction implements IDownstreamAction {
            constructor(properties?: POGOProtos.Rpc.IDownstreamAction);
            public method: number;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IDownstreamAction, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamAction;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamAction;
            public static toObject(message: POGOProtos.Rpc.DownstreamAction, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownstreamActionMessages {
            messages?: (POGOProtos.Rpc.IDownstreamAction[]|null);
        }

        class DownstreamActionMessages implements IDownstreamActionMessages {
            constructor(properties?: POGOProtos.Rpc.IDownstreamActionMessages);
            public messages: POGOProtos.Rpc.IDownstreamAction[];
            public static encode(message: POGOProtos.Rpc.IDownstreamActionMessages, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamActionMessages;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamActionMessages;
            public static toObject(message: POGOProtos.Rpc.DownstreamActionMessages, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDownstreamMessage {
            datastore?: (POGOProtos.Rpc.DownstreamMessage.IDatastore|null);
            peer_message?: (POGOProtos.Rpc.DownstreamMessage.IPeerMessage|null);
            peer_joined?: (POGOProtos.Rpc.DownstreamMessage.IPeerJoined|null);
            peer_left?: (POGOProtos.Rpc.DownstreamMessage.IPeerLeft|null);
            connected?: (POGOProtos.Rpc.DownstreamMessage.IConnected|null);
            clock_sync?: (POGOProtos.Rpc.DownstreamMessage.IClockSyncResponse|null);
        }

        class DownstreamMessage implements IDownstreamMessage {
            constructor(properties?: POGOProtos.Rpc.IDownstreamMessage);
            public datastore?: (POGOProtos.Rpc.DownstreamMessage.IDatastore|null);
            public peer_message?: (POGOProtos.Rpc.DownstreamMessage.IPeerMessage|null);
            public peer_joined?: (POGOProtos.Rpc.DownstreamMessage.IPeerJoined|null);
            public peer_left?: (POGOProtos.Rpc.DownstreamMessage.IPeerLeft|null);
            public connected?: (POGOProtos.Rpc.DownstreamMessage.IConnected|null);
            public clock_sync?: (POGOProtos.Rpc.DownstreamMessage.IClockSyncResponse|null);
            public message?: ("datastore"|"peer_message"|"peer_joined"|"peer_left"|"connected"|"clock_sync");
            public static encode(message: POGOProtos.Rpc.IDownstreamMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage;
            public static toObject(message: POGOProtos.Rpc.DownstreamMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace DownstreamMessage {

            interface IDatastore {
                valueChanged?: (POGOProtos.Rpc.DownstreamMessage.Datastore.IValueChanged|null);
                keyDeleted?: (POGOProtos.Rpc.DownstreamMessage.Datastore.IKeyDeleted|null);
            }

            class Datastore implements IDatastore {
                constructor(properties?: POGOProtos.Rpc.DownstreamMessage.IDatastore);
                public valueChanged?: (POGOProtos.Rpc.DownstreamMessage.Datastore.IValueChanged|null);
                public keyDeleted?: (POGOProtos.Rpc.DownstreamMessage.Datastore.IKeyDeleted|null);
                public message?: ("valueChanged"|"keyDeleted");
                public static encode(message: POGOProtos.Rpc.DownstreamMessage.IDatastore, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.Datastore;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.Datastore;
                public static toObject(message: POGOProtos.Rpc.DownstreamMessage.Datastore, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Datastore {

                interface IValueChanged {
                    key?: (POGOProtos.Rpc.IKey|null);
                    value?: (POGOProtos.Rpc.IVersionedValue|null);
                }

                class ValueChanged implements IValueChanged {
                    constructor(properties?: POGOProtos.Rpc.DownstreamMessage.Datastore.IValueChanged);
                    public key?: (POGOProtos.Rpc.IKey|null);
                    public value?: (POGOProtos.Rpc.IVersionedValue|null);
                    public static encode(message: POGOProtos.Rpc.DownstreamMessage.Datastore.IValueChanged, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.Datastore.ValueChanged;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.Datastore.ValueChanged;
                    public static toObject(message: POGOProtos.Rpc.DownstreamMessage.Datastore.ValueChanged, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IKeyDeleted {
                    key?: (POGOProtos.Rpc.IKey|null);
                }

                class KeyDeleted implements IKeyDeleted {
                    constructor(properties?: POGOProtos.Rpc.DownstreamMessage.Datastore.IKeyDeleted);
                    public key?: (POGOProtos.Rpc.IKey|null);
                    public static encode(message: POGOProtos.Rpc.DownstreamMessage.Datastore.IKeyDeleted, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.Datastore.KeyDeleted;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.Datastore.KeyDeleted;
                    public static toObject(message: POGOProtos.Rpc.DownstreamMessage.Datastore.KeyDeleted, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IPeerMessage {
                sender_id?: (number|null);
                tag?: (number|null);
                data?: (Uint8Array|null);
            }

            class PeerMessage implements IPeerMessage {
                constructor(properties?: POGOProtos.Rpc.DownstreamMessage.IPeerMessage);
                public sender_id: number;
                public tag: number;
                public data: Uint8Array;
                public static encode(message: POGOProtos.Rpc.DownstreamMessage.IPeerMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.PeerMessage;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.PeerMessage;
                public static toObject(message: POGOProtos.Rpc.DownstreamMessage.PeerMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPeerJoined {
                peer_id?: (number|null);
            }

            class PeerJoined implements IPeerJoined {
                constructor(properties?: POGOProtos.Rpc.DownstreamMessage.IPeerJoined);
                public peer_id: number;
                public static encode(message: POGOProtos.Rpc.DownstreamMessage.IPeerJoined, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.PeerJoined;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.PeerJoined;
                public static toObject(message: POGOProtos.Rpc.DownstreamMessage.PeerJoined, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPeerLeft {
                peer_id?: (number|null);
            }

            class PeerLeft implements IPeerLeft {
                constructor(properties?: POGOProtos.Rpc.DownstreamMessage.IPeerLeft);
                public peer_id: number;
                public static encode(message: POGOProtos.Rpc.DownstreamMessage.IPeerLeft, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.PeerLeft;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.PeerLeft;
                public static toObject(message: POGOProtos.Rpc.DownstreamMessage.PeerLeft, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IConnected {
                assigned_peer_id?: (number|null);
                peers_in_room?: (number[]|null);
                room_data?: (POGOProtos.Rpc.IVersionedKeyValuePair[]|null);
                clock_sync?: (POGOProtos.Rpc.DownstreamMessage.IClockSyncResponse|null);
            }

            class Connected implements IConnected {
                constructor(properties?: POGOProtos.Rpc.DownstreamMessage.IConnected);
                public assigned_peer_id: number;
                public peers_in_room: number[];
                public room_data: POGOProtos.Rpc.IVersionedKeyValuePair[];
                public clock_sync?: (POGOProtos.Rpc.DownstreamMessage.IClockSyncResponse|null);
                public static encode(message: POGOProtos.Rpc.DownstreamMessage.IConnected, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.Connected;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.Connected;
                public static toObject(message: POGOProtos.Rpc.DownstreamMessage.Connected, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IClockSyncResponse {
                request_unix_time_ms?: (number|Long|null);
                response_unix_time_ms?: (number|Long|null);
                avg_rtt_ms?: (number|Long|null);
            }

            class ClockSyncResponse implements IClockSyncResponse {
                constructor(properties?: POGOProtos.Rpc.DownstreamMessage.IClockSyncResponse);
                public request_unix_time_ms: (number|Long);
                public response_unix_time_ms: (number|Long);
                public avg_rtt_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.DownstreamMessage.IClockSyncResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DownstreamMessage.ClockSyncResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DownstreamMessage.ClockSyncResponse;
                public static toObject(message: POGOProtos.Rpc.DownstreamMessage.ClockSyncResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IDumbBeaconProto {
        }

        class DumbBeaconProto implements IDumbBeaconProto {
            constructor(properties?: POGOProtos.Rpc.IDumbBeaconProto);
            public static encode(message: POGOProtos.Rpc.IDumbBeaconProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.DumbBeaconProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.DumbBeaconProto;
            public static toObject(message: POGOProtos.Rpc.DumbBeaconProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IDuration {
            seconds?: (number|Long|null);
            nanos?: (number|null);
        }

        class Duration implements IDuration {
            constructor(properties?: POGOProtos.Rpc.IDuration);
            public seconds: (number|Long);
            public nanos: number;
            public static encode(message: POGOProtos.Rpc.IDuration, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Duration;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Duration;
            public static toObject(message: POGOProtos.Rpc.Duration, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEchoOutProto {
            context?: (string|null);
        }

        class EchoOutProto implements IEchoOutProto {
            constructor(properties?: POGOProtos.Rpc.IEchoOutProto);
            public context: string;
            public static encode(message: POGOProtos.Rpc.IEchoOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EchoOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EchoOutProto;
            public static toObject(message: POGOProtos.Rpc.EchoOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEchoProto {
        }

        class EchoProto implements IEchoProto {
            constructor(properties?: POGOProtos.Rpc.IEchoProto);
            public static encode(message: POGOProtos.Rpc.IEchoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EchoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EchoProto;
            public static toObject(message: POGOProtos.Rpc.EchoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEditPokemonTagOutProto {
            edit_result?: (POGOProtos.Rpc.EditPokemonTagOutProto.Result[]|null);
        }

        class EditPokemonTagOutProto implements IEditPokemonTagOutProto {
            constructor(properties?: POGOProtos.Rpc.IEditPokemonTagOutProto);
            public edit_result: POGOProtos.Rpc.EditPokemonTagOutProto.Result[];
            public static encode(message: POGOProtos.Rpc.IEditPokemonTagOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EditPokemonTagOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EditPokemonTagOutProto;
            public static toObject(message: POGOProtos.Rpc.EditPokemonTagOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EditPokemonTagOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                TAG_DOES_NOT_EXIST = 3,
                INVALID_TAG_NAME = 4,
                INVALID_TAG_SORT_INDEX = 5,
                TAG_NAME_CONTAINS_PROFANITY = 6
            }
        }

        interface IEditPokemonTagProto {
            tag_to_edit?: (POGOProtos.Rpc.IPokemonTagProto[]|null);
        }

        class EditPokemonTagProto implements IEditPokemonTagProto {
            constructor(properties?: POGOProtos.Rpc.IEditPokemonTagProto);
            public tag_to_edit: POGOProtos.Rpc.IPokemonTagProto[];
            public static encode(message: POGOProtos.Rpc.IEditPokemonTagProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EditPokemonTagProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EditPokemonTagProto;
            public static toObject(message: POGOProtos.Rpc.EditPokemonTagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggCreateDetail {
            hatched_time_ms?: (number|Long|null);
            player_hatched_s2_cell_id?: (number|Long|null);
            received_time_ms?: (number|Long|null);
        }

        class EggCreateDetail implements IEggCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IEggCreateDetail);
            public hatched_time_ms: (number|Long);
            public player_hatched_s2_cell_id: (number|Long);
            public received_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IEggCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggCreateDetail;
            public static toObject(message: POGOProtos.Rpc.EggCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggDistributionProto {
            egg_distribution?: (POGOProtos.Rpc.EggDistributionProto.IEggDistributionEntryProto[]|null);
        }

        class EggDistributionProto implements IEggDistributionProto {
            constructor(properties?: POGOProtos.Rpc.IEggDistributionProto);
            public egg_distribution: POGOProtos.Rpc.EggDistributionProto.IEggDistributionEntryProto[];
            public static encode(message: POGOProtos.Rpc.IEggDistributionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggDistributionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggDistributionProto;
            public static toObject(message: POGOProtos.Rpc.EggDistributionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EggDistributionProto {

            interface IEggDistributionEntryProto {
                rarity?: (POGOProtos.Rpc.HoloPokemonClass|null);
                pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            }

            class EggDistributionEntryProto implements IEggDistributionEntryProto {
                constructor(properties?: POGOProtos.Rpc.EggDistributionProto.IEggDistributionEntryProto);
                public rarity: POGOProtos.Rpc.HoloPokemonClass;
                public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
                public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public static encode(message: POGOProtos.Rpc.EggDistributionProto.IEggDistributionEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggDistributionProto.EggDistributionEntryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggDistributionProto.EggDistributionEntryProto;
                public static toObject(message: POGOProtos.Rpc.EggDistributionProto.EggDistributionEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IEggHatchImprovementsSettingsProto {
            feature_enabled?: (boolean|null);
            boot_delay_ms?: (number|null);
            raid_invite_hard_cap_ms?: (number|null);
        }

        class EggHatchImprovementsSettingsProto implements IEggHatchImprovementsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEggHatchImprovementsSettingsProto);
            public feature_enabled: boolean;
            public boot_delay_ms: number;
            public raid_invite_hard_cap_ms: number;
            public static encode(message: POGOProtos.Rpc.IEggHatchImprovementsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggHatchImprovementsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggHatchImprovementsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EggHatchImprovementsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggHatchTelemetry {
            num_eggs_hatched?: (number|null);
            num_animations_skipped?: (number|null);
        }

        class EggHatchTelemetry implements IEggHatchTelemetry {
            constructor(properties?: POGOProtos.Rpc.IEggHatchTelemetry);
            public num_eggs_hatched: number;
            public num_animations_skipped: number;
            public static encode(message: POGOProtos.Rpc.IEggHatchTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggHatchTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggHatchTelemetry;
            public static toObject(message: POGOProtos.Rpc.EggHatchTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggIncubatorAttributesProto {
            incubator_type?: (POGOProtos.Rpc.EggIncubatorType|null);
            uses?: (number|null);
            distance_multiplier?: (number|null);
        }

        class EggIncubatorAttributesProto implements IEggIncubatorAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IEggIncubatorAttributesProto);
            public incubator_type: POGOProtos.Rpc.EggIncubatorType;
            public uses: number;
            public distance_multiplier: number;
            public static encode(message: POGOProtos.Rpc.IEggIncubatorAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggIncubatorAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggIncubatorAttributesProto;
            public static toObject(message: POGOProtos.Rpc.EggIncubatorAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggIncubatorProto {
            item_id?: (string|null);
            item?: (POGOProtos.Rpc.Item|null);
            incubator_type?: (POGOProtos.Rpc.EggIncubatorType|null);
            uses_remaining?: (number|null);
            pokemon_id?: (number|Long|null);
            start_km_walked?: (number|null);
            target_km_walked?: (number|null);
        }

        class EggIncubatorProto implements IEggIncubatorProto {
            constructor(properties?: POGOProtos.Rpc.IEggIncubatorProto);
            public item_id: string;
            public item: POGOProtos.Rpc.Item;
            public incubator_type: POGOProtos.Rpc.EggIncubatorType;
            public uses_remaining: number;
            public pokemon_id: (number|Long);
            public start_km_walked: number;
            public target_km_walked: number;
            public static encode(message: POGOProtos.Rpc.IEggIncubatorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggIncubatorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggIncubatorProto;
            public static toObject(message: POGOProtos.Rpc.EggIncubatorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggIncubatorsProto {
            egg_incubator?: (POGOProtos.Rpc.IEggIncubatorProto[]|null);
        }

        class EggIncubatorsProto implements IEggIncubatorsProto {
            constructor(properties?: POGOProtos.Rpc.IEggIncubatorsProto);
            public egg_incubator: POGOProtos.Rpc.IEggIncubatorProto[];
            public static encode(message: POGOProtos.Rpc.IEggIncubatorsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggIncubatorsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggIncubatorsProto;
            public static toObject(message: POGOProtos.Rpc.EggIncubatorsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggTelemetryProto {
            egg_loot_table_id?: (string|null);
            original_egg_slot_type?: (POGOProtos.Rpc.EggSlotType|null);
        }

        class EggTelemetryProto implements IEggTelemetryProto {
            constructor(properties?: POGOProtos.Rpc.IEggTelemetryProto);
            public egg_loot_table_id: string;
            public original_egg_slot_type: POGOProtos.Rpc.EggSlotType;
            public static encode(message: POGOProtos.Rpc.IEggTelemetryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggTelemetryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggTelemetryProto;
            public static toObject(message: POGOProtos.Rpc.EggTelemetryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggTransparencySettingsProto {
            enable_egg_distribution?: (boolean|null);
        }

        class EggTransparencySettingsProto implements IEggTransparencySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEggTransparencySettingsProto);
            public enable_egg_distribution: boolean;
            public static encode(message: POGOProtos.Rpc.IEggTransparencySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EggTransparencySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EggTransparencySettingsProto;
            public static toObject(message: POGOProtos.Rpc.EggTransparencySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEligibleContestPoolSettingsProto {
            contest?: (POGOProtos.Rpc.IEligibleContestProto[]|null);
        }

        class EligibleContestPoolSettingsProto implements IEligibleContestPoolSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEligibleContestPoolSettingsProto);
            public contest: POGOProtos.Rpc.IEligibleContestProto[];
            public static encode(message: POGOProtos.Rpc.IEligibleContestPoolSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EligibleContestPoolSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EligibleContestPoolSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EligibleContestPoolSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEligibleContestProto {
            contest?: (POGOProtos.Rpc.IContestProto|null);
            weight?: (number|null);
        }

        class EligibleContestProto implements IEligibleContestProto {
            constructor(properties?: POGOProtos.Rpc.IEligibleContestProto);
            public contest?: (POGOProtos.Rpc.IContestProto|null);
            public weight: number;
            public static encode(message: POGOProtos.Rpc.IEligibleContestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EligibleContestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EligibleContestProto;
            public static toObject(message: POGOProtos.Rpc.EligibleContestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEmpty {
        }

        class Empty implements IEmpty {
            constructor(properties?: POGOProtos.Rpc.IEmpty);
            public static encode(message: POGOProtos.Rpc.IEmpty, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Empty;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Empty;
            public static toObject(message: POGOProtos.Rpc.Empty, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnabledPokemonSettingsProto {
            enabled_pokemon_range?: (POGOProtos.Rpc.EnabledPokemonSettingsProto.IRange[]|null);
        }

        class EnabledPokemonSettingsProto implements IEnabledPokemonSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEnabledPokemonSettingsProto);
            public enabled_pokemon_range: POGOProtos.Rpc.EnabledPokemonSettingsProto.IRange[];
            public static encode(message: POGOProtos.Rpc.IEnabledPokemonSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnabledPokemonSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnabledPokemonSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EnabledPokemonSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EnabledPokemonSettingsProto {

            interface IRange {
                start?: (number|null);
                end?: (number|null);
            }

            class Range implements IRange {
                constructor(properties?: POGOProtos.Rpc.EnabledPokemonSettingsProto.IRange);
                public start: number;
                public end: number;
                public static encode(message: POGOProtos.Rpc.EnabledPokemonSettingsProto.IRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnabledPokemonSettingsProto.Range;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnabledPokemonSettingsProto.Range;
                public static toObject(message: POGOProtos.Rpc.EnabledPokemonSettingsProto.Range, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IEncounterOutProto {
            pokemon?: (POGOProtos.Rpc.IWildPokemonProto|null);
            background?: (POGOProtos.Rpc.EncounterOutProto.Background|null);
            status?: (POGOProtos.Rpc.EncounterOutProto.Status|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class EncounterOutProto implements IEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterOutProto);
            public pokemon?: (POGOProtos.Rpc.IWildPokemonProto|null);
            public background: POGOProtos.Rpc.EncounterOutProto.Background;
            public status: POGOProtos.Rpc.EncounterOutProto.Status;
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.EncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EncounterOutProto {

            enum Background {
                PARK = 0,
                DESERT = 1,
                BEACH = 2,
                LAKE = 3,
                RIVER = 4,
                OCEAN = 5
            }

            enum Status {
                ENCOUNTER_ERROR = 0,
                ENCOUNTER_SUCCESS = 1,
                ENCOUNTER_NOT_FOUND = 2,
                ENCOUNTER_CLOSED = 3,
                ENCOUNTER_POKEMON_FLED = 4,
                ENCOUNTER_NOT_IN_RANGE = 5,
                ENCOUNTER_ALREADY_HAPPENED = 6,
                POKEMON_INVENTORY_FULL = 7
            }
        }

        interface IEncounterPhotobombOutProto {
            result?: (POGOProtos.Rpc.EncounterPhotobombOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class EncounterPhotobombOutProto implements IEncounterPhotobombOutProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterPhotobombOutProto);
            public result: POGOProtos.Rpc.EncounterPhotobombOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IEncounterPhotobombOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterPhotobombOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterPhotobombOutProto;
            public static toObject(message: POGOProtos.Rpc.EncounterPhotobombOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EncounterPhotobombOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_ENCOUNTER_AVAILABLE = 2,
                POKEMON_INVENTORY_FULL = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface IEncounterPhotobombProto {
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
        }

        class EncounterPhotobombProto implements IEncounterPhotobombProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterPhotobombProto);
            public encounter_id: (number|Long);
            public encounter_location: string;
            public static encode(message: POGOProtos.Rpc.IEncounterPhotobombProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterPhotobombProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterPhotobombProto;
            public static toObject(message: POGOProtos.Rpc.EncounterPhotobombProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEncounterPokemonTelemetry {
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            map_pokemon_type?: (string|null);
            ar_enabled?: (boolean|null);
            ar_plus_enabled?: (boolean|null);
        }

        class EncounterPokemonTelemetry implements IEncounterPokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IEncounterPokemonTelemetry);
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public map_pokemon_type: string;
            public ar_enabled: boolean;
            public ar_plus_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IEncounterPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterPokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterPokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.EncounterPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEncounterPokestopEncounterOutProto {
            result?: (POGOProtos.Rpc.EncounterPokestopEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
        }

        class EncounterPokestopEncounterOutProto implements IEncounterPokestopEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterPokestopEncounterOutProto);
            public result: POGOProtos.Rpc.EncounterPokestopEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IEncounterPokestopEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterPokestopEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterPokestopEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.EncounterPokestopEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EncounterPokestopEncounterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_ENCOUNTER_AVAILABLE = 2,
                POKEMON_INVENTORY_FULL = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface IEncounterPokestopEncounterProto {
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
        }

        class EncounterPokestopEncounterProto implements IEncounterPokestopEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterPokestopEncounterProto);
            public encounter_id: (number|Long);
            public encounter_location: string;
            public static encode(message: POGOProtos.Rpc.IEncounterPokestopEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterPokestopEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterPokestopEncounterProto;
            public static toObject(message: POGOProtos.Rpc.EncounterPokestopEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEncounterProto {
            encounter_id?: (number|Long|null);
            spawnpoint_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class EncounterProto implements IEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterProto);
            public encounter_id: (number|Long);
            public spawnpoint_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterProto;
            public static toObject(message: POGOProtos.Rpc.EncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEncounterSettingsProto {
            spin_bonus_threshold?: (number|null);
            excellent_throw_threshold?: (number|null);
            great_throw_threshold?: (number|null);
            nice_throw_threshold?: (number|null);
            milestone_threshold?: (number|null);
            ar_plus_mode_enabled?: (boolean|null);
            ar_close_proximity_threshold?: (number|null);
            ar_low_awareness_threshold?: (number|null);
            ar_close_proximity_multiplier?: (number|null);
            ar_awareness_penalty_threshold?: (number|null);
            ar_low_awareness_max_multiplier?: (number|null);
            ar_high_awareness_min_penalty_multiplier?: (number|null);
            ar_plus_attempts_until_flee_max?: (number|null);
            ar_plus_attempts_until_flee_infinite?: (number|null);
            escaped_bonus_multiplier_max?: (number|null);
            escaped_bonus_multiplier_by_excellent_throw?: (number|null);
            escaped_bonus_multiplier_by_great_throw?: (number|null);
            escaped_bonus_multiplier_by_nice_throw?: (number|null);
            encounter_arena_scene_asset_name?: (string|null);
            global_stardust_multiplier?: (number|null);
            global_candy_multiplier?: (number|null);
            critical_reticle_threshold?: (number|null);
            critical_reticle_catch_multiplier?: (number|null);
            critical_reticle_capture_rate_threshold?: (number|null);
            critical_reticle_fallback_catch_multiplier?: (number|null);
            show_last_throw_animation?: (boolean|null);
            enable_pokemon_stats_limits?: (boolean|null);
            enable_extended_create_details_client?: (boolean|null);
            enable_extended_create_details_server?: (boolean|null);
            enable_item_selection_slider_v2?: (boolean|null);
            enable_auto_wild_ball_select?: (boolean|null);
            highlight_streak_rewards?: (boolean|null);
            player_activity_catch_legendary_pokemon_enabled?: (boolean|null);
        }

        class EncounterSettingsProto implements IEncounterSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterSettingsProto);
            public spin_bonus_threshold: number;
            public excellent_throw_threshold: number;
            public great_throw_threshold: number;
            public nice_throw_threshold: number;
            public milestone_threshold: number;
            public ar_plus_mode_enabled: boolean;
            public ar_close_proximity_threshold: number;
            public ar_low_awareness_threshold: number;
            public ar_close_proximity_multiplier: number;
            public ar_awareness_penalty_threshold: number;
            public ar_low_awareness_max_multiplier: number;
            public ar_high_awareness_min_penalty_multiplier: number;
            public ar_plus_attempts_until_flee_max: number;
            public ar_plus_attempts_until_flee_infinite: number;
            public escaped_bonus_multiplier_max: number;
            public escaped_bonus_multiplier_by_excellent_throw: number;
            public escaped_bonus_multiplier_by_great_throw: number;
            public escaped_bonus_multiplier_by_nice_throw: number;
            public encounter_arena_scene_asset_name: string;
            public global_stardust_multiplier: number;
            public global_candy_multiplier: number;
            public critical_reticle_threshold: number;
            public critical_reticle_catch_multiplier: number;
            public critical_reticle_capture_rate_threshold: number;
            public critical_reticle_fallback_catch_multiplier: number;
            public show_last_throw_animation: boolean;
            public enable_pokemon_stats_limits: boolean;
            public enable_extended_create_details_client: boolean;
            public enable_extended_create_details_server: boolean;
            public enable_item_selection_slider_v2: boolean;
            public enable_auto_wild_ball_select: boolean;
            public highlight_streak_rewards: boolean;
            public player_activity_catch_legendary_pokemon_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IEncounterSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EncounterSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEncounterStationSpawnOutProto {
            result?: (POGOProtos.Rpc.EncounterStationSpawnOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
        }

        class EncounterStationSpawnOutProto implements IEncounterStationSpawnOutProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterStationSpawnOutProto);
            public result: POGOProtos.Rpc.EncounterStationSpawnOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IEncounterStationSpawnOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterStationSpawnOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterStationSpawnOutProto;
            public static toObject(message: POGOProtos.Rpc.EncounterStationSpawnOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EncounterStationSpawnOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_INVENTORY_FULL = 2,
                ERROR_NO_ENCOUNTER_AVAILABLE = 3
            }
        }

        interface IEncounterStationSpawnProto {
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
        }

        class EncounterStationSpawnProto implements IEncounterStationSpawnProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterStationSpawnProto);
            public encounter_id: (number|Long);
            public encounter_location: string;
            public static encode(message: POGOProtos.Rpc.IEncounterStationSpawnProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterStationSpawnProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterStationSpawnProto;
            public static toObject(message: POGOProtos.Rpc.EncounterStationSpawnProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEncounterTutorialCompleteOutProto {
            result?: (POGOProtos.Rpc.EncounterTutorialCompleteOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            scores?: (POGOProtos.Rpc.ICaptureScoreProto|null);
        }

        class EncounterTutorialCompleteOutProto implements IEncounterTutorialCompleteOutProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterTutorialCompleteOutProto);
            public result: POGOProtos.Rpc.EncounterTutorialCompleteOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public scores?: (POGOProtos.Rpc.ICaptureScoreProto|null);
            public static encode(message: POGOProtos.Rpc.IEncounterTutorialCompleteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterTutorialCompleteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterTutorialCompleteOutProto;
            public static toObject(message: POGOProtos.Rpc.EncounterTutorialCompleteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EncounterTutorialCompleteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_POKEMON = 2
            }
        }

        interface IEncounterTutorialCompleteProto {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
        }

        class EncounterTutorialCompleteProto implements IEncounterTutorialCompleteProto {
            constructor(properties?: POGOProtos.Rpc.IEncounterTutorialCompleteProto);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public static encode(message: POGOProtos.Rpc.IEncounterTutorialCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EncounterTutorialCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EncounterTutorialCompleteProto;
            public static toObject(message: POGOProtos.Rpc.EncounterTutorialCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnhanceBreadMoveOutProto {
            result?: (POGOProtos.Rpc.EnhanceBreadMoveOutProto.Result|null);
            bread_move_slot?: (POGOProtos.Rpc.IBreadMoveSlotProto|null);
        }

        class EnhanceBreadMoveOutProto implements IEnhanceBreadMoveOutProto {
            constructor(properties?: POGOProtos.Rpc.IEnhanceBreadMoveOutProto);
            public result: POGOProtos.Rpc.EnhanceBreadMoveOutProto.Result;
            public bread_move_slot?: (POGOProtos.Rpc.IBreadMoveSlotProto|null);
            public static encode(message: POGOProtos.Rpc.IEnhanceBreadMoveOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnhanceBreadMoveOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnhanceBreadMoveOutProto;
            public static toObject(message: POGOProtos.Rpc.EnhanceBreadMoveOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EnhanceBreadMoveOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                INSUFFICIENT_RESOURCES = 2,
                ALREADY_MAX_LEVEL = 3,
                INVALID_MOVE = 4,
                INVALID_POKEMON = 5
            }
        }

        interface IEnhanceBreadMoveProto {
            pokemon_id?: (number|Long|null);
            move_type?: (POGOProtos.Rpc.BreadMoveSlotProto.BreadMoveType|null);
            target_move_level?: (POGOProtos.Rpc.BreadMoveLevels|null);
        }

        class EnhanceBreadMoveProto implements IEnhanceBreadMoveProto {
            constructor(properties?: POGOProtos.Rpc.IEnhanceBreadMoveProto);
            public pokemon_id: (number|Long);
            public move_type: POGOProtos.Rpc.BreadMoveSlotProto.BreadMoveType;
            public target_move_level: POGOProtos.Rpc.BreadMoveLevels;
            public static encode(message: POGOProtos.Rpc.IEnhanceBreadMoveProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnhanceBreadMoveProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnhanceBreadMoveProto;
            public static toObject(message: POGOProtos.Rpc.EnhanceBreadMoveProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnum {
            name?: (string|null);
            enumvalue?: (POGOProtos.Rpc.IEnumValue[]|null);
            options?: (POGOProtos.Rpc.IOption[]|null);
            source_context?: (POGOProtos.Rpc.ISourceContext|null);
            syntax?: (POGOProtos.Rpc.Syntax|null);
            edition?: (string|null);
        }

        class Enum implements IEnum {
            constructor(properties?: POGOProtos.Rpc.IEnum);
            public name: string;
            public enumvalue: POGOProtos.Rpc.IEnumValue[];
            public options: POGOProtos.Rpc.IOption[];
            public source_context?: (POGOProtos.Rpc.ISourceContext|null);
            public syntax: POGOProtos.Rpc.Syntax;
            public edition: string;
            public static encode(message: POGOProtos.Rpc.IEnum, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Enum;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Enum;
            public static toObject(message: POGOProtos.Rpc.Enum, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnumDescriptorProto {
            name?: (string|null);
            value?: (POGOProtos.Rpc.IEnumValueDescriptorProto[]|null);
            options?: (POGOProtos.Rpc.IEnumOptions|null);
        }

        class EnumDescriptorProto implements IEnumDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IEnumDescriptorProto);
            public name: string;
            public value: POGOProtos.Rpc.IEnumValueDescriptorProto[];
            public options?: (POGOProtos.Rpc.IEnumOptions|null);
            public static encode(message: POGOProtos.Rpc.IEnumDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnumDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnumDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.EnumDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnumOptions {
            allow_alias?: (boolean|null);
            deprecated?: (boolean|null);
        }

        class EnumOptions implements IEnumOptions {
            constructor(properties?: POGOProtos.Rpc.IEnumOptions);
            public allow_alias: boolean;
            public deprecated: boolean;
            public static encode(message: POGOProtos.Rpc.IEnumOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnumOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnumOptions;
            public static toObject(message: POGOProtos.Rpc.EnumOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnumValue {
            name?: (string|null);
            number?: (number|null);
            options?: (POGOProtos.Rpc.IOption[]|null);
        }

        class EnumValue implements IEnumValue {
            constructor(properties?: POGOProtos.Rpc.IEnumValue);
            public name: string;
            public number: number;
            public options: POGOProtos.Rpc.IOption[];
            public static encode(message: POGOProtos.Rpc.IEnumValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnumValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnumValue;
            public static toObject(message: POGOProtos.Rpc.EnumValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnumValueDescriptorProto {
            name?: (string|null);
            number?: (number|null);
            options?: (POGOProtos.Rpc.IEnumValueOptions|null);
        }

        class EnumValueDescriptorProto implements IEnumValueDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IEnumValueDescriptorProto);
            public name: string;
            public number: number;
            public options?: (POGOProtos.Rpc.IEnumValueOptions|null);
            public static encode(message: POGOProtos.Rpc.IEnumValueDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnumValueDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnumValueDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.EnumValueDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnumValueOptions {
            deprecated?: (boolean|null);
        }

        class EnumValueOptions implements IEnumValueOptions {
            constructor(properties?: POGOProtos.Rpc.IEnumValueOptions);
            public deprecated: boolean;
            public static encode(message: POGOProtos.Rpc.IEnumValueOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnumValueOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnumValueOptions;
            public static toObject(message: POGOProtos.Rpc.EnumValueOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEnumWrapper {
        }

        class EnumWrapper implements IEnumWrapper {
            constructor(properties?: POGOProtos.Rpc.IEnumWrapper);
            public static encode(message: POGOProtos.Rpc.IEnumWrapper, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EnumWrapper;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EnumWrapper;
            public static toObject(message: POGOProtos.Rpc.EnumWrapper, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EnumWrapper {

            enum CharacterCategory {
                UNSET = 0,
                TEAM_LEADER = 1,
                GRUNT = 2,
                ARLO = 3,
                CLIFF = 4,
                SIERRA = 5,
                GIOVANNI = 6,
                GRUNTBF = 7,
                GRUNTBM = 8,
                EVENT_NPC = 9,
                PLAYER_TEAM_LEADER = 10
            }

            enum IncidentStartPhase {
                INCIDENT_START_ON_SPIN_OR_EXIT = 0,
                INCIDENT_START_ON_SPIN_NOT_EXIT = 1,
                INCIDENT_START_ON_EXIT_NOT_SPIN = 2
            }

            enum InvasionCharacter {
                CHARACTER_UNSET = 0,
                CHARACTER_BLANCHE = 1,
                CHARACTER_CANDELA = 2,
                CHARACTER_SPARK = 3,
                CHARACTER_GRUNT_MALE = 4,
                CHARACTER_GRUNT_FEMALE = 5,
                CHARACTER_BUG_GRUNT_FEMALE = 6,
                CHARACTER_BUG_GRUNT_MALE = 7,
                CHARACTER_DARKNESS_GRUNT_FEMALE = 8,
                CHARACTER_DARKNESS_GRUNT_MALE = 9,
                CHARACTER_DARK_GRUNT_FEMALE = 10,
                CHARACTER_DARK_GRUNT_MALE = 11,
                CHARACTER_DRAGON_GRUNT_FEMALE = 12,
                CHARACTER_DRAGON_GRUNT_MALE = 13,
                CHARACTER_FAIRY_GRUNT_FEMALE = 14,
                CHARACTER_FAIRY_GRUNT_MALE = 15,
                CHARACTER_FIGHTING_GRUNT_FEMALE = 16,
                CHARACTER_FIGHTING_GRUNT_MALE = 17,
                CHARACTER_FIRE_GRUNT_FEMALE = 18,
                CHARACTER_FIRE_GRUNT_MALE = 19,
                CHARACTER_FLYING_GRUNT_FEMALE = 20,
                CHARACTER_FLYING_GRUNT_MALE = 21,
                CHARACTER_GRASS_GRUNT_FEMALE = 22,
                CHARACTER_GRASS_GRUNT_MALE = 23,
                CHARACTER_GROUND_GRUNT_FEMALE = 24,
                CHARACTER_GROUND_GRUNT_MALE = 25,
                CHARACTER_ICE_GRUNT_FEMALE = 26,
                CHARACTER_ICE_GRUNT_MALE = 27,
                CHARACTER_METAL_GRUNT_FEMALE = 28,
                CHARACTER_METAL_GRUNT_MALE = 29,
                CHARACTER_NORMAL_GRUNT_FEMALE = 30,
                CHARACTER_NORMAL_GRUNT_MALE = 31,
                CHARACTER_POISON_GRUNT_FEMALE = 32,
                CHARACTER_POISON_GRUNT_MALE = 33,
                CHARACTER_PSYCHIC_GRUNT_FEMALE = 34,
                CHARACTER_PSYCHIC_GRUNT_MALE = 35,
                CHARACTER_ROCK_GRUNT_FEMALE = 36,
                CHARACTER_ROCK_GRUNT_MALE = 37,
                CHARACTER_WATER_GRUNT_FEMALE = 38,
                CHARACTER_WATER_GRUNT_MALE = 39,
                CHARACTER_PLAYER_TEAM_LEADER = 40,
                CHARACTER_EXECUTIVE_CLIFF = 41,
                CHARACTER_EXECUTIVE_ARLO = 42,
                CHARACTER_EXECUTIVE_SIERRA = 43,
                CHARACTER_GIOVANNI = 44,
                CHARACTER_DECOY_GRUNT_MALE = 45,
                CHARACTER_DECOY_GRUNT_FEMALE = 46,
                CHARACTER_GHOST_GRUNT_FEMALE = 47,
                CHARACTER_GHOST_GRUNT_MALE = 48,
                CHARACTER_ELECTRIC_GRUNT_FEMALE = 49,
                CHARACTER_ELECTRIC_GRUNT_MALE = 50,
                CHARACTER_BALLOON_GRUNT_FEMALE = 51,
                CHARACTER_BALLOON_GRUNT_MALE = 52,
                CHARACTER_GRUNTB_FEMALE = 53,
                CHARACTER_GRUNTB_MALE = 54,
                CHARACTER_BUG_BALLOON_GRUNT_FEMALE = 55,
                CHARACTER_BUG_BALLOON_GRUNT_MALE = 56,
                CHARACTER_DARK_BALLOON_GRUNT_FEMALE = 57,
                CHARACTER_DARK_BALLOON_GRUNT_MALE = 58,
                CHARACTER_DRAGON_BALLOON_GRUNT_FEMALE = 59,
                CHARACTER_DRAGON_BALLOON_GRUNT_MALE = 60,
                CHARACTER_FAIRY_BALLOON_GRUNT_FEMALE = 61,
                CHARACTER_FAIRY_BALLOON_GRUNT_MALE = 62,
                CHARACTER_FIGHTING_BALLOON_GRUNT_FEMALE = 63,
                CHARACTER_FIGHTING_BALLOON_GRUNT_MALE = 64,
                CHARACTER_FIRE_BALLOON_GRUNT_FEMALE = 65,
                CHARACTER_FIRE_BALLOON_GRUNT_MALE = 66,
                CHARACTER_FLYING_BALLOON_GRUNT_FEMALE = 67,
                CHARACTER_FLYING_BALLOON_GRUNT_MALE = 68,
                CHARACTER_GRASS_BALLOON_GRUNT_FEMALE = 69,
                CHARACTER_GRASS_BALLOON_GRUNT_MALE = 70,
                CHARACTER_GROUND_BALLOON_GRUNT_FEMALE = 71,
                CHARACTER_GROUND_BALLOON_GRUNT_MALE = 72,
                CHARACTER_ICE_BALLOON_GRUNT_FEMALE = 73,
                CHARACTER_ICE_BALLOON_GRUNT_MALE = 74,
                CHARACTER_METAL_BALLOON_GRUNT_FEMALE = 75,
                CHARACTER_METAL_BALLOON_GRUNT_MALE = 76,
                CHARACTER_NORMAL_BALLOON_GRUNT_FEMALE = 77,
                CHARACTER_NORMAL_BALLOON_GRUNT_MALE = 78,
                CHARACTER_POISON_BALLOON_GRUNT_FEMALE = 79,
                CHARACTER_POISON_BALLOON_GRUNT_MALE = 80,
                CHARACTER_PSYCHIC_BALLOON_GRUNT_FEMALE = 81,
                CHARACTER_PSYCHIC_BALLOON_GRUNT_MALE = 82,
                CHARACTER_ROCK_BALLOON_GRUNT_FEMALE = 83,
                CHARACTER_ROCK_BALLOON_GRUNT_MALE = 84,
                CHARACTER_WATER_BALLOON_GRUNT_FEMALE = 85,
                CHARACTER_WATER_BALLOON_GRUNT_MALE = 86,
                CHARACTER_GHOST_BALLOON_GRUNT_FEMALE = 87,
                CHARACTER_GHOST_BALLOON_GRUNT_MALE = 88,
                CHARACTER_ELECTRIC_BALLOON_GRUNT_FEMALE = 89,
                CHARACTER_ELECTRIC_BALLOON_GRUNT_MALE = 90,
                CHARACTER_WILLOW = 91,
                CHARACTER_WILLOWB = 92,
                CHARACTER_TRAVELER = 93,
                CHARACTER_EXPLORER = 94,
                CHARACTER_EVENT_NPC_0 = 500,
                CHARACTER_EVENT_NPC_1 = 501,
                CHARACTER_EVENT_NPC_2 = 502,
                CHARACTER_EVENT_NPC_3 = 503,
                CHARACTER_EVENT_NPC_4 = 504,
                CHARACTER_EVENT_NPC_5 = 505,
                CHARACTER_EVENT_NPC_6 = 506,
                CHARACTER_EVENT_NPC_7 = 507,
                CHARACTER_EVENT_NPC_8 = 508,
                CHARACTER_EVENT_NPC_9 = 509,
                CHARACTER_EVENT_NPC_10 = 510,
                CHARACTER_EVENT_NPC_BLANCHE = 511,
                CHARACTER_EVENT_NPC_CANDELA = 512,
                CHARACTER_EVENT_NPC_SPARK = 513,
                CHARACTER_EVENT_NPC_11 = 514,
                CHARACTER_EVENT_NPC_12 = 515,
                CHARACTER_EVENT_NPC_13 = 516,
                CHARACTER_EVENT_NPC_14 = 517,
                CHARACTER_EVENT_NPC_15 = 518,
                CHARACTER_EVENT_NPC_16 = 519,
                CHARACTER_EVENT_NPC_17 = 520,
                CHARACTER_EVENT_NPC_18 = 521,
                CHARACTER_EVENT_NPC_19 = 522,
                CHARACTER_EVENT_NPC_20 = 523,
                CHARACTER_EVENT_GIOVANNI_UNTICKETED = 524,
                CHARACTER_EVENT_SIERRA_UNTICKETED = 525,
                CHARACTER_EVENT_ARLO_UNTICKETED = 526,
                CHARACTER_EVENT_CLIFF_UNTICKETED = 527
            }

            enum InvasionCharacterExpression {
                EXPRESSION_UNSET = 0,
                PLACEHOLDER_1 = 1,
                PLACEHOLDER_2 = 2,
                PLACEHOLDER_3 = 3,
                PLACEHOLDER_4 = 4,
                GREETING = 5,
                CHALLENGE = 6,
                VICTORY = 7,
                DEFEAT = 8
            }

            enum InvasionContext {
                POKESTOP_INCIDENT = 0,
                ROCKET_BALLOON = 1,
                QUEST_REWARD_INCIDENT = 2,
                CROSS_POKESTOP_INCIDENT = 3
            }

            enum PokestopStyle {
                POKESTOP_NORMAL = 0,
                POKESTOP_ROCKET_INVASION = 1,
                POKESTOP_ROCKET_VICTORY = 2,
                POKESTOP_CONTEST = 3
            }
        }

        interface IErrorReportingSettingsProto {
            is_enabled?: (boolean|null);
            event_sample_rate?: (number|null);
            percent_chance_player_sends?: (number|null);
            editor_enabled?: (boolean|null);
            editor_sample_rate?: (number|null);
            max_events_per_sliding_window?: (number|null);
            sliding_window_length_s?: (number|null);
            max_total_events_before_shutdown?: (number|Long|null);
        }

        class ErrorReportingSettingsProto implements IErrorReportingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IErrorReportingSettingsProto);
            public is_enabled: boolean;
            public event_sample_rate: number;
            public percent_chance_player_sends: number;
            public editor_enabled: boolean;
            public editor_sample_rate: number;
            public max_events_per_sliding_window: number;
            public sliding_window_length_s: number;
            public max_total_events_before_shutdown: (number|Long);
            public static encode(message: POGOProtos.Rpc.IErrorReportingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ErrorReportingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ErrorReportingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ErrorReportingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventBadgeSettingsProto {
            valid_from_ms?: (number|Long|null);
            valid_to_ms?: (number|Long|null);
            mutually_exclusive_badges?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            automatically_award_badge?: (boolean|null);
            suppress_client_visuals?: (boolean|null);
        }

        class EventBadgeSettingsProto implements IEventBadgeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventBadgeSettingsProto);
            public valid_from_ms: (number|Long);
            public valid_to_ms: (number|Long);
            public mutually_exclusive_badges: POGOProtos.Rpc.HoloBadgeType[];
            public automatically_award_badge: boolean;
            public suppress_client_visuals: boolean;
            public static encode(message: POGOProtos.Rpc.IEventBadgeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventBadgeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventBadgeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventBadgeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventBannerSectionProto {
            event_icon?: (string|null);
            title_text?: (string|null);
            body_text?: (string|null);
            image_url?: (string|null);
            header_image_url?: (string|null);
            image_overlay_text?: (string|null);
            link_from_image?: (string|null);
            image_sub_text?: (string|null);
            image_urls?: (string[]|null);
            image_auto_scroll_ms?: (number|Long|null);
        }

        class EventBannerSectionProto implements IEventBannerSectionProto {
            constructor(properties?: POGOProtos.Rpc.IEventBannerSectionProto);
            public event_icon: string;
            public title_text: string;
            public body_text: string;
            public image_url: string;
            public header_image_url: string;
            public image_overlay_text: string;
            public link_from_image: string;
            public image_sub_text: string;
            public image_urls: string[];
            public image_auto_scroll_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IEventBannerSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventBannerSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventBannerSectionProto;
            public static toObject(message: POGOProtos.Rpc.EventBannerSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventInfoProto {
            image_url?: (string|null);
            icon_url?: (string|null);
            name_key?: (string|null);
        }

        class EventInfoProto implements IEventInfoProto {
            constructor(properties?: POGOProtos.Rpc.IEventInfoProto);
            public image_url: string;
            public icon_url: string;
            public name_key: string;
            public static encode(message: POGOProtos.Rpc.IEventInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventInfoProto;
            public static toObject(message: POGOProtos.Rpc.EventInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventMapDecorationProto {
            decorations?: (POGOProtos.Rpc.EventMapDecorationProto.IEventMapDecoration[]|null);
        }

        class EventMapDecorationProto implements IEventMapDecorationProto {
            constructor(properties?: POGOProtos.Rpc.IEventMapDecorationProto);
            public decorations: POGOProtos.Rpc.EventMapDecorationProto.IEventMapDecoration[];
            public static encode(message: POGOProtos.Rpc.IEventMapDecorationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto;
            public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EventMapDecorationProto {

            interface IEventMapArea {
                id?: (string|null);
                asset_id?: (string|null);
                points?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng[]|null);
                holes?: (POGOProtos.Rpc.EventMapDecorationProto.IEventMapAreaHole[]|null);
                fade_distance?: (number|null);
            }

            class EventMapArea implements IEventMapArea {
                constructor(properties?: POGOProtos.Rpc.EventMapDecorationProto.IEventMapArea);
                public id: string;
                public asset_id: string;
                public points: POGOProtos.Rpc.EventMapDecorationProto.ILatLng[];
                public holes: POGOProtos.Rpc.EventMapDecorationProto.IEventMapAreaHole[];
                public fade_distance: number;
                public static encode(message: POGOProtos.Rpc.EventMapDecorationProto.IEventMapArea, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto.EventMapArea;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto.EventMapArea;
                public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto.EventMapArea, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEventMapAreaHole {
                points?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng[]|null);
            }

            class EventMapAreaHole implements IEventMapAreaHole {
                constructor(properties?: POGOProtos.Rpc.EventMapDecorationProto.IEventMapAreaHole);
                public points: POGOProtos.Rpc.EventMapDecorationProto.ILatLng[];
                public static encode(message: POGOProtos.Rpc.EventMapDecorationProto.IEventMapAreaHole, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto.EventMapAreaHole;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto.EventMapAreaHole;
                public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto.EventMapAreaHole, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEventMapDecoration {
                id?: (string|null);
                version?: (number|null);
                center?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng|null);
                radius?: (number|null);
                areas?: (POGOProtos.Rpc.EventMapDecorationProto.IEventMapArea[]|null);
                paths?: (POGOProtos.Rpc.EventMapDecorationProto.IEventMapPath[]|null);
                objects?: (POGOProtos.Rpc.EventMapDecorationProto.IEventMapObject[]|null);
            }

            class EventMapDecoration implements IEventMapDecoration {
                constructor(properties?: POGOProtos.Rpc.EventMapDecorationProto.IEventMapDecoration);
                public id: string;
                public version: number;
                public center?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng|null);
                public radius: number;
                public areas: POGOProtos.Rpc.EventMapDecorationProto.IEventMapArea[];
                public paths: POGOProtos.Rpc.EventMapDecorationProto.IEventMapPath[];
                public objects: POGOProtos.Rpc.EventMapDecorationProto.IEventMapObject[];
                public static encode(message: POGOProtos.Rpc.EventMapDecorationProto.IEventMapDecoration, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto.EventMapDecoration;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto.EventMapDecoration;
                public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto.EventMapDecoration, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEventMapObject {
                id?: (string|null);
                asset_id?: (string|null);
                point?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng|null);
                orientation?: (number|null);
                random_orientation?: (boolean|null);
            }

            class EventMapObject implements IEventMapObject {
                constructor(properties?: POGOProtos.Rpc.EventMapDecorationProto.IEventMapObject);
                public id: string;
                public asset_id: string;
                public point?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng|null);
                public orientation: number;
                public random_orientation: boolean;
                public static encode(message: POGOProtos.Rpc.EventMapDecorationProto.IEventMapObject, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto.EventMapObject;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto.EventMapObject;
                public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto.EventMapObject, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEventMapPath {
                id?: (string|null);
                asset_id?: (string|null);
                points?: (POGOProtos.Rpc.EventMapDecorationProto.ILatLng[]|null);
                smoothing?: (boolean|null);
                style?: (POGOProtos.Rpc.EventMapDecorationProto.EventMapPath.Style|null);
            }

            class EventMapPath implements IEventMapPath {
                constructor(properties?: POGOProtos.Rpc.EventMapDecorationProto.IEventMapPath);
                public id: string;
                public asset_id: string;
                public points: POGOProtos.Rpc.EventMapDecorationProto.ILatLng[];
                public smoothing: boolean;
                public style: POGOProtos.Rpc.EventMapDecorationProto.EventMapPath.Style;
                public static encode(message: POGOProtos.Rpc.EventMapDecorationProto.IEventMapPath, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto.EventMapPath;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto.EventMapPath;
                public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto.EventMapPath, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace EventMapPath {

                enum Style {
                    FLAT = 0,
                    HEDGE = 1
                }
            }

            interface ILatLng {
                lat_degree?: (number|null);
                lng_degree?: (number|null);
            }

            class LatLng implements ILatLng {
                constructor(properties?: POGOProtos.Rpc.EventMapDecorationProto.ILatLng);
                public lat_degree: number;
                public lng_degree: number;
                public static encode(message: POGOProtos.Rpc.EventMapDecorationProto.ILatLng, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationProto.LatLng;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationProto.LatLng;
                public static toObject(message: POGOProtos.Rpc.EventMapDecorationProto.LatLng, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IEventMapDecorationSettingsProto {
            event_map_decoration?: (POGOProtos.Rpc.IEventMapDecorationProto[]|null);
        }

        class EventMapDecorationSettingsProto implements IEventMapDecorationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventMapDecorationSettingsProto);
            public event_map_decoration: POGOProtos.Rpc.IEventMapDecorationProto[];
            public static encode(message: POGOProtos.Rpc.IEventMapDecorationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventMapDecorationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventMapDecorationSystemSettingsProto {
            event_map_decoration_template_ids?: (string[]|null);
        }

        class EventMapDecorationSystemSettingsProto implements IEventMapDecorationSystemSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventMapDecorationSystemSettingsProto);
            public event_map_decoration_template_ids: string[];
            public static encode(message: POGOProtos.Rpc.IEventMapDecorationSystemSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventMapDecorationSystemSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventMapDecorationSystemSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventMapDecorationSystemSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassDisplaySettingsProto {
            bonus_display_title?: (string|null);
            bonus_display_body?: (string|null);
            bonus_boxes?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            event_pass_track_upgrade_descriptions?: (POGOProtos.Rpc.EventPassDisplaySettingsProto.IEventPassTrackUpgradeDescriptionProto[]|null);
            event_pass_title_key?: (string|null);
            header_icon_url?: (string|null);
            premium_reward_banner_top?: (string|null);
            premium_reward_banner_middle?: (string|null);
            premium_reward_banner_bottom?: (string|null);
            premium_reward_banner_image_url?: (string|null);
            premium_rewards_description?: (string|null);
            today_view_section?: (POGOProtos.Rpc.EventPassDisplaySettingsProto.TodayViewSectionDisplay|null);
        }

        class EventPassDisplaySettingsProto implements IEventPassDisplaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassDisplaySettingsProto);
            public bonus_display_title: string;
            public bonus_display_body: string;
            public bonus_boxes: POGOProtos.Rpc.IBonusBoxProto[];
            public event_pass_track_upgrade_descriptions: POGOProtos.Rpc.EventPassDisplaySettingsProto.IEventPassTrackUpgradeDescriptionProto[];
            public event_pass_title_key: string;
            public header_icon_url: string;
            public premium_reward_banner_top: string;
            public premium_reward_banner_middle: string;
            public premium_reward_banner_bottom: string;
            public premium_reward_banner_image_url: string;
            public premium_rewards_description: string;
            public today_view_section: POGOProtos.Rpc.EventPassDisplaySettingsProto.TodayViewSectionDisplay;
            public static encode(message: POGOProtos.Rpc.IEventPassDisplaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassDisplaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassDisplaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventPassDisplaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EventPassDisplaySettingsProto {

            enum TodayViewSectionDisplay {
                EVENT_PASS_SECTION = 0,
                SEASONAL_EVENT_PASS_SECTION = 1,
                GLOBAL_EVENT_PASS_SECTION = 2
            }

            interface IEventPassTrackUpgradeDescriptionProto {
                pass_track_upgrade_header_description?: (string|null);
                event_pass_track_to_upgrade_to?: (POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack|null);
                track_unlock_sku_id?: (string|null);
                track_unlock_plus_points_sku_id?: (string|null);
                event_duration_key?: (string|null);
                upgrade_description_key?: (string|null);
                ranks_to_highlight_rewards?: (number[]|null);
                details_link_key?: (string|null);
                pass_track_upgrade_header_pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                pass_track_upgrade_header_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                track_unlock_image_url?: (string|null);
                track_unlock_plus_points_image_url?: (string|null);
            }

            class EventPassTrackUpgradeDescriptionProto implements IEventPassTrackUpgradeDescriptionProto {
                constructor(properties?: POGOProtos.Rpc.EventPassDisplaySettingsProto.IEventPassTrackUpgradeDescriptionProto);
                public pass_track_upgrade_header_description: string;
                public event_pass_track_to_upgrade_to: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack;
                public track_unlock_sku_id: string;
                public track_unlock_plus_points_sku_id: string;
                public event_duration_key: string;
                public upgrade_description_key: string;
                public ranks_to_highlight_rewards: number[];
                public details_link_key: string;
                public pass_track_upgrade_header_pokedex_id: POGOProtos.Rpc.HoloPokemonId;
                public pass_track_upgrade_header_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public track_unlock_image_url: string;
                public track_unlock_plus_points_image_url: string;
                public static encode(message: POGOProtos.Rpc.EventPassDisplaySettingsProto.IEventPassTrackUpgradeDescriptionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassDisplaySettingsProto.EventPassTrackUpgradeDescriptionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassDisplaySettingsProto.EventPassTrackUpgradeDescriptionProto;
                public static toObject(message: POGOProtos.Rpc.EventPassDisplaySettingsProto.EventPassTrackUpgradeDescriptionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IEventPassPointAttributesProto {
            event_pass_id?: (string|null);
        }

        class EventPassPointAttributesProto implements IEventPassPointAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassPointAttributesProto);
            public event_pass_id: string;
            public static encode(message: POGOProtos.Rpc.IEventPassPointAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassPointAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassPointAttributesProto;
            public static toObject(message: POGOProtos.Rpc.EventPassPointAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassSectionProto {
            bonus_quest_id?: (string[]|null);
            event_pass_display_settings?: (POGOProtos.Rpc.IEventPassDisplaySettingsProto|null);
            event_pass_id?: (string|null);
            expiration_time_ms?: (number|Long|null);
            grace_period_end_time_ms?: (number|Long|null);
        }

        class EventPassSectionProto implements IEventPassSectionProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassSectionProto);
            public bonus_quest_id: string[];
            public event_pass_display_settings?: (POGOProtos.Rpc.IEventPassDisplaySettingsProto|null);
            public event_pass_id: string;
            public expiration_time_ms: (number|Long);
            public grace_period_end_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IEventPassSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassSectionProto;
            public static toObject(message: POGOProtos.Rpc.EventPassSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassSettingsProto {
            prefix?: (string|null);
            points_item_id?: (POGOProtos.Rpc.Item|null);
            track_conditions?: (POGOProtos.Rpc.EventPassSettingsProto.IEventPassTrackConditionProto[]|null);
            expiration_time?: (string|null);
            max_tier_level?: (number|null);
            additional_bonus_tiers_level?: (number|null);
            event_pass_display_settings?: (POGOProtos.Rpc.IEventPassDisplaySettingsProto|null);
            grace_period_end_time?: (string|null);
        }

        class EventPassSettingsProto implements IEventPassSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassSettingsProto);
            public prefix: string;
            public points_item_id: POGOProtos.Rpc.Item;
            public track_conditions: POGOProtos.Rpc.EventPassSettingsProto.IEventPassTrackConditionProto[];
            public expiration_time: string;
            public max_tier_level: number;
            public additional_bonus_tiers_level: number;
            public event_pass_display_settings?: (POGOProtos.Rpc.IEventPassDisplaySettingsProto|null);
            public grace_period_end_time: string;
            public static encode(message: POGOProtos.Rpc.IEventPassSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventPassSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EventPassSettingsProto {

            interface IEventPassTrackConditionProto {
                track?: (POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack|null);
                badge?: (POGOProtos.Rpc.HoloBadgeType|null);
                is_locked?: (boolean|null);
                track_title_key?: (string|null);
            }

            class EventPassTrackConditionProto implements IEventPassTrackConditionProto {
                constructor(properties?: POGOProtos.Rpc.EventPassSettingsProto.IEventPassTrackConditionProto);
                public track: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack;
                public badge: POGOProtos.Rpc.HoloBadgeType;
                public is_locked: boolean;
                public track_title_key: string;
                public static encode(message: POGOProtos.Rpc.EventPassSettingsProto.IEventPassTrackConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassSettingsProto.EventPassTrackConditionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassSettingsProto.EventPassTrackConditionProto;
                public static toObject(message: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrackConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum EventPassTrack {
                EVENT_PASS_TRACK_UNSET = 0,
                FREE = 1,
                PREMIUM = 2
            }
        }

        interface IEventPassSlotRewardProto {
            slot?: (POGOProtos.Rpc.IClaimRewardsSlotProto|null);
            rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class EventPassSlotRewardProto implements IEventPassSlotRewardProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassSlotRewardProto);
            public slot?: (POGOProtos.Rpc.IClaimRewardsSlotProto|null);
            public rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IEventPassSlotRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassSlotRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassSlotRewardProto;
            public static toObject(message: POGOProtos.Rpc.EventPassSlotRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassStateProto {
            pass_id?: (string|null);
            current_rank?: (number|null);
            track_reward_states?: (POGOProtos.Rpc.EventPassStateProto.ITrackRewardsClaimStateProto[]|null);
            unconverted_local_expiration_time_ms?: (number|Long|null);
            encounters?: (POGOProtos.Rpc.IQuestPokemonEncounterProto[]|null);
            points_item_id?: (POGOProtos.Rpc.Item|null);
            last_update_timestamp_ms?: (number|Long|null);
        }

        class EventPassStateProto implements IEventPassStateProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassStateProto);
            public pass_id: string;
            public current_rank: number;
            public track_reward_states: POGOProtos.Rpc.EventPassStateProto.ITrackRewardsClaimStateProto[];
            public unconverted_local_expiration_time_ms: (number|Long);
            public encounters: POGOProtos.Rpc.IQuestPokemonEncounterProto[];
            public points_item_id: POGOProtos.Rpc.Item;
            public last_update_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IEventPassStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassStateProto;
            public static toObject(message: POGOProtos.Rpc.EventPassStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EventPassStateProto {

            interface ITrackRewardsClaimStateProto {
                track?: (POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack|null);
                is_rank_reward_claimed?: (Uint8Array|null);
            }

            class TrackRewardsClaimStateProto implements ITrackRewardsClaimStateProto {
                constructor(properties?: POGOProtos.Rpc.EventPassStateProto.ITrackRewardsClaimStateProto);
                public track: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack;
                public is_rank_reward_claimed: Uint8Array;
                public static encode(message: POGOProtos.Rpc.EventPassStateProto.ITrackRewardsClaimStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassStateProto.TrackRewardsClaimStateProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassStateProto.TrackRewardsClaimStateProto;
                public static toObject(message: POGOProtos.Rpc.EventPassStateProto.TrackRewardsClaimStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IEventPassSystemSettingsProto {
            event_pass_ids_to_add?: (string[]|null);
        }

        class EventPassSystemSettingsProto implements IEventPassSystemSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassSystemSettingsProto);
            public event_pass_ids_to_add: string[];
            public static encode(message: POGOProtos.Rpc.IEventPassSystemSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassSystemSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassSystemSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventPassSystemSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassTierBonusSettingsProto {
            event_name?: (string|null);
            bonus_boxes?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
        }

        class EventPassTierBonusSettingsProto implements IEventPassTierBonusSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassTierBonusSettingsProto);
            public event_name: string;
            public bonus_boxes: POGOProtos.Rpc.IBonusBoxProto[];
            public static encode(message: POGOProtos.Rpc.IEventPassTierBonusSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassTierBonusSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassTierBonusSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventPassTierBonusSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassTierSettingsProto {
            rank?: (number|null);
            track?: (POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack|null);
            min_points_required?: (number|null);
            rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
            bonus_settings?: (POGOProtos.Rpc.IEventPassTierBonusSettingsProto|null);
        }

        class EventPassTierSettingsProto implements IEventPassTierSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassTierSettingsProto);
            public rank: number;
            public track: POGOProtos.Rpc.EventPassSettingsProto.EventPassTrack;
            public min_points_required: number;
            public rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public bonus_settings?: (POGOProtos.Rpc.IEventPassTierBonusSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IEventPassTierSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassTierSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassTierSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventPassTierSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassUpdateLogEntry {
            event_pass_id?: (string|null);
            event_pass_title_key?: (string|null);
            current_rank?: (number|null);
        }

        class EventPassUpdateLogEntry implements IEventPassUpdateLogEntry {
            constructor(properties?: POGOProtos.Rpc.IEventPassUpdateLogEntry);
            public event_pass_id: string;
            public event_pass_title_key: string;
            public current_rank: number;
            public static encode(message: POGOProtos.Rpc.IEventPassUpdateLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassUpdateLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassUpdateLogEntry;
            public static toObject(message: POGOProtos.Rpc.EventPassUpdateLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPassesStateProto {
            event_passes?: (POGOProtos.Rpc.IEventPassStateProto[]|null);
        }

        class EventPassesStateProto implements IEventPassesStateProto {
            constructor(properties?: POGOProtos.Rpc.IEventPassesStateProto);
            public event_passes: POGOProtos.Rpc.IEventPassStateProto[];
            public static encode(message: POGOProtos.Rpc.IEventPassesStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPassesStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPassesStateProto;
            public static toObject(message: POGOProtos.Rpc.EventPassesStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPlannerNotification {
            timing_type?: (POGOProtos.Rpc.PlannedEventSettingsProto.MessagingTimingType|null);
            holo_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            poi_image_url?: (string|null);
            event_type?: (POGOProtos.Rpc.PlannedEventSettingsProto.EventType|null);
            rsvp_going_count?: (number|null);
            event_start_time?: (number|Long|null);
            poi_id?: (string|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            poi_lat?: (number|null);
            poi_lng?: (number|null);
            raid_level?: (POGOProtos.Rpc.RaidLevel|null);
        }

        class EventPlannerNotification implements IEventPlannerNotification {
            constructor(properties?: POGOProtos.Rpc.IEventPlannerNotification);
            public timing_type: POGOProtos.Rpc.PlannedEventSettingsProto.MessagingTimingType;
            public holo_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public poi_image_url: string;
            public event_type: POGOProtos.Rpc.PlannedEventSettingsProto.EventType;
            public rsvp_going_count: number;
            public event_start_time: (number|Long);
            public poi_id: string;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public poi_lat: number;
            public poi_lng: number;
            public raid_level: POGOProtos.Rpc.RaidLevel;
            public static encode(message: POGOProtos.Rpc.IEventPlannerNotification, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPlannerNotification;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPlannerNotification;
            public static toObject(message: POGOProtos.Rpc.EventPlannerNotification, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventPlannerPopularNotificationSettings {
            scan_interval_seconds?: (number|Long|null);
            first_scan_offset_seconds?: (number|Long|null);
            nearby_poi_threshold?: (number|null);
            urban_threshold?: (number|null);
            rural_threshold?: (number|null);
            max_notif_per_day?: (number|null);
            notif_delay_intervals_seconds?: (number|Long|null);
            timeslot_buffer_window_seconds?: (number|Long|null);
            battle_levels?: (number[]|null);
        }

        class EventPlannerPopularNotificationSettings implements IEventPlannerPopularNotificationSettings {
            constructor(properties?: POGOProtos.Rpc.IEventPlannerPopularNotificationSettings);
            public scan_interval_seconds: (number|Long);
            public first_scan_offset_seconds: (number|Long);
            public nearby_poi_threshold: number;
            public urban_threshold: number;
            public rural_threshold: number;
            public max_notif_per_day: number;
            public notif_delay_intervals_seconds: (number|Long);
            public timeslot_buffer_window_seconds: (number|Long);
            public battle_levels: number[];
            public static encode(message: POGOProtos.Rpc.IEventPlannerPopularNotificationSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventPlannerPopularNotificationSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventPlannerPopularNotificationSettings;
            public static toObject(message: POGOProtos.Rpc.EventPlannerPopularNotificationSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventRsvpInvitationDetailsProto {
            location_id?: (string|null);
            timeslot_ms?: (number|Long|null);
            inviter_nickname?: (string|null);
            inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            inviter_team?: (POGOProtos.Rpc.Team|null);
            raid?: (POGOProtos.Rpc.IRaidDetails|null);
            gmax_battle?: (POGOProtos.Rpc.IGMaxDetails|null);
        }

        class EventRsvpInvitationDetailsProto implements IEventRsvpInvitationDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IEventRsvpInvitationDetailsProto);
            public location_id: string;
            public timeslot_ms: (number|Long);
            public inviter_nickname: string;
            public inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public inviter_team: POGOProtos.Rpc.Team;
            public raid?: (POGOProtos.Rpc.IRaidDetails|null);
            public gmax_battle?: (POGOProtos.Rpc.IGMaxDetails|null);
            public EventDetails?: ("raid"|"gmax_battle");
            public static encode(message: POGOProtos.Rpc.IEventRsvpInvitationDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventRsvpInvitationDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventRsvpInvitationDetailsProto;
            public static toObject(message: POGOProtos.Rpc.EventRsvpInvitationDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventRsvpProto {
            timestamp_ms?: (number|Long|null);
            rsvp_selection?: (POGOProtos.Rpc.RsvpSelection|null);
            raid?: (POGOProtos.Rpc.IRaidDetails|null);
            gmax_battle?: (POGOProtos.Rpc.IGMaxDetails|null);
            num_invites_sent?: (number|null);
        }

        class EventRsvpProto implements IEventRsvpProto {
            constructor(properties?: POGOProtos.Rpc.IEventRsvpProto);
            public timestamp_ms: (number|Long);
            public rsvp_selection: POGOProtos.Rpc.RsvpSelection;
            public raid?: (POGOProtos.Rpc.IRaidDetails|null);
            public gmax_battle?: (POGOProtos.Rpc.IGMaxDetails|null);
            public num_invites_sent: number;
            public EventDetails?: ("raid"|"gmax_battle");
            public static encode(message: POGOProtos.Rpc.IEventRsvpProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventRsvpProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventRsvpProto;
            public static toObject(message: POGOProtos.Rpc.EventRsvpProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventRsvpTimeslotProto {
            time_slot?: (number|Long|null);
            going_count?: (number|null);
            maybe_count?: (number|null);
            rsvp_players?: (POGOProtos.Rpc.EventRsvpTimeslotProto.IRsvpPlayer[]|null);
        }

        class EventRsvpTimeslotProto implements IEventRsvpTimeslotProto {
            constructor(properties?: POGOProtos.Rpc.IEventRsvpTimeslotProto);
            public time_slot: (number|Long);
            public going_count: number;
            public maybe_count: number;
            public rsvp_players: POGOProtos.Rpc.EventRsvpTimeslotProto.IRsvpPlayer[];
            public static encode(message: POGOProtos.Rpc.IEventRsvpTimeslotProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventRsvpTimeslotProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventRsvpTimeslotProto;
            public static toObject(message: POGOProtos.Rpc.EventRsvpTimeslotProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EventRsvpTimeslotProto {

            interface IRsvpPlayer {
                anonymous_count?: (number|null);
                trainer_details?: (POGOProtos.Rpc.EventRsvpTimeslotProto.IPlayerDetails|null);
                rsvp_selection?: (POGOProtos.Rpc.RsvpSelection|null);
                share_preference?: (POGOProtos.Rpc.NameSharingPreferencesProto.Preference|null);
                isFriend?: (boolean|null);
            }

            class RsvpPlayer implements IRsvpPlayer {
                constructor(properties?: POGOProtos.Rpc.EventRsvpTimeslotProto.IRsvpPlayer);
                public anonymous_count?: (number|null);
                public trainer_details?: (POGOProtos.Rpc.EventRsvpTimeslotProto.IPlayerDetails|null);
                public rsvp_selection: POGOProtos.Rpc.RsvpSelection;
                public share_preference: POGOProtos.Rpc.NameSharingPreferencesProto.Preference;
                public isFriend: boolean;
                public Type?: ("anonymous_count"|"trainer_details");
                public static encode(message: POGOProtos.Rpc.EventRsvpTimeslotProto.IRsvpPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventRsvpTimeslotProto.RsvpPlayer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventRsvpTimeslotProto.RsvpPlayer;
                public static toObject(message: POGOProtos.Rpc.EventRsvpTimeslotProto.RsvpPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerDetails {
                nickname?: (string|null);
                inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
                player_id?: (string|null);
            }

            class PlayerDetails implements IPlayerDetails {
                constructor(properties?: POGOProtos.Rpc.EventRsvpTimeslotProto.IPlayerDetails);
                public nickname: string;
                public inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
                public player_id: string;
                public static encode(message: POGOProtos.Rpc.EventRsvpTimeslotProto.IPlayerDetails, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventRsvpTimeslotProto.PlayerDetails;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventRsvpTimeslotProto.PlayerDetails;
                public static toObject(message: POGOProtos.Rpc.EventRsvpTimeslotProto.PlayerDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IEventRsvpsProto {
            event_rsvp?: (POGOProtos.Rpc.IEventRsvpProto[]|null);
        }

        class EventRsvpsProto implements IEventRsvpsProto {
            constructor(properties?: POGOProtos.Rpc.IEventRsvpsProto);
            public event_rsvp: POGOProtos.Rpc.IEventRsvpProto[];
            public static encode(message: POGOProtos.Rpc.IEventRsvpsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventRsvpsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventRsvpsProto;
            public static toObject(message: POGOProtos.Rpc.EventRsvpsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventSectionProto {
            event_name?: (string|null);
            end_time?: (POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto|null);
            ref_news_id?: (string|null);
            bonus_boxes?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            start_time?: (POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto|null);
            banner_url?: (string|null);
            icon_url?: (string|null);
            blog_url?: (string|null);
            priority?: (number|Long|null);
            enable_local_timezone?: (boolean|null);
            banner_display_offset_days?: (number|Long|null);
        }

        class EventSectionProto implements IEventSectionProto {
            constructor(properties?: POGOProtos.Rpc.IEventSectionProto);
            public event_name: string;
            public end_time?: (POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto|null);
            public ref_news_id: string;
            public bonus_boxes: POGOProtos.Rpc.IBonusBoxProto[];
            public start_time?: (POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto|null);
            public banner_url: string;
            public icon_url: string;
            public blog_url: string;
            public priority: (number|Long);
            public enable_local_timezone: boolean;
            public banner_display_offset_days: (number|Long);
            public static encode(message: POGOProtos.Rpc.IEventSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventSectionProto;
            public static toObject(message: POGOProtos.Rpc.EventSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventSettingsProto {
            condolence_ribbon_country?: (string[]|null);
            enable_event_link?: (boolean|null);
            enable_event_link_for_children?: (boolean|null);
            event_webtoken_server_url?: (string|null);
            enable_event_lnt?: (boolean|null);
            event_lnt_url?: (string|null);
        }

        class EventSettingsProto implements IEventSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEventSettingsProto);
            public condolence_ribbon_country: string[];
            public enable_event_link: boolean;
            public enable_event_link_for_children: boolean;
            public event_webtoken_server_url: string;
            public enable_event_lnt: boolean;
            public event_lnt_url: string;
            public static encode(message: POGOProtos.Rpc.IEventSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EventSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventTicketActiveTimeProto {
            event_ticket?: (POGOProtos.Rpc.Item|null);
            event_start_ms?: (number|Long|null);
            event_end_ms?: (number|Long|null);
        }

        class EventTicketActiveTimeProto implements IEventTicketActiveTimeProto {
            constructor(properties?: POGOProtos.Rpc.IEventTicketActiveTimeProto);
            public event_ticket: POGOProtos.Rpc.Item;
            public event_start_ms: (number|Long);
            public event_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IEventTicketActiveTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EventTicketActiveTimeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EventTicketActiveTimeProto;
            public static toObject(message: POGOProtos.Rpc.EventTicketActiveTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolutionBranchProto {
            evolution?: (POGOProtos.Rpc.HoloPokemonId|null);
            evolution_item_requirement?: (POGOProtos.Rpc.Item|null);
            candy_cost?: (number|null);
            km_buddy_distance_requirement?: (number|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            gender_requirement?: (POGOProtos.Rpc.PokemonDisplayProto.Gender|null);
            lure_item_requirement?: (POGOProtos.Rpc.Item|null);
            must_be_buddy?: (boolean|null);
            only_daytime?: (boolean|null);
            only_nighttime?: (boolean|null);
            priority?: (number|null);
            no_candy_cost_via_trade?: (boolean|null);
            temporary_evolution?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            temporary_evolution_energy_cost?: (number|null);
            temporary_evolution_energy_cost_subsequent?: (number|null);
            quest_display?: (POGOProtos.Rpc.IEvolutionQuestInfoProto[]|null);
            only_upside_down?: (boolean|null);
            candy_cost_purified?: (number|null);
            only_dusk_period?: (boolean|null);
            only_full_moon?: (boolean|null);
            evolution_item_requirement_cost?: (number|null);
            evolution_move_requirement?: (POGOProtos.Rpc.HoloPokemonMove|null);
            evolution_likelihood_weight?: (number|null);
            should_hide_button?: (boolean|null);
        }

        class EvolutionBranchProto implements IEvolutionBranchProto {
            constructor(properties?: POGOProtos.Rpc.IEvolutionBranchProto);
            public evolution: POGOProtos.Rpc.HoloPokemonId;
            public evolution_item_requirement: POGOProtos.Rpc.Item;
            public candy_cost: number;
            public km_buddy_distance_requirement: number;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public gender_requirement: POGOProtos.Rpc.PokemonDisplayProto.Gender;
            public lure_item_requirement: POGOProtos.Rpc.Item;
            public must_be_buddy: boolean;
            public only_daytime: boolean;
            public only_nighttime: boolean;
            public priority: number;
            public no_candy_cost_via_trade: boolean;
            public temporary_evolution: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public temporary_evolution_energy_cost: number;
            public temporary_evolution_energy_cost_subsequent: number;
            public quest_display: POGOProtos.Rpc.IEvolutionQuestInfoProto[];
            public only_upside_down: boolean;
            public candy_cost_purified: number;
            public only_dusk_period: boolean;
            public only_full_moon: boolean;
            public evolution_item_requirement_cost: number;
            public evolution_move_requirement: POGOProtos.Rpc.HoloPokemonMove;
            public evolution_likelihood_weight: number;
            public should_hide_button: boolean;
            public static encode(message: POGOProtos.Rpc.IEvolutionBranchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolutionBranchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolutionBranchProto;
            public static toObject(message: POGOProtos.Rpc.EvolutionBranchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolutionChainDisplayProto {
            header_message?: (string|null);
            evolution_infos?: (POGOProtos.Rpc.IEvolutionDisplayInfoProto[]|null);
        }

        class EvolutionChainDisplayProto implements IEvolutionChainDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IEvolutionChainDisplayProto);
            public header_message: string;
            public evolution_infos: POGOProtos.Rpc.IEvolutionDisplayInfoProto[];
            public static encode(message: POGOProtos.Rpc.IEvolutionChainDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolutionChainDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolutionChainDisplayProto;
            public static toObject(message: POGOProtos.Rpc.EvolutionChainDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolutionChainDisplaySettingsProto {
            pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            evolution_chains?: (POGOProtos.Rpc.IEvolutionChainDisplayProto[]|null);
        }

        class EvolutionChainDisplaySettingsProto implements IEvolutionChainDisplaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEvolutionChainDisplaySettingsProto);
            public pokemon: POGOProtos.Rpc.HoloPokemonId;
            public evolution_chains: POGOProtos.Rpc.IEvolutionChainDisplayProto[];
            public static encode(message: POGOProtos.Rpc.IEvolutionChainDisplaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolutionChainDisplaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolutionChainDisplaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.EvolutionChainDisplaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolutionDisplayInfoProto {
            pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            gender?: (POGOProtos.Rpc.PokemonDisplayProto.Gender|null);
        }

        class EvolutionDisplayInfoProto implements IEvolutionDisplayInfoProto {
            constructor(properties?: POGOProtos.Rpc.IEvolutionDisplayInfoProto);
            public pokemon: POGOProtos.Rpc.HoloPokemonId;
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public gender: POGOProtos.Rpc.PokemonDisplayProto.Gender;
            public static encode(message: POGOProtos.Rpc.IEvolutionDisplayInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolutionDisplayInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolutionDisplayInfoProto;
            public static toObject(message: POGOProtos.Rpc.EvolutionDisplayInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolutionQuestInfoProto {
            quest_requirement_template_id?: (string|null);
            description?: (string|null);
            target?: (number|null);
        }

        class EvolutionQuestInfoProto implements IEvolutionQuestInfoProto {
            constructor(properties?: POGOProtos.Rpc.IEvolutionQuestInfoProto);
            public quest_requirement_template_id: string;
            public description: string;
            public target: number;
            public static encode(message: POGOProtos.Rpc.IEvolutionQuestInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolutionQuestInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolutionQuestInfoProto;
            public static toObject(message: POGOProtos.Rpc.EvolutionQuestInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolutionV2SettingsProto {
            is_enabled?: (boolean|null);
        }

        class EvolutionV2SettingsProto implements IEvolutionV2SettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEvolutionV2SettingsProto);
            public is_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IEvolutionV2SettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolutionV2SettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolutionV2SettingsProto;
            public static toObject(message: POGOProtos.Rpc.EvolutionV2SettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolveIntoPokemonQuestProto {
            unique_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId[]|null);
        }

        class EvolveIntoPokemonQuestProto implements IEvolveIntoPokemonQuestProto {
            constructor(properties?: POGOProtos.Rpc.IEvolveIntoPokemonQuestProto);
            public unique_pokemon_id: POGOProtos.Rpc.HoloPokemonId[];
            public static encode(message: POGOProtos.Rpc.IEvolveIntoPokemonQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolveIntoPokemonQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolveIntoPokemonQuestProto;
            public static toObject(message: POGOProtos.Rpc.EvolveIntoPokemonQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolvePokemonOutProto {
            result?: (POGOProtos.Rpc.EvolvePokemonOutProto.Result|null);
            evolved_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            exp_awarded?: (number|null);
            candy_awarded?: (number|null);
            preview?: (POGOProtos.Rpc.IPreviewProto|null);
            items_awarded?: (POGOProtos.Rpc.ILootProto[]|null);
        }

        class EvolvePokemonOutProto implements IEvolvePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IEvolvePokemonOutProto);
            public result: POGOProtos.Rpc.EvolvePokemonOutProto.Result;
            public evolved_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public exp_awarded: number;
            public candy_awarded: number;
            public preview?: (POGOProtos.Rpc.IPreviewProto|null);
            public items_awarded: POGOProtos.Rpc.ILootProto[];
            public static encode(message: POGOProtos.Rpc.IEvolvePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolvePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolvePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.EvolvePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace EvolvePokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILED_POKEMON_MISSING = 2,
                FAILED_INSUFFICIENT_RESOURCES = 3,
                FAILED_POKEMON_CANNOT_EVOLVE = 4,
                FAILED_POKEMON_IS_DEPLOYED = 5,
                FAILED_INVALID_ITEM_REQUIREMENT = 6,
                FAILED_FUSION_POKEMON = 7,
                FAILED_FUSION_COMPONENT_POKEMON = 8
            }
        }

        interface IEvolvePokemonProto {
            pokemon_id?: (number|Long|null);
            evolution_item_requirement?: (POGOProtos.Rpc.Item|null);
            target_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            target_pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            use_special?: (boolean|null);
            preview?: (boolean|null);
            debug_proto?: (POGOProtos.Rpc.IDebugEvolvePreviewProto|null);
            evolution_item_requirement_count?: (number|null);
            enabled_by_player_bonus?: (boolean|null);
        }

        class EvolvePokemonProto implements IEvolvePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IEvolvePokemonProto);
            public pokemon_id: (number|Long);
            public evolution_item_requirement: POGOProtos.Rpc.Item;
            public target_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public target_pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public use_special: boolean;
            public preview: boolean;
            public debug_proto?: (POGOProtos.Rpc.IDebugEvolvePreviewProto|null);
            public evolution_item_requirement_count: number;
            public enabled_by_player_bonus: boolean;
            public static encode(message: POGOProtos.Rpc.IEvolvePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolvePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolvePokemonProto;
            public static toObject(message: POGOProtos.Rpc.EvolvePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolvePokemonTelemetry {
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            evolved_pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
        }

        class EvolvePokemonTelemetry implements IEvolvePokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IEvolvePokemonTelemetry);
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public evolved_pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public static encode(message: POGOProtos.Rpc.IEvolvePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolvePokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolvePokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.EvolvePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEvolvePreviewSettingsProto {
            enable_evolve_preview_debug_logging?: (boolean|null);
        }

        class EvolvePreviewSettingsProto implements IEvolvePreviewSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IEvolvePreviewSettingsProto);
            public enable_evolve_preview_debug_logging: boolean;
            public static encode(message: POGOProtos.Rpc.IEvolvePreviewSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.EvolvePreviewSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.EvolvePreviewSettingsProto;
            public static toObject(message: POGOProtos.Rpc.EvolvePreviewSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IExceptionCaughtData {
            exception_code?: (number|null);
            location?: (POGOProtos.Rpc.ExceptionCaughtData.ExceptionLocation|null);
        }

        class ExceptionCaughtData implements IExceptionCaughtData {
            constructor(properties?: POGOProtos.Rpc.IExceptionCaughtData);
            public exception_code: number;
            public location: POGOProtos.Rpc.ExceptionCaughtData.ExceptionLocation;
            public static encode(message: POGOProtos.Rpc.IExceptionCaughtData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ExceptionCaughtData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ExceptionCaughtData;
            public static toObject(message: POGOProtos.Rpc.ExceptionCaughtData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ExceptionCaughtData {

            enum ExceptionLocation {
                NO_EXCEPTION = 0
            }
        }

        interface IExceptionCaughtInCombatData {
            exception_code?: (number|null);
            location?: (POGOProtos.Rpc.ExceptionCaughtInCombatData.ExceptionLocation|null);
        }

        class ExceptionCaughtInCombatData implements IExceptionCaughtInCombatData {
            constructor(properties?: POGOProtos.Rpc.IExceptionCaughtInCombatData);
            public exception_code: number;
            public location: POGOProtos.Rpc.ExceptionCaughtInCombatData.ExceptionLocation;
            public static encode(message: POGOProtos.Rpc.IExceptionCaughtInCombatData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ExceptionCaughtInCombatData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ExceptionCaughtInCombatData;
            public static toObject(message: POGOProtos.Rpc.ExceptionCaughtInCombatData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ExceptionCaughtInCombatData {

            enum ExceptionLocation {
                NO_EXCEPTION = 0,
                COMBAT_PUB_SUB = 1
            }
        }

        interface IExperience {
            experience_id?: (string|null);
            name?: (string|null);
            description?: (string|null);
            empty_room_timeout_seconds?: (number|null);
            init_data?: ({ [k: string]: Uint8Array }|null);
            app_id?: (string|null);
            lat?: (number|null);
            lng?: (number|null);
        }

        class Experience implements IExperience {
            constructor(properties?: POGOProtos.Rpc.IExperience);
            public experience_id: string;
            public name: string;
            public description: string;
            public empty_room_timeout_seconds: number;
            public init_data: { [k: string]: Uint8Array };
            public app_id: string;
            public lat: number;
            public lng: number;
            public static encode(message: POGOProtos.Rpc.IExperience, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Experience;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Experience;
            public static toObject(message: POGOProtos.Rpc.Experience, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IExperienceBoostAttributesProto {
            xp_multiplier?: (number|null);
            boost_duration_ms?: (number|null);
        }

        class ExperienceBoostAttributesProto implements IExperienceBoostAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IExperienceBoostAttributesProto);
            public xp_multiplier: number;
            public boost_duration_ms: number;
            public static encode(message: POGOProtos.Rpc.IExperienceBoostAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ExperienceBoostAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ExperienceBoostAttributesProto;
            public static toObject(message: POGOProtos.Rpc.ExperienceBoostAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IExtensionRangeOptions {
            uninterpreted_option?: (POGOProtos.Rpc.IUninterpretedOption[]|null);
            declaration?: (POGOProtos.Rpc.ExtensionRangeOptions.IDeclaration[]|null);
            features?: (POGOProtos.Rpc.IFeatureSet|null);
            verification?: (POGOProtos.Rpc.ExtensionRangeOptions.VerificationState|null);
        }

        class ExtensionRangeOptions implements IExtensionRangeOptions {
            constructor(properties?: POGOProtos.Rpc.IExtensionRangeOptions);
            public uninterpreted_option: POGOProtos.Rpc.IUninterpretedOption[];
            public declaration: POGOProtos.Rpc.ExtensionRangeOptions.IDeclaration[];
            public features?: (POGOProtos.Rpc.IFeatureSet|null);
            public verification: POGOProtos.Rpc.ExtensionRangeOptions.VerificationState;
            public static encode(message: POGOProtos.Rpc.IExtensionRangeOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ExtensionRangeOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ExtensionRangeOptions;
            public static toObject(message: POGOProtos.Rpc.ExtensionRangeOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ExtensionRangeOptions {

            enum VerificationState {
                STATE_DECLARATION = 0,
                STATE_UNVERIFIED = 1
            }

            interface IDeclaration {
                number?: (number|null);
                full_name?: (string|null);
                type?: (string|null);
                reserved?: (boolean|null);
                repeated?: (boolean|null);
            }

            class Declaration implements IDeclaration {
                constructor(properties?: POGOProtos.Rpc.ExtensionRangeOptions.IDeclaration);
                public number: number;
                public full_name: string;
                public type: string;
                public reserved: boolean;
                public repeated: boolean;
                public static encode(message: POGOProtos.Rpc.ExtensionRangeOptions.IDeclaration, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ExtensionRangeOptions.Declaration;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ExtensionRangeOptions.Declaration;
                public static toObject(message: POGOProtos.Rpc.ExtensionRangeOptions.Declaration, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IExternalAddressableAssetsProto {
            main_catalog_id?: (number|null);
            avatar_catalog_id?: (number|null);
        }

        class ExternalAddressableAssetsProto implements IExternalAddressableAssetsProto {
            constructor(properties?: POGOProtos.Rpc.IExternalAddressableAssetsProto);
            public main_catalog_id: number;
            public avatar_catalog_id: number;
            public static encode(message: POGOProtos.Rpc.IExternalAddressableAssetsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ExternalAddressableAssetsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ExternalAddressableAssetsProto;
            public static toObject(message: POGOProtos.Rpc.ExternalAddressableAssetsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFakeDataProto {
            fake_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class FakeDataProto implements IFakeDataProto {
            constructor(properties?: POGOProtos.Rpc.IFakeDataProto);
            public fake_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IFakeDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FakeDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FakeDataProto;
            public static toObject(message: POGOProtos.Rpc.FakeDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFavoritePokemonTelemetry {
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            favored?: (boolean|null);
        }

        class FavoritePokemonTelemetry implements IFavoritePokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IFavoritePokemonTelemetry);
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public favored: boolean;
            public static encode(message: POGOProtos.Rpc.IFavoritePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FavoritePokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FavoritePokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.FavoritePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFavoriteRouteOutProto {
            result?: (POGOProtos.Rpc.FavoriteRouteOutProto.Result|null);
        }

        class FavoriteRouteOutProto implements IFavoriteRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.IFavoriteRouteOutProto);
            public result: POGOProtos.Rpc.FavoriteRouteOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IFavoriteRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FavoriteRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FavoriteRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.FavoriteRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FavoriteRouteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ROUTE_NOT_FOUND = 2,
                ERROR_RATE_LIMITED = 3,
                ERROR_NO_CHANGE = 4,
                ERROR_UNKNOWN = 5,
                ERROR_MAX_FAVORITE = 6
            }
        }

        interface IFavoriteRouteProto {
            route_id?: (string|null);
            favorite?: (boolean|null);
        }

        class FavoriteRouteProto implements IFavoriteRouteProto {
            constructor(properties?: POGOProtos.Rpc.IFavoriteRouteProto);
            public route_id: string;
            public favorite: boolean;
            public static encode(message: POGOProtos.Rpc.IFavoriteRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FavoriteRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FavoriteRouteProto;
            public static toObject(message: POGOProtos.Rpc.FavoriteRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFbTokenProto {
            token?: (string|null);
            nonce?: (string|null);
            is_limited_login_token?: (boolean|null);
        }

        class FbTokenProto implements IFbTokenProto {
            constructor(properties?: POGOProtos.Rpc.IFbTokenProto);
            public token: string;
            public nonce: string;
            public is_limited_login_token: boolean;
            public static encode(message: POGOProtos.Rpc.IFbTokenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FbTokenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FbTokenProto;
            public static toObject(message: POGOProtos.Rpc.FbTokenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFeature {
            building_metadata?: (POGOProtos.Rpc.IBuildingMetadata|null);
            road_metadata?: (POGOProtos.Rpc.IRoadMetadata|null);
            transit_metadata?: (POGOProtos.Rpc.ITransitMetadata|null);
            geometry?: (POGOProtos.Rpc.IGeometry|null);
            label?: (POGOProtos.Rpc.ILabel|null);
            is_private?: (boolean|null);
            feature_kind?: (POGOProtos.Rpc.FeatureKind|null);
        }

        class Feature implements IFeature {
            constructor(properties?: POGOProtos.Rpc.IFeature);
            public building_metadata?: (POGOProtos.Rpc.IBuildingMetadata|null);
            public road_metadata?: (POGOProtos.Rpc.IRoadMetadata|null);
            public transit_metadata?: (POGOProtos.Rpc.ITransitMetadata|null);
            public geometry?: (POGOProtos.Rpc.IGeometry|null);
            public label?: (POGOProtos.Rpc.ILabel|null);
            public is_private: boolean;
            public feature_kind: POGOProtos.Rpc.FeatureKind;
            public Metadata?: ("building_metadata"|"road_metadata"|"transit_metadata");
            public static encode(message: POGOProtos.Rpc.IFeature, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Feature;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Feature;
            public static toObject(message: POGOProtos.Rpc.Feature, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFeatureGateProto {
            status?: (number|null);
            rollout_percentage?: (number|null);
            sub_feature_gate_list?: (POGOProtos.Rpc.FeatureGateProto.ISubFeatureGateProto[]|null);
            code_gate_owner?: (string|null);
            expiration_timestamp_ms?: (number|Long|null);
        }

        class FeatureGateProto implements IFeatureGateProto {
            constructor(properties?: POGOProtos.Rpc.IFeatureGateProto);
            public status: number;
            public rollout_percentage: number;
            public sub_feature_gate_list: POGOProtos.Rpc.FeatureGateProto.ISubFeatureGateProto[];
            public code_gate_owner: string;
            public expiration_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IFeatureGateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeatureGateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeatureGateProto;
            public static toObject(message: POGOProtos.Rpc.FeatureGateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FeatureGateProto {

            interface ISubFeatureGateProto {
                name?: (string|null);
                status?: (number|null);
                rollout_percentage?: (number|null);
            }

            class SubFeatureGateProto implements ISubFeatureGateProto {
                constructor(properties?: POGOProtos.Rpc.FeatureGateProto.ISubFeatureGateProto);
                public name: string;
                public status: number;
                public rollout_percentage: number;
                public static encode(message: POGOProtos.Rpc.FeatureGateProto.ISubFeatureGateProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeatureGateProto.SubFeatureGateProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeatureGateProto.SubFeatureGateProto;
                public static toObject(message: POGOProtos.Rpc.FeatureGateProto.SubFeatureGateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IFeatureSet {
            field_presence?: (POGOProtos.Rpc.FeatureSet.FieldPresence|null);
            enum_type?: (POGOProtos.Rpc.FeatureSet.EnumType|null);
            repeated_field_encoding?: (POGOProtos.Rpc.FeatureSet.RepeatedFieldEncoding|null);
            utf8_validation?: (POGOProtos.Rpc.FeatureSet.Utf8Validation|null);
            message_encoding?: (POGOProtos.Rpc.FeatureSet.MessageEncoding|null);
            json_format?: (POGOProtos.Rpc.FeatureSet.JsonFormat|null);
        }

        class FeatureSet implements IFeatureSet {
            constructor(properties?: POGOProtos.Rpc.IFeatureSet);
            public field_presence: POGOProtos.Rpc.FeatureSet.FieldPresence;
            public enum_type: POGOProtos.Rpc.FeatureSet.EnumType;
            public repeated_field_encoding: POGOProtos.Rpc.FeatureSet.RepeatedFieldEncoding;
            public utf8_validation: POGOProtos.Rpc.FeatureSet.Utf8Validation;
            public message_encoding: POGOProtos.Rpc.FeatureSet.MessageEncoding;
            public json_format: POGOProtos.Rpc.FeatureSet.JsonFormat;
            public static encode(message: POGOProtos.Rpc.IFeatureSet, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeatureSet;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeatureSet;
            public static toObject(message: POGOProtos.Rpc.FeatureSet, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FeatureSet {

            enum EnumType {
                TYPE_UNKNOWN = 0,
                TYPE_OPEN = 1,
                TYPE_CLOSED = 2
            }

            enum FieldPresence {
                PRESENCE_UNKNOWN = 0,
                PRESENCE_EXPLICIT = 1,
                PRESENCE_IMPLICIT = 2,
                PRESENCE_LEGACY_REQUIRED = 3
            }

            enum JsonFormat {
                JSON_UNKNOWN = 0,
                JSON_ALLOW = 1,
                JSON_LEGACY_BEST_EFFORT = 2
            }

            enum MessageEncoding {
                ENC_UNKNOWN = 0,
                ENC_LENGTH_PREFIXED = 1,
                ENC_DELIMITED = 2
            }

            enum RepeatedFieldEncoding {
                FIELD_UNKNOWN = 0,
                FIELD_PACKED = 1,
                FIELD_EXPANDED = 2
            }

            enum Utf8Validation {
                UNKNOWN = 0,
                NONE = 1,
                VERIFY = 2
            }
        }

        interface IFeatureSetDefaults {
            defaults?: (POGOProtos.Rpc.FeatureSetDefaults.IFeatureSetEditionDefault[]|null);
            minimum_edition?: (POGOProtos.Rpc.Edition|null);
            maximum_edition?: (POGOProtos.Rpc.Edition|null);
        }

        class FeatureSetDefaults implements IFeatureSetDefaults {
            constructor(properties?: POGOProtos.Rpc.IFeatureSetDefaults);
            public defaults: POGOProtos.Rpc.FeatureSetDefaults.IFeatureSetEditionDefault[];
            public minimum_edition: POGOProtos.Rpc.Edition;
            public maximum_edition: POGOProtos.Rpc.Edition;
            public static encode(message: POGOProtos.Rpc.IFeatureSetDefaults, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeatureSetDefaults;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeatureSetDefaults;
            public static toObject(message: POGOProtos.Rpc.FeatureSetDefaults, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FeatureSetDefaults {

            interface IFeatureSetEditionDefault {
                edition?: (POGOProtos.Rpc.Edition|null);
                features?: (POGOProtos.Rpc.IFeatureSet|null);
            }

            class FeatureSetEditionDefault implements IFeatureSetEditionDefault {
                constructor(properties?: POGOProtos.Rpc.FeatureSetDefaults.IFeatureSetEditionDefault);
                public edition: POGOProtos.Rpc.Edition;
                public features?: (POGOProtos.Rpc.IFeatureSet|null);
                public static encode(message: POGOProtos.Rpc.FeatureSetDefaults.IFeatureSetEditionDefault, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeatureSetDefaults.FeatureSetEditionDefault;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeatureSetDefaults.FeatureSetEditionDefault;
                public static toObject(message: POGOProtos.Rpc.FeatureSetDefaults.FeatureSetEditionDefault, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IFeatureUnlockLevelSettings {
            lures_unlock_level?: (number|null);
            trading_unlock_level?: (number|null);
            rare_candy_conversion_unlock_level?: (number|null);
        }

        class FeatureUnlockLevelSettings implements IFeatureUnlockLevelSettings {
            constructor(properties?: POGOProtos.Rpc.IFeatureUnlockLevelSettings);
            public lures_unlock_level: number;
            public trading_unlock_level: number;
            public rare_candy_conversion_unlock_level: number;
            public static encode(message: POGOProtos.Rpc.IFeatureUnlockLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeatureUnlockLevelSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeatureUnlockLevelSettings;
            public static toObject(message: POGOProtos.Rpc.FeatureUnlockLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFeedPokemonTelemetry {
            status?: (number|null);
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            gym_id?: (string|null);
            team?: (POGOProtos.Rpc.Team|null);
            defender_count?: (number|null);
            motivation?: (number|null);
            cp_now?: (number|null);
        }

        class FeedPokemonTelemetry implements IFeedPokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IFeedPokemonTelemetry);
            public status: number;
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public gym_id: string;
            public team: POGOProtos.Rpc.Team;
            public defender_count: number;
            public motivation: number;
            public cp_now: number;
            public static encode(message: POGOProtos.Rpc.IFeedPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FeedPokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FeedPokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.FeedPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFestivalSettingsProto {
            festival_type?: (POGOProtos.Rpc.FestivalSettingsProto.FestivalType|null);
            key?: (string|null);
            vector?: (string|null);
        }

        class FestivalSettingsProto implements IFestivalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFestivalSettingsProto);
            public festival_type: POGOProtos.Rpc.FestivalSettingsProto.FestivalType;
            public key: string;
            public vector: string;
            public static encode(message: POGOProtos.Rpc.IFestivalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FestivalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FestivalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FestivalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FestivalSettingsProto {

            enum FestivalType {
                NONE = 0,
                HALLOWEEN = 1,
                HOLIDAY = 2,
                ROCKET = 3
            }
        }

        interface IFetchAllNewsOutProto {
            result?: (POGOProtos.Rpc.FetchAllNewsOutProto.Result|null);
            current_news?: (POGOProtos.Rpc.ICurrentNewsProto|null);
        }

        class FetchAllNewsOutProto implements IFetchAllNewsOutProto {
            constructor(properties?: POGOProtos.Rpc.IFetchAllNewsOutProto);
            public result: POGOProtos.Rpc.FetchAllNewsOutProto.Result;
            public current_news?: (POGOProtos.Rpc.ICurrentNewsProto|null);
            public static encode(message: POGOProtos.Rpc.IFetchAllNewsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FetchAllNewsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FetchAllNewsOutProto;
            public static toObject(message: POGOProtos.Rpc.FetchAllNewsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FetchAllNewsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_NEWS_FOUND = 2
            }
        }

        interface IFetchAllNewsProto {
        }

        class FetchAllNewsProto implements IFetchAllNewsProto {
            constructor(properties?: POGOProtos.Rpc.IFetchAllNewsProto);
            public static encode(message: POGOProtos.Rpc.IFetchAllNewsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FetchAllNewsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FetchAllNewsProto;
            public static toObject(message: POGOProtos.Rpc.FetchAllNewsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFetchNewsfeedRequest {
            page_token?: (string|null);
            player_id?: (string|null);
            number_of_posts?: (number|null);
            app_id?: (string|null);
            newsfeed_channel?: (POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel[]|null);
            language_version?: (string|null);
            country_code?: (string|null);
        }

        class FetchNewsfeedRequest implements IFetchNewsfeedRequest {
            constructor(properties?: POGOProtos.Rpc.IFetchNewsfeedRequest);
            public page_token: string;
            public player_id: string;
            public number_of_posts: number;
            public app_id: string;
            public newsfeed_channel: POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel[];
            public language_version: string;
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IFetchNewsfeedRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FetchNewsfeedRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FetchNewsfeedRequest;
            public static toObject(message: POGOProtos.Rpc.FetchNewsfeedRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFetchNewsfeedResponse {
            result?: (POGOProtos.Rpc.FetchNewsfeedResponse.Result|null);
            post_record?: (POGOProtos.Rpc.INewsfeedPostRecord[]|null);
            next_page_token?: (string|null);
        }

        class FetchNewsfeedResponse implements IFetchNewsfeedResponse {
            constructor(properties?: POGOProtos.Rpc.IFetchNewsfeedResponse);
            public result: POGOProtos.Rpc.FetchNewsfeedResponse.Result;
            public post_record: POGOProtos.Rpc.INewsfeedPostRecord[];
            public next_page_token: string;
            public static encode(message: POGOProtos.Rpc.IFetchNewsfeedResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FetchNewsfeedResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FetchNewsfeedResponse;
            public static toObject(message: POGOProtos.Rpc.FetchNewsfeedResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FetchNewsfeedResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                INTERNAL_ERROR = 2,
                CHANNEL_NOT_DEFINED = 3
            }
        }

        interface IField {
            kind?: (POGOProtos.Rpc.Field.Kind|null);
            cardinality?: (POGOProtos.Rpc.Field.Cardinality|null);
            number?: (number|null);
            name?: (string|null);
            type_url?: (string|null);
            oneof_index?: (number|null);
            packed?: (boolean|null);
            options?: (POGOProtos.Rpc.IOption[]|null);
            json_name?: (string|null);
            default_value?: (string|null);
        }

        class Field implements IField {
            constructor(properties?: POGOProtos.Rpc.IField);
            public kind: POGOProtos.Rpc.Field.Kind;
            public cardinality: POGOProtos.Rpc.Field.Cardinality;
            public number: number;
            public name: string;
            public type_url: string;
            public oneof_index: number;
            public packed: boolean;
            public options: POGOProtos.Rpc.IOption[];
            public json_name: string;
            public default_value: string;
            public static encode(message: POGOProtos.Rpc.IField, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Field;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Field;
            public static toObject(message: POGOProtos.Rpc.Field, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Field {

            enum Cardinality {
                unknown = 0,
                optional = 1,
                required = 2,
                repeated = 3
            }

            enum Kind {
                type_unknown = 0,
                type_double = 1,
                type_float = 2,
                type_int64 = 3,
                type_uint64 = 4,
                type_int32 = 5,
                type_fixed64 = 6,
                type_fixed32 = 7,
                type_bool = 8,
                type_string = 9,
                type_group = 10,
                type_message = 11,
                type_bytes = 12,
                type_uint32 = 13,
                type_enum = 14,
                type_sfixed32 = 15,
                type_sfixed64 = 16,
                type_sint32 = 17,
                type_sint64 = 18
            }
        }

        interface IFieldDescriptorProto {
            name?: (string|null);
            number?: (number|null);
            type_name?: (string|null);
            extendee?: (string|null);
            default_value?: (string|null);
            oneof_index?: (number|null);
            json_name?: (string|null);
            options?: (POGOProtos.Rpc.IFieldOptions|null);
        }

        class FieldDescriptorProto implements IFieldDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IFieldDescriptorProto);
            public name: string;
            public number: number;
            public type_name: string;
            public extendee: string;
            public default_value: string;
            public oneof_index: number;
            public json_name: string;
            public options?: (POGOProtos.Rpc.IFieldOptions|null);
            public static encode(message: POGOProtos.Rpc.IFieldDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FieldDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FieldDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.FieldDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FieldDescriptorProto {

            enum Label {
                LABEL_AUTO_INVALID = 0,
                optional = 1,
                required = 2,
                repeated = 3
            }

            enum Type {
                TYPE_AUTO_INVALID = 0,
                type_double = 1,
                type_float = 2,
                type_int64 = 3,
                type_uint64 = 4,
                type_int32 = 5,
                type_fixed64 = 6,
                type_fixed32 = 7,
                type_bool = 8,
                type_string = 9,
                type_group = 10,
                type_message = 11,
                type_bytes = 12,
                type_uint32 = 13,
                type_enum = 14,
                type_sfixed32 = 15,
                type_sfixed64 = 16,
                type_sint32 = 17,
                type_sint64 = 18
            }
        }

        interface IFieldEffectTelemetry {
            field_effect_source_id?: (POGOProtos.Rpc.FieldEffectTelemetry.FieldEffectSourceId|null);
        }

        class FieldEffectTelemetry implements IFieldEffectTelemetry {
            constructor(properties?: POGOProtos.Rpc.IFieldEffectTelemetry);
            public field_effect_source_id: POGOProtos.Rpc.FieldEffectTelemetry.FieldEffectSourceId;
            public static encode(message: POGOProtos.Rpc.IFieldEffectTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FieldEffectTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FieldEffectTelemetry;
            public static toObject(message: POGOProtos.Rpc.FieldEffectTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FieldEffectTelemetry {

            enum FieldEffectSourceId {
                UNDEFINED = 0,
                FROM_POKEMON_INFO_PANEL = 1,
                FROM_BUDDY_PAGE = 2,
                FROM_IAP_USAGE = 3
            }
        }

        interface IFieldMask {
            paths?: (string[]|null);
        }

        class FieldMask implements IFieldMask {
            constructor(properties?: POGOProtos.Rpc.IFieldMask);
            public paths: string[];
            public static encode(message: POGOProtos.Rpc.IFieldMask, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FieldMask;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FieldMask;
            public static toObject(message: POGOProtos.Rpc.FieldMask, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFieldOptions {
            packed?: (boolean|null);
            lazy?: (boolean|null);
            deprecated?: (boolean|null);
            weak?: (boolean|null);
        }

        class FieldOptions implements IFieldOptions {
            constructor(properties?: POGOProtos.Rpc.IFieldOptions);
            public packed: boolean;
            public lazy: boolean;
            public deprecated: boolean;
            public weak: boolean;
            public static encode(message: POGOProtos.Rpc.IFieldOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FieldOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FieldOptions;
            public static toObject(message: POGOProtos.Rpc.FieldOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FieldOptions {

            enum CType {
                string = 0,
                cord = 1,
                string_piece = 2
            }

            enum JSType {
                js_normal = 0,
                js_string = 1,
                js_number = 2
            }
        }

        interface IFileDescriptorProto {
            name?: (string|null);
            "package"?: (string|null);
            dependency?: (string[]|null);
            public_dependency?: (number[]|null);
            message_type?: (POGOProtos.Rpc.IDescriptorProto[]|null);
            enum_type?: (POGOProtos.Rpc.IEnumDescriptorProto[]|null);
            service?: (POGOProtos.Rpc.IServiceDescriptorProto[]|null);
            options?: (POGOProtos.Rpc.IFileOptions|null);
            source_code_info?: (POGOProtos.Rpc.ISourceCodeInfo|null);
            syntax?: (string|null);
        }

        class FileDescriptorProto implements IFileDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IFileDescriptorProto);
            public name: string;
            public package: string;
            public dependency: string[];
            public public_dependency: number[];
            public message_type: POGOProtos.Rpc.IDescriptorProto[];
            public enum_type: POGOProtos.Rpc.IEnumDescriptorProto[];
            public service: POGOProtos.Rpc.IServiceDescriptorProto[];
            public options?: (POGOProtos.Rpc.IFileOptions|null);
            public source_code_info?: (POGOProtos.Rpc.ISourceCodeInfo|null);
            public syntax: string;
            public static encode(message: POGOProtos.Rpc.IFileDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FileDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FileDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.FileDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFileDescriptorSet {
        }

        class FileDescriptorSet implements IFileDescriptorSet {
            constructor(properties?: POGOProtos.Rpc.IFileDescriptorSet);
            public static encode(message: POGOProtos.Rpc.IFileDescriptorSet, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FileDescriptorSet;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FileDescriptorSet;
            public static toObject(message: POGOProtos.Rpc.FileDescriptorSet, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFileOptions {
            java_package?: (string|null);
            java_outer_classname?: (string|null);
            java_multiple_files?: (boolean|null);
            java_generate_equals_and_hash?: (boolean|null);
            java_string_check_utf8?: (boolean|null);
            go_package?: (string|null);
            cc_generic_services?: (boolean|null);
            java_generic_services?: (boolean|null);
            py_generic_services?: (boolean|null);
            deprecated?: (boolean|null);
            cc_enable_arenas?: (boolean|null);
            objc_class_prefix?: (string|null);
            csharp_namespace?: (string|null);
        }

        class FileOptions implements IFileOptions {
            constructor(properties?: POGOProtos.Rpc.IFileOptions);
            public java_package: string;
            public java_outer_classname: string;
            public java_multiple_files: boolean;
            public java_generate_equals_and_hash: boolean;
            public java_string_check_utf8: boolean;
            public go_package: string;
            public cc_generic_services: boolean;
            public java_generic_services: boolean;
            public py_generic_services: boolean;
            public deprecated: boolean;
            public cc_enable_arenas: boolean;
            public objc_class_prefix: string;
            public csharp_namespace: string;
            public static encode(message: POGOProtos.Rpc.IFileOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FileOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FileOptions;
            public static toObject(message: POGOProtos.Rpc.FileOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FileOptions {

            enum OptimizeMode {
                OPTIMIZEMODE_AUTO_INVALID = 0,
                speed = 1,
                code_size = 2,
                lite_runtime = 3
            }
        }

        interface IFitnessMetricsProto {
            distance_walked_meters?: (number|null);
            step_count?: (number|null);
            calories_burned_kcals?: (number|null);
            exercise_duration_mi?: (number|Long|null);
            wheelchair_distance_meters?: (number|null);
            wheelchair_push_count?: (number|null);
        }

        class FitnessMetricsProto implements IFitnessMetricsProto {
            constructor(properties?: POGOProtos.Rpc.IFitnessMetricsProto);
            public distance_walked_meters: number;
            public step_count: number;
            public calories_burned_kcals: number;
            public exercise_duration_mi: (number|Long);
            public wheelchair_distance_meters: number;
            public wheelchair_push_count: number;
            public static encode(message: POGOProtos.Rpc.IFitnessMetricsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessMetricsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessMetricsProto;
            public static toObject(message: POGOProtos.Rpc.FitnessMetricsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFitnessMetricsReportHistory {
            weekly_history?: (POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory[]|null);
            daily_history?: (POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory[]|null);
            hourly_history?: (POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory[]|null);
        }

        class FitnessMetricsReportHistory implements IFitnessMetricsReportHistory {
            constructor(properties?: POGOProtos.Rpc.IFitnessMetricsReportHistory);
            public weekly_history: POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory[];
            public daily_history: POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory[];
            public hourly_history: POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory[];
            public static encode(message: POGOProtos.Rpc.IFitnessMetricsReportHistory, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessMetricsReportHistory;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessMetricsReportHistory;
            public static toObject(message: POGOProtos.Rpc.FitnessMetricsReportHistory, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FitnessMetricsReportHistory {

            interface IMetricsHistory {
                bucket?: (number|Long|null);
                metrics?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            }

            class MetricsHistory implements IMetricsHistory {
                constructor(properties?: POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory);
                public bucket: (number|Long);
                public metrics?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
                public static encode(message: POGOProtos.Rpc.FitnessMetricsReportHistory.IMetricsHistory, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessMetricsReportHistory.MetricsHistory;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessMetricsReportHistory.MetricsHistory;
                public static toObject(message: POGOProtos.Rpc.FitnessMetricsReportHistory.MetricsHistory, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IFitnessRecordProto {
            hourly_reports?: ({ [k: string]: POGOProtos.Rpc.IFitnessMetricsProto }|null);
            raw_samples?: (POGOProtos.Rpc.IFitnessSample[]|null);
            last_aggregation_timestamp_ms?: (number|Long|null);
            fitness_stats?: (POGOProtos.Rpc.IFitnessStatsProto|null);
            report_history?: (POGOProtos.Rpc.IFitnessMetricsReportHistory|null);
        }

        class FitnessRecordProto implements IFitnessRecordProto {
            constructor(properties?: POGOProtos.Rpc.IFitnessRecordProto);
            public hourly_reports: { [k: string]: POGOProtos.Rpc.IFitnessMetricsProto };
            public raw_samples: POGOProtos.Rpc.IFitnessSample[];
            public last_aggregation_timestamp_ms: (number|Long);
            public fitness_stats?: (POGOProtos.Rpc.IFitnessStatsProto|null);
            public report_history?: (POGOProtos.Rpc.IFitnessMetricsReportHistory|null);
            public static encode(message: POGOProtos.Rpc.IFitnessRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessRecordProto;
            public static toObject(message: POGOProtos.Rpc.FitnessRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFitnessReportProto {
            day_offset_from_now?: (number|null);
            week_offset_from_now?: (number|null);
            hour_offset_from_now?: (number|null);
            metrics?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            game_data?: (Uint8Array|null);
        }

        class FitnessReportProto implements IFitnessReportProto {
            constructor(properties?: POGOProtos.Rpc.IFitnessReportProto);
            public day_offset_from_now?: (number|null);
            public week_offset_from_now?: (number|null);
            public hour_offset_from_now?: (number|null);
            public metrics?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            public game_data: Uint8Array;
            public Window?: ("day_offset_from_now"|"week_offset_from_now"|"hour_offset_from_now");
            public static encode(message: POGOProtos.Rpc.IFitnessReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessReportProto;
            public static toObject(message: POGOProtos.Rpc.FitnessReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFitnessRewardsLogEntry {
            result?: (POGOProtos.Rpc.FitnessRewardsLogEntry.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            distance_walked_km?: (number|null);
        }

        class FitnessRewardsLogEntry implements IFitnessRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IFitnessRewardsLogEntry);
            public result: POGOProtos.Rpc.FitnessRewardsLogEntry.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public distance_walked_km: number;
            public static encode(message: POGOProtos.Rpc.IFitnessRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.FitnessRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FitnessRewardsLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IFitnessSample {
            sample_type?: (POGOProtos.Rpc.FitnessSample.FitnessSampleType|null);
            sample_start_timestamp_ms?: (number|Long|null);
            sample_end_timestamp_ms?: (number|Long|null);
            value?: (number|null);
            source_type?: (POGOProtos.Rpc.FitnessSample.FitnessSourceType|null);
            metadata?: (POGOProtos.Rpc.IFitnessSampleMetadata|null);
        }

        class FitnessSample implements IFitnessSample {
            constructor(properties?: POGOProtos.Rpc.IFitnessSample);
            public sample_type: POGOProtos.Rpc.FitnessSample.FitnessSampleType;
            public sample_start_timestamp_ms: (number|Long);
            public sample_end_timestamp_ms: (number|Long);
            public value: number;
            public source_type: POGOProtos.Rpc.FitnessSample.FitnessSourceType;
            public metadata?: (POGOProtos.Rpc.IFitnessSampleMetadata|null);
            public static encode(message: POGOProtos.Rpc.IFitnessSample, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessSample;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessSample;
            public static toObject(message: POGOProtos.Rpc.FitnessSample, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FitnessSample {

            enum FitnessSampleType {
                SAMPLE_UNSET = 0,
                STEPS = 1,
                WALKING_DISTANCE_METERS = 2,
                WHEELCHAIR_DISTANCE_METERS = 3,
                CALORIES_KCALS = 4,
                WHEELCHAIR_PUSH_COUNT = 5,
                EXERCISE_TIME_MI = 6
            }

            enum FitnessSourceType {
                SOURCE_UNSET = 0,
                HEALTHKIT = 1,
                GOOGLE_FIT = 2,
                APPLE_WATCH = 3,
                GPS = 4,
                ANDROID_SENSOR_HUB = 5
            }
        }

        interface IFitnessSampleMetadata {
            original_data_source?: (POGOProtos.Rpc.IAndroidDataSource|null);
            data_source?: (POGOProtos.Rpc.IAndroidDataSource|null);
            source_revision?: (POGOProtos.Rpc.IIosSourceRevision|null);
            device?: (POGOProtos.Rpc.IIosDevice|null);
            user_entered?: (boolean|null);
        }

        class FitnessSampleMetadata implements IFitnessSampleMetadata {
            constructor(properties?: POGOProtos.Rpc.IFitnessSampleMetadata);
            public original_data_source?: (POGOProtos.Rpc.IAndroidDataSource|null);
            public data_source?: (POGOProtos.Rpc.IAndroidDataSource|null);
            public source_revision?: (POGOProtos.Rpc.IIosSourceRevision|null);
            public device?: (POGOProtos.Rpc.IIosDevice|null);
            public user_entered: boolean;
            public static encode(message: POGOProtos.Rpc.IFitnessSampleMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessSampleMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessSampleMetadata;
            public static toObject(message: POGOProtos.Rpc.FitnessSampleMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFitnessStatsProto {
            last_accumulated_timestamp_ms?: (number|Long|null);
            accumulated?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            pending?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            player_initial_walk_km?: (number|null);
            player_total_walk_km?: (number|null);
            player_total_steps?: (number|Long|null);
        }

        class FitnessStatsProto implements IFitnessStatsProto {
            constructor(properties?: POGOProtos.Rpc.IFitnessStatsProto);
            public last_accumulated_timestamp_ms: (number|Long);
            public accumulated?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            public pending?: (POGOProtos.Rpc.IFitnessMetricsProto|null);
            public player_initial_walk_km: number;
            public player_total_walk_km: number;
            public player_total_steps: (number|Long);
            public static encode(message: POGOProtos.Rpc.IFitnessStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessStatsProto;
            public static toObject(message: POGOProtos.Rpc.FitnessStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFitnessUpdateOutProto {
            status?: (POGOProtos.Rpc.FitnessUpdateOutProto.Status|null);
        }

        class FitnessUpdateOutProto implements IFitnessUpdateOutProto {
            constructor(properties?: POGOProtos.Rpc.IFitnessUpdateOutProto);
            public status: POGOProtos.Rpc.FitnessUpdateOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IFitnessUpdateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessUpdateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessUpdateOutProto;
            public static toObject(message: POGOProtos.Rpc.FitnessUpdateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FitnessUpdateOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IFitnessUpdateProto {
            fitness_samples?: (POGOProtos.Rpc.IFitnessSample[]|null);
        }

        class FitnessUpdateProto implements IFitnessUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IFitnessUpdateProto);
            public fitness_samples: POGOProtos.Rpc.IFitnessSample[];
            public static encode(message: POGOProtos.Rpc.IFitnessUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FitnessUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FitnessUpdateProto;
            public static toObject(message: POGOProtos.Rpc.FitnessUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFloatValue {
            value?: (number|null);
        }

        class FloatValue implements IFloatValue {
            constructor(properties?: POGOProtos.Rpc.IFloatValue);
            public value: number;
            public static encode(message: POGOProtos.Rpc.IFloatValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FloatValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FloatValue;
            public static toObject(message: POGOProtos.Rpc.FloatValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFollowerDataProto {
            pokemon_followers?: (POGOProtos.Rpc.IFollowerPokemonProto[]|null);
        }

        class FollowerDataProto implements IFollowerDataProto {
            constructor(properties?: POGOProtos.Rpc.IFollowerDataProto);
            public pokemon_followers: POGOProtos.Rpc.IFollowerPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IFollowerDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FollowerDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FollowerDataProto;
            public static toObject(message: POGOProtos.Rpc.FollowerDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFollowerPokemonProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            address?: (string|null);
            display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            end_ms?: (number|Long|null);
            id?: (POGOProtos.Rpc.FollowerPokemonProto.FollowerId|null);
        }

        class FollowerPokemonProto implements IFollowerPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IFollowerPokemonProto);
            public pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            public address?: (string|null);
            public display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public end_ms: (number|Long);
            public id: POGOProtos.Rpc.FollowerPokemonProto.FollowerId;
            public PokemonData?: ("pokemon_id"|"address");
            public static encode(message: POGOProtos.Rpc.IFollowerPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FollowerPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FollowerPokemonProto;
            public static toObject(message: POGOProtos.Rpc.FollowerPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FollowerPokemonProto {

            enum FollowerId {
                UNSET = 0,
                ID_1 = 1
            }
        }

        interface IFollowerPokemonTappedTelemetry {
            follower_holo_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            follower_address?: (string|null);
            follower_id?: (POGOProtos.Rpc.FollowerPokemonProto.FollowerId|null);
        }

        class FollowerPokemonTappedTelemetry implements IFollowerPokemonTappedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IFollowerPokemonTappedTelemetry);
            public follower_holo_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            public follower_address?: (string|null);
            public follower_id: POGOProtos.Rpc.FollowerPokemonProto.FollowerId;
            public PokemonData?: ("follower_holo_pokemon_id"|"follower_address");
            public static encode(message: POGOProtos.Rpc.IFollowerPokemonTappedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FollowerPokemonTappedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FollowerPokemonTappedTelemetry;
            public static toObject(message: POGOProtos.Rpc.FollowerPokemonTappedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFoodAttributesProto {
            item_effect?: (POGOProtos.Rpc.HoloItemEffect[]|null);
            item_effect_percent?: (number[]|null);
            growth_percent?: (number|null);
            berry_multiplier?: (number|null);
            remote_berry_multiplier?: (number|null);
            num_buddy_affection_points?: (number|null);
            map_duration_ms?: (number|Long|null);
            active_duration_ms?: (number|Long|null);
            num_buddy_hunger_points?: (number|null);
        }

        class FoodAttributesProto implements IFoodAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IFoodAttributesProto);
            public item_effect: POGOProtos.Rpc.HoloItemEffect[];
            public item_effect_percent: number[];
            public growth_percent: number;
            public berry_multiplier: number;
            public remote_berry_multiplier: number;
            public num_buddy_affection_points: number;
            public map_duration_ms: (number|Long);
            public active_duration_ms: (number|Long);
            public num_buddy_hunger_points: number;
            public static encode(message: POGOProtos.Rpc.IFoodAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FoodAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FoodAttributesProto;
            public static toObject(message: POGOProtos.Rpc.FoodAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFoodValue {
            motivation_increase?: (number|null);
            cp_increase?: (number|null);
            food_item?: (POGOProtos.Rpc.Item|null);
        }

        class FoodValue implements IFoodValue {
            constructor(properties?: POGOProtos.Rpc.IFoodValue);
            public motivation_increase: number;
            public cp_increase: number;
            public food_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IFoodValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FoodValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FoodValue;
            public static toObject(message: POGOProtos.Rpc.FoodValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeBonusAttributesProto {
            target_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            bread_mode?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
            clear_bread_mode?: (boolean|null);
            max_moves?: (POGOProtos.Rpc.IBreadMoveSlotProto[]|null);
        }

        class FormChangeBonusAttributesProto implements IFormChangeBonusAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeBonusAttributesProto);
            public target_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public bread_mode: POGOProtos.Rpc.BreadModeEnum.Modifier;
            public clear_bread_mode: boolean;
            public max_moves: POGOProtos.Rpc.IBreadMoveSlotProto[];
            public static encode(message: POGOProtos.Rpc.IFormChangeBonusAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeBonusAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeBonusAttributesProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeBonusAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeBreadMoveRequirementProto {
            move_types?: (POGOProtos.Rpc.BreadMoveSlotProto.BreadMoveType[]|null);
            move_level?: (POGOProtos.Rpc.BreadMoveLevels|null);
        }

        class FormChangeBreadMoveRequirementProto implements IFormChangeBreadMoveRequirementProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeBreadMoveRequirementProto);
            public move_types: POGOProtos.Rpc.BreadMoveSlotProto.BreadMoveType[];
            public move_level: POGOProtos.Rpc.BreadMoveLevels;
            public static encode(message: POGOProtos.Rpc.IFormChangeBreadMoveRequirementProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeBreadMoveRequirementProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeBreadMoveRequirementProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeBreadMoveRequirementProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeLocationCardSettingsProto {
            base_pokemon_location_card?: (POGOProtos.Rpc.LocationCard|null);
            component_pokemon_location_card?: (POGOProtos.Rpc.LocationCard|null);
            fusion_pokemon_location_card?: (POGOProtos.Rpc.LocationCard|null);
        }

        class FormChangeLocationCardSettingsProto implements IFormChangeLocationCardSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeLocationCardSettingsProto);
            public base_pokemon_location_card: POGOProtos.Rpc.LocationCard;
            public component_pokemon_location_card: POGOProtos.Rpc.LocationCard;
            public fusion_pokemon_location_card: POGOProtos.Rpc.LocationCard;
            public static encode(message: POGOProtos.Rpc.IFormChangeLocationCardSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeLocationCardSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeLocationCardSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeLocationCardSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeMoveReassignmentProto {
            quick_moves?: (POGOProtos.Rpc.IMoveReassignmentProto[]|null);
            cinematic_moves?: (POGOProtos.Rpc.IMoveReassignmentProto[]|null);
        }

        class FormChangeMoveReassignmentProto implements IFormChangeMoveReassignmentProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeMoveReassignmentProto);
            public quick_moves: POGOProtos.Rpc.IMoveReassignmentProto[];
            public cinematic_moves: POGOProtos.Rpc.IMoveReassignmentProto[];
            public static encode(message: POGOProtos.Rpc.IFormChangeMoveReassignmentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeMoveReassignmentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeMoveReassignmentProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeMoveReassignmentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeMoveRequirementProto {
            required_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
        }

        class FormChangeMoveRequirementProto implements IFormChangeMoveRequirementProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeMoveRequirementProto);
            public required_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public static encode(message: POGOProtos.Rpc.IFormChangeMoveRequirementProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeMoveRequirementProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeMoveRequirementProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeMoveRequirementProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeProto {
            available_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            candy_cost?: (number|null);
            stardust_cost?: (number|null);
            item_cost?: (POGOProtos.Rpc.Item|null);
            quest_requirement?: (POGOProtos.Rpc.IEvolutionQuestInfoProto[]|null);
            item_cost_count?: (number|null);
            component_pokemon_settings?: (POGOProtos.Rpc.IComponentPokemonSettingsProto|null);
            move_reassignment?: (POGOProtos.Rpc.IFormChangeMoveReassignmentProto|null);
            required_quick_moves?: (POGOProtos.Rpc.IFormChangeMoveRequirementProto[]|null);
            required_cinematic_moves?: (POGOProtos.Rpc.IFormChangeMoveRequirementProto[]|null);
            required_bread_moves?: (POGOProtos.Rpc.IFormChangeBreadMoveRequirementProto[]|null);
            priority?: (number|null);
            form_change_bonus_attributes?: (POGOProtos.Rpc.IFormChangeBonusAttributesProto[]|null);
        }

        class FormChangeProto implements IFormChangeProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeProto);
            public available_form: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public candy_cost: number;
            public stardust_cost: number;
            public item_cost: POGOProtos.Rpc.Item;
            public quest_requirement: POGOProtos.Rpc.IEvolutionQuestInfoProto[];
            public item_cost_count: number;
            public component_pokemon_settings?: (POGOProtos.Rpc.IComponentPokemonSettingsProto|null);
            public move_reassignment?: (POGOProtos.Rpc.IFormChangeMoveReassignmentProto|null);
            public required_quick_moves: POGOProtos.Rpc.IFormChangeMoveRequirementProto[];
            public required_cinematic_moves: POGOProtos.Rpc.IFormChangeMoveRequirementProto[];
            public required_bread_moves: POGOProtos.Rpc.IFormChangeBreadMoveRequirementProto[];
            public priority: number;
            public form_change_bonus_attributes: POGOProtos.Rpc.IFormChangeBonusAttributesProto[];
            public static encode(message: POGOProtos.Rpc.IFormChangeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormChangeSettingsProto {
            enabled?: (boolean|null);
        }

        class FormChangeSettingsProto implements IFormChangeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFormChangeSettingsProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IFormChangeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormChangeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormChangeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FormChangeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormPokedexSizeProto {
            is_alias?: (boolean|null);
            alias_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class FormPokedexSizeProto implements IFormPokedexSizeProto {
            constructor(properties?: POGOProtos.Rpc.IFormPokedexSizeProto);
            public is_alias: boolean;
            public alias_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IFormPokedexSizeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormPokedexSizeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormPokedexSizeProto;
            public static toObject(message: POGOProtos.Rpc.FormPokedexSizeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormProto {
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            asset_bundle_value?: (number|null);
            asset_bundle_suffix?: (string|null);
            is_costume?: (boolean|null);
            size_data?: (POGOProtos.Rpc.IFormPokedexSizeProto|null);
            sillouette_obfuscation_group?: (POGOProtos.Rpc.ISillouetteObfuscationGroup|null);
        }

        class FormProto implements IFormProto {
            constructor(properties?: POGOProtos.Rpc.IFormProto);
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public asset_bundle_value: number;
            public asset_bundle_suffix: string;
            public is_costume: boolean;
            public size_data?: (POGOProtos.Rpc.IFormPokedexSizeProto|null);
            public sillouette_obfuscation_group?: (POGOProtos.Rpc.ISillouetteObfuscationGroup|null);
            public static encode(message: POGOProtos.Rpc.IFormProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormProto;
            public static toObject(message: POGOProtos.Rpc.FormProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormRenderModifier {
            type?: (POGOProtos.Rpc.FormRenderModifier.RenderModifierType[]|null);
            effect_target?: (POGOProtos.Rpc.FormRenderModifier.EffectTarget|null);
            pokemon_id?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment|null);
            transition_vfx_key?: (POGOProtos.Rpc.FormRenderModifier.TransitionVfxKey|null);
            event_trigger_time?: (number|Long|null);
        }

        class FormRenderModifier implements IFormRenderModifier {
            constructor(properties?: POGOProtos.Rpc.IFormRenderModifier);
            public type: POGOProtos.Rpc.FormRenderModifier.RenderModifierType[];
            public effect_target: POGOProtos.Rpc.FormRenderModifier.EffectTarget;
            public pokemon_id: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment;
            public transition_vfx_key: POGOProtos.Rpc.FormRenderModifier.TransitionVfxKey;
            public event_trigger_time: (number|Long);
            public static encode(message: POGOProtos.Rpc.IFormRenderModifier, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormRenderModifier;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormRenderModifier;
            public static toObject(message: POGOProtos.Rpc.FormRenderModifier, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FormRenderModifier {

            enum EffectTarget {
                UNSET_TARGET = 0,
                DEFENDER = 1,
                ATTACKER = 2,
                ALL_PLAYERS = 3
            }

            enum RenderModifierType {
                UNSET = 0,
                SUPPRESS_SELF = 1,
                SUPPRESS_OPPONENT = 2,
                DISPLAY_CHANGE = 3
            }

            enum TransitionVfxKey {
                DEFAULT_TRANSITION = 0,
                SHADOW_ENRAGE = 1,
                SHADOW_SUPPRESS = 2
            }
        }

        interface IFormSettingsProto {
            pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            forms?: (POGOProtos.Rpc.IFormProto[]|null);
        }

        class FormSettingsProto implements IFormSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFormSettingsProto);
            public pokemon: POGOProtos.Rpc.HoloPokemonId;
            public forms: POGOProtos.Rpc.IFormProto[];
            public static encode(message: POGOProtos.Rpc.IFormSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FormSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFormsRefactorSettingsProto {
            enable_shadow_v2_gmts?: (boolean|null);
            read_from_new_pokedex_entry_fields?: (boolean|null);
            validate_no_shadows_in_quest_or_invasion_gmts?: (boolean|null);
            validate_no_shadow_or_purified_in_gmts?: (boolean|null);
        }

        class FormsRefactorSettingsProto implements IFormsRefactorSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFormsRefactorSettingsProto);
            public enable_shadow_v2_gmts: boolean;
            public read_from_new_pokedex_entry_fields: boolean;
            public validate_no_shadows_in_quest_or_invasion_gmts: boolean;
            public validate_no_shadow_or_purified_in_gmts: boolean;
            public static encode(message: POGOProtos.Rpc.IFormsRefactorSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FormsRefactorSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FormsRefactorSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FormsRefactorSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortDeployOutProto {
            result?: (POGOProtos.Rpc.FortDeployOutProto.Result|null);
            fort_details_out_proto?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
            egg_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            gym_state_proto?: (POGOProtos.Rpc.IGymStateProto|null);
        }

        class FortDeployOutProto implements IFortDeployOutProto {
            constructor(properties?: POGOProtos.Rpc.IFortDeployOutProto);
            public result: POGOProtos.Rpc.FortDeployOutProto.Result;
            public fort_details_out_proto?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
            public egg_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public gym_state_proto?: (POGOProtos.Rpc.IGymStateProto|null);
            public static encode(message: POGOProtos.Rpc.IFortDeployOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortDeployOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortDeployOutProto;
            public static toObject(message: POGOProtos.Rpc.FortDeployOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortDeployOutProto {

            enum Result {
                NO_RESULT_SET = 0,
                SUCCESS = 1,
                ERROR_ALREADY_HAS_POKEMON_ON_FORT = 2,
                ERROR_OPPOSING_TEAM_OWNS_FORT = 3,
                ERROR_FORT_IS_FULL = 4,
                ERROR_NOT_IN_RANGE = 5,
                ERROR_PLAYER_HAS_NO_TEAM = 6,
                ERROR_POKEMON_NOT_FULL_HP = 7,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 8,
                ERROR_POKEMON_IS_BUDDY = 9,
                ERROR_FORT_DEPLOY_LOCKOUT = 10,
                ERROR_PLAYER_HAS_NO_NICKNAME = 11,
                ERROR_POI_INACCESSIBLE = 12,
                ERROR_LEGENDARY_POKEMON = 13,
                ERROR_INVALID_POKEMON = 14
            }
        }

        interface IFortDeployProto {
            fort_id?: (string|null);
            pokemon_id?: (number|Long|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class FortDeployProto implements IFortDeployProto {
            constructor(properties?: POGOProtos.Rpc.IFortDeployProto);
            public fort_id: string;
            public pokemon_id: (number|Long);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IFortDeployProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortDeployProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortDeployProto;
            public static toObject(message: POGOProtos.Rpc.FortDeployProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortDetailsOutProto {
            id?: (string|null);
            team?: (POGOProtos.Rpc.Team|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto[]|null);
            name?: (string|null);
            image_url?: (string[]|null);
            fp?: (number|null);
            stamina?: (number|null);
            max_stamina?: (number|null);
            fort_type?: (POGOProtos.Rpc.FortType|null);
            latitude?: (number|null);
            longitude?: (number|null);
            description?: (string|null);
            modifier?: (POGOProtos.Rpc.IClientFortModifierProto[]|null);
            close_soon?: (boolean|null);
            checkin_image_url?: (string|null);
            event_info?: (POGOProtos.Rpc.IEventInfoProto|null);
            promo_description?: (string[]|null);
            call_to_action_link?: (string|null);
            sponsored_details?: (POGOProtos.Rpc.ISponsoredDetailsProto|null);
            geostore_tombstone_message_key?: (string|null);
            geostore_suspension_message_key?: (string|null);
            poi_images_count?: (number|null);
            power_up_progress_points?: (number|null);
            power_up_level_expiration_ms?: (number|Long|null);
            next_fort_close_ms?: (number|Long|null);
            is_vps_eligible?: (boolean|null);
            vps_enabled_status?: (POGOProtos.Rpc.VpsEnabledStatus|null);
        }

        class FortDetailsOutProto implements IFortDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IFortDetailsOutProto);
            public id: string;
            public team: POGOProtos.Rpc.Team;
            public pokemon: POGOProtos.Rpc.IPokemonProto[];
            public name: string;
            public image_url: string[];
            public fp: number;
            public stamina: number;
            public max_stamina: number;
            public fort_type: POGOProtos.Rpc.FortType;
            public latitude: number;
            public longitude: number;
            public description: string;
            public modifier: POGOProtos.Rpc.IClientFortModifierProto[];
            public close_soon: boolean;
            public checkin_image_url: string;
            public event_info?: (POGOProtos.Rpc.IEventInfoProto|null);
            public promo_description: string[];
            public call_to_action_link: string;
            public sponsored_details?: (POGOProtos.Rpc.ISponsoredDetailsProto|null);
            public geostore_tombstone_message_key: string;
            public geostore_suspension_message_key: string;
            public poi_images_count: number;
            public power_up_progress_points: number;
            public power_up_level_expiration_ms: (number|Long);
            public next_fort_close_ms: (number|Long);
            public is_vps_eligible: boolean;
            public vps_enabled_status: POGOProtos.Rpc.VpsEnabledStatus;
            public static encode(message: POGOProtos.Rpc.IFortDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.FortDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortDetailsProto {
            id?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class FortDetailsProto implements IFortDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IFortDetailsProto);
            public id: string;
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IFortDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortDetailsProto;
            public static toObject(message: POGOProtos.Rpc.FortDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortModifierAttributesProto {
            modifier_lifetime_seconds?: (number|null);
            troy_disk_num_pokemon_spawned?: (number|null);
        }

        class FortModifierAttributesProto implements IFortModifierAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IFortModifierAttributesProto);
            public modifier_lifetime_seconds: number;
            public troy_disk_num_pokemon_spawned: number;
            public static encode(message: POGOProtos.Rpc.IFortModifierAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortModifierAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortModifierAttributesProto;
            public static toObject(message: POGOProtos.Rpc.FortModifierAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortPokemonProto {
            pokemon_proto?: (POGOProtos.Rpc.IMapPokemonProto|null);
            spawn_type?: (POGOProtos.Rpc.FortPokemonProto.SpawnType|null);
        }

        class FortPokemonProto implements IFortPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IFortPokemonProto);
            public pokemon_proto?: (POGOProtos.Rpc.IMapPokemonProto|null);
            public spawn_type: POGOProtos.Rpc.FortPokemonProto.SpawnType;
            public static encode(message: POGOProtos.Rpc.IFortPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortPokemonProto;
            public static toObject(message: POGOProtos.Rpc.FortPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortPokemonProto {

            enum SpawnType {
                LURE = 0,
                POWER_UP = 1
            }
        }

        interface IFortPowerUpActivitySettings {
            activity?: (POGOProtos.Rpc.FortPowerUpActivitySettings.FortPowerUpActivity|null);
            num_points_per_activity?: (number|null);
            max_daily_limit_per_player?: (number|null);
        }

        class FortPowerUpActivitySettings implements IFortPowerUpActivitySettings {
            constructor(properties?: POGOProtos.Rpc.IFortPowerUpActivitySettings);
            public activity: POGOProtos.Rpc.FortPowerUpActivitySettings.FortPowerUpActivity;
            public num_points_per_activity: number;
            public max_daily_limit_per_player: number;
            public static encode(message: POGOProtos.Rpc.IFortPowerUpActivitySettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortPowerUpActivitySettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortPowerUpActivitySettings;
            public static toObject(message: POGOProtos.Rpc.FortPowerUpActivitySettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortPowerUpActivitySettings {

            enum FortPowerUpActivity {
                UNSET = 0,
                FORT_POWER_UP_ACTIVITY_AR_SCAN = 1
            }
        }

        interface IFortPowerUpLevelSettings {
            level?: (POGOProtos.Rpc.FortPowerUpLevel|null);
            min_power_up_points_required?: (number|null);
            powerup_level_rewards?: (POGOProtos.Rpc.FortPowerUpLevelReward[]|null);
            additional_level_powerup_duration_ms?: (number|null);
        }

        class FortPowerUpLevelSettings implements IFortPowerUpLevelSettings {
            constructor(properties?: POGOProtos.Rpc.IFortPowerUpLevelSettings);
            public level: POGOProtos.Rpc.FortPowerUpLevel;
            public min_power_up_points_required: number;
            public powerup_level_rewards: POGOProtos.Rpc.FortPowerUpLevelReward[];
            public additional_level_powerup_duration_ms: number;
            public static encode(message: POGOProtos.Rpc.IFortPowerUpLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortPowerUpLevelSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortPowerUpLevelSettings;
            public static toObject(message: POGOProtos.Rpc.FortPowerUpLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortPowerUpSpawnSettings {
            fort_power_up_pokemon_spawn_count?: (number|null);
        }

        class FortPowerUpSpawnSettings implements IFortPowerUpSpawnSettings {
            constructor(properties?: POGOProtos.Rpc.IFortPowerUpSpawnSettings);
            public fort_power_up_pokemon_spawn_count: number;
            public static encode(message: POGOProtos.Rpc.IFortPowerUpSpawnSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortPowerUpSpawnSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortPowerUpSpawnSettings;
            public static toObject(message: POGOProtos.Rpc.FortPowerUpSpawnSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortRecallOutProto {
            result?: (POGOProtos.Rpc.FortRecallOutProto.Result|null);
            fort_details_out_proto?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
        }

        class FortRecallOutProto implements IFortRecallOutProto {
            constructor(properties?: POGOProtos.Rpc.IFortRecallOutProto);
            public result: POGOProtos.Rpc.FortRecallOutProto.Result;
            public fort_details_out_proto?: (POGOProtos.Rpc.IFortDetailsOutProto|null);
            public static encode(message: POGOProtos.Rpc.IFortRecallOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortRecallOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortRecallOutProto;
            public static toObject(message: POGOProtos.Rpc.FortRecallOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortRecallOutProto {

            enum Result {
                NO_RESULT_SET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_POKEMON_NOT_ON_FORT = 3,
                ERROR_NO_PLAYER = 4
            }
        }

        interface IFortRecallProto {
            fort_id?: (string|null);
            pokemon_id?: (number|Long|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class FortRecallProto implements IFortRecallProto {
            constructor(properties?: POGOProtos.Rpc.IFortRecallProto);
            public fort_id: string;
            public pokemon_id: (number|Long);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IFortRecallProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortRecallProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortRecallProto;
            public static toObject(message: POGOProtos.Rpc.FortRecallProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortRenderingType {
            rendering_type?: (POGOProtos.Rpc.FortRenderingType.RenderingType|null);
        }

        class FortRenderingType implements IFortRenderingType {
            constructor(properties?: POGOProtos.Rpc.IFortRenderingType);
            public rendering_type: POGOProtos.Rpc.FortRenderingType.RenderingType;
            public static encode(message: POGOProtos.Rpc.IFortRenderingType, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortRenderingType;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortRenderingType;
            public static toObject(message: POGOProtos.Rpc.FortRenderingType, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortRenderingType {

            enum RenderingType {
                DEFAULT = 0,
                INTERNAL_TEST = 1
            }
        }

        interface IFortSearchLogEntry {
            result?: (POGOProtos.Rpc.FortSearchLogEntry.Result|null);
            fort_id?: (string|null);
            items?: (POGOProtos.Rpc.IItemProto[]|null);
            eggs?: (number|null);
            pokemon_eggs?: (POGOProtos.Rpc.IPokemonProto[]|null);
            fort_type?: (POGOProtos.Rpc.FortType|null);
            awarded_items?: (POGOProtos.Rpc.IItemProto[]|null);
            bonus_items?: (POGOProtos.Rpc.IItemProto[]|null);
            team_bonus_items?: (POGOProtos.Rpc.IItemProto[]|null);
            gift_boxes?: (POGOProtos.Rpc.IGiftBoxProto[]|null);
            stickers?: (POGOProtos.Rpc.ILootItemProto[]|null);
            powered_up_stop_bonus_items?: (POGOProtos.Rpc.IItemProto[]|null);
            mega_resource?: (POGOProtos.Rpc.ILootItemProto[]|null);
        }

        class FortSearchLogEntry implements IFortSearchLogEntry {
            constructor(properties?: POGOProtos.Rpc.IFortSearchLogEntry);
            public result: POGOProtos.Rpc.FortSearchLogEntry.Result;
            public fort_id: string;
            public items: POGOProtos.Rpc.IItemProto[];
            public eggs: number;
            public pokemon_eggs: POGOProtos.Rpc.IPokemonProto[];
            public fort_type: POGOProtos.Rpc.FortType;
            public awarded_items: POGOProtos.Rpc.IItemProto[];
            public bonus_items: POGOProtos.Rpc.IItemProto[];
            public team_bonus_items: POGOProtos.Rpc.IItemProto[];
            public gift_boxes: POGOProtos.Rpc.IGiftBoxProto[];
            public stickers: POGOProtos.Rpc.ILootItemProto[];
            public powered_up_stop_bonus_items: POGOProtos.Rpc.IItemProto[];
            public mega_resource: POGOProtos.Rpc.ILootItemProto[];
            public static encode(message: POGOProtos.Rpc.IFortSearchLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortSearchLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortSearchLogEntry;
            public static toObject(message: POGOProtos.Rpc.FortSearchLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortSearchLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IFortSearchOutProto {
            result?: (POGOProtos.Rpc.FortSearchOutProto.Result|null);
            items?: (POGOProtos.Rpc.IAwardItemProto[]|null);
            gems_awarded?: (number|null);
            egg_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            xp_awarded?: (number|null);
            cooldown_complete?: (number|Long|null);
            chain_hack_sequence_number?: (number|null);
            awarded_gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            loot?: (POGOProtos.Rpc.ILootProto|null);
            bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            raid_tickets?: (number|null);
            team_bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            fort_id?: (string|null);
            challenge_quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            gift_box?: (POGOProtos.Rpc.IGiftBoxProto|null);
            sponsored_gift?: (POGOProtos.Rpc.IAdDetails|null);
            power_up_stop_bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            ad?: (POGOProtos.Rpc.IAdProto|null);
        }

        class FortSearchOutProto implements IFortSearchOutProto {
            constructor(properties?: POGOProtos.Rpc.IFortSearchOutProto);
            public result: POGOProtos.Rpc.FortSearchOutProto.Result;
            public items: POGOProtos.Rpc.IAwardItemProto[];
            public gems_awarded: number;
            public egg_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public xp_awarded: number;
            public cooldown_complete: (number|Long);
            public chain_hack_sequence_number: number;
            public awarded_gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            public loot?: (POGOProtos.Rpc.ILootProto|null);
            public bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            public raid_tickets: number;
            public team_bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            public fort_id: string;
            public challenge_quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            public gift_box?: (POGOProtos.Rpc.IGiftBoxProto|null);
            public sponsored_gift?: (POGOProtos.Rpc.IAdDetails|null);
            public power_up_stop_bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            public ad?: (POGOProtos.Rpc.IAdProto|null);
            public static encode(message: POGOProtos.Rpc.IFortSearchOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortSearchOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortSearchOutProto;
            public static toObject(message: POGOProtos.Rpc.FortSearchOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortSearchOutProto {

            enum Result {
                NO_RESULT_SET = 0,
                SUCCESS = 1,
                OUT_OF_RANGE = 2,
                IN_COOLDOWN_PERIOD = 3,
                INVENTORY_FULL = 4,
                EXCEEDED_DAILY_LIMIT = 5,
                POI_INACCESSIBLE = 6
            }
        }

        interface IFortSearchProto {
            id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
            ad_targeting_info?: (POGOProtos.Rpc.IAdTargetingInfoProto|null);
            is_player_eligible_for_geotargeted_quest?: (boolean|null);
            is_from_wearable_device?: (boolean|null);
        }

        class FortSearchProto implements IFortSearchProto {
            constructor(properties?: POGOProtos.Rpc.IFortSearchProto);
            public id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public ad_targeting_info?: (POGOProtos.Rpc.IAdTargetingInfoProto|null);
            public is_player_eligible_for_geotargeted_quest: boolean;
            public is_from_wearable_device: boolean;
            public static encode(message: POGOProtos.Rpc.IFortSearchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortSearchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortSearchProto;
            public static toObject(message: POGOProtos.Rpc.FortSearchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortSettingsProto {
            interaction_range_meters?: (number|null);
            max_total_deployed_pokemon?: (number|null);
            max_player_deployed_pokemon?: (number|null);
            deploy_stamina_multiplier?: (number|null);
            deploy_attack_multiplier?: (number|null);
            far_interaction_range_meters?: (number|null);
            disable_gyms?: (boolean|null);
            max_same_pokemon_at_fort?: (number|null);
            max_player_total_deployed_pokemon?: (number|null);
            enable_hyperlinks_in_poi_descriptions?: (boolean|null);
            enable_right_to_left_text_display?: (boolean|null);
            enable_sponsored_poi_decorators?: (boolean|null);
            remote_interaction_range_meters?: (number|null);
        }

        class FortSettingsProto implements IFortSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFortSettingsProto);
            public interaction_range_meters: number;
            public max_total_deployed_pokemon: number;
            public max_player_deployed_pokemon: number;
            public deploy_stamina_multiplier: number;
            public deploy_attack_multiplier: number;
            public far_interaction_range_meters: number;
            public disable_gyms: boolean;
            public max_same_pokemon_at_fort: number;
            public max_player_total_deployed_pokemon: number;
            public enable_hyperlinks_in_poi_descriptions: boolean;
            public enable_right_to_left_text_display: boolean;
            public enable_sponsored_poi_decorators: boolean;
            public remote_interaction_range_meters: number;
            public static encode(message: POGOProtos.Rpc.IFortSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FortSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortSponsor {
            sponsor?: (POGOProtos.Rpc.FortSponsor.Sponsor|null);
        }

        class FortSponsor implements IFortSponsor {
            constructor(properties?: POGOProtos.Rpc.IFortSponsor);
            public sponsor: POGOProtos.Rpc.FortSponsor.Sponsor;
            public static encode(message: POGOProtos.Rpc.IFortSponsor, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortSponsor;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortSponsor;
            public static toObject(message: POGOProtos.Rpc.FortSponsor, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortSponsor {

            enum Sponsor {
                UNSET = 0,
                MCDONALDS = 1,
                POKEMON_STORE = 2,
                TOHO = 3,
                SOFTBANK = 4,
                GLOBE = 5,
                SPATULA = 6,
                THERMOMETER = 7,
                KNIFE = 8,
                GRILL = 9,
                SMOKER = 10,
                PAN = 11,
                BBQ = 12,
                FRYER = 13,
                STEAMER = 14,
                HOOD = 15,
                SLOWCOOKER = 16,
                MIXER = 17,
                SCOOPER = 18,
                MUFFINTIN = 19,
                SALAMANDER = 20,
                PLANCHA = 21,
                NIA_OPS = 22,
                WHISK = 23
            }
        }

        interface IFortUpdateLatencyTelemetry {
            latency_ms?: (number|null);
            fort_type?: (number|null);
            distance?: (number|null);
            context?: (string|null);
        }

        class FortUpdateLatencyTelemetry implements IFortUpdateLatencyTelemetry {
            constructor(properties?: POGOProtos.Rpc.IFortUpdateLatencyTelemetry);
            public latency_ms: number;
            public fort_type: number;
            public distance: number;
            public context: string;
            public static encode(message: POGOProtos.Rpc.IFortUpdateLatencyTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortUpdateLatencyTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortUpdateLatencyTelemetry;
            public static toObject(message: POGOProtos.Rpc.FortUpdateLatencyTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFortVpsInfoProto {
            vps_enabled_v2?: (boolean|null);
            anchor_id?: (string|null);
            anchor_payload?: (string|null);
            hint_image_url?: (string|null);
            is_hint_image_poi_image?: (boolean|null);
            vps_enabled_status?: (POGOProtos.Rpc.VpsEnabledStatus|null);
            mesh_metadata?: (POGOProtos.Rpc.IHoloholoMeshMetadata|null);
            hint_image_lat?: (number|null);
            hint_image_lng?: (number|null);
            hint_image_position?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition|null);
            hint_image_rotation?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IRotation|null);
            vps_temporarily_not_allowed_until_ms?: (number|Long|null);
            localization_tier_level?: (number|null);
            vps_disallowed_details?: (POGOProtos.Rpc.FortVpsInfoProto.IVpsDisallowedDetailsProto|null);
        }

        class FortVpsInfoProto implements IFortVpsInfoProto {
            constructor(properties?: POGOProtos.Rpc.IFortVpsInfoProto);
            public vps_enabled_v2: boolean;
            public anchor_id: string;
            public anchor_payload: string;
            public hint_image_url: string;
            public is_hint_image_poi_image: boolean;
            public vps_enabled_status: POGOProtos.Rpc.VpsEnabledStatus;
            public mesh_metadata?: (POGOProtos.Rpc.IHoloholoMeshMetadata|null);
            public hint_image_lat: number;
            public hint_image_lng: number;
            public hint_image_position?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition|null);
            public hint_image_rotation?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IRotation|null);
            public vps_temporarily_not_allowed_until_ms: (number|Long);
            public localization_tier_level: number;
            public vps_disallowed_details?: (POGOProtos.Rpc.FortVpsInfoProto.IVpsDisallowedDetailsProto|null);
            public static encode(message: POGOProtos.Rpc.IFortVpsInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortVpsInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortVpsInfoProto;
            public static toObject(message: POGOProtos.Rpc.FortVpsInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FortVpsInfoProto {

            interface IVpsDisallowedDetailsProto {
                source?: (POGOProtos.Rpc.FortVpsInfoProto.VpsDisallowedDetailsProto.VpsDisallowedSource|null);
                previous_state?: (POGOProtos.Rpc.VpsEnabledStatus|null);
            }

            class VpsDisallowedDetailsProto implements IVpsDisallowedDetailsProto {
                constructor(properties?: POGOProtos.Rpc.FortVpsInfoProto.IVpsDisallowedDetailsProto);
                public source: POGOProtos.Rpc.FortVpsInfoProto.VpsDisallowedDetailsProto.VpsDisallowedSource;
                public previous_state: POGOProtos.Rpc.VpsEnabledStatus;
                public static encode(message: POGOProtos.Rpc.FortVpsInfoProto.IVpsDisallowedDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FortVpsInfoProto.VpsDisallowedDetailsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FortVpsInfoProto.VpsDisallowedDetailsProto;
                public static toObject(message: POGOProtos.Rpc.FortVpsInfoProto.VpsDisallowedDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace VpsDisallowedDetailsProto {

                enum VpsDisallowedSource {
                    DISALLOWED_SOURCE_UNSET = 0,
                    PGO_ADMIN_BAN = 1,
                    GEOSTORE_BAN = 2,
                    LOW_VPS_SCORE = 3
                }
            }
        }

        interface IFramePoses {
            coordinate?: (string|null);
            poses?: (POGOProtos.Rpc.IPose[]|null);
        }

        class FramePoses implements IFramePoses {
            constructor(properties?: POGOProtos.Rpc.IFramePoses);
            public coordinate: string;
            public poses: POGOProtos.Rpc.IPose[];
            public static encode(message: POGOProtos.Rpc.IFramePoses, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FramePoses;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FramePoses;
            public static toObject(message: POGOProtos.Rpc.FramePoses, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFrameRate {
            sampled_frame_rate?: (POGOProtos.Rpc.IPlatformMetricData|null);
        }

        class FrameRate implements IFrameRate {
            constructor(properties?: POGOProtos.Rpc.IFrameRate);
            public sampled_frame_rate?: (POGOProtos.Rpc.IPlatformMetricData|null);
            public static encode(message: POGOProtos.Rpc.IFrameRate, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FrameRate;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FrameRate;
            public static toObject(message: POGOProtos.Rpc.FrameRate, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFriendActivityProto {
            raid_activity?: (POGOProtos.Rpc.IRaidFriendActivityProto|null);
            max_battle_activity?: (POGOProtos.Rpc.IMaxBattleFriendActivityProto|null);
        }

        class FriendActivityProto implements IFriendActivityProto {
            constructor(properties?: POGOProtos.Rpc.IFriendActivityProto);
            public raid_activity?: (POGOProtos.Rpc.IRaidFriendActivityProto|null);
            public max_battle_activity?: (POGOProtos.Rpc.IMaxBattleFriendActivityProto|null);
            public Type?: ("raid_activity"|"max_battle_activity");
            public static encode(message: POGOProtos.Rpc.IFriendActivityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FriendActivityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FriendActivityProto;
            public static toObject(message: POGOProtos.Rpc.FriendActivityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFriendshipDataProto {
            friendship_level_data?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            giftbox_details?: (POGOProtos.Rpc.IGiftBoxDetailsProto[]|null);
            codename?: (string|null);
            nickname?: (string|null);
            open_trade_expire_ms?: (number|Long|null);
            is_lucky?: (boolean|null);
            lucky_count?: (number|null);
        }

        class FriendshipDataProto implements IFriendshipDataProto {
            constructor(properties?: POGOProtos.Rpc.IFriendshipDataProto);
            public friendship_level_data?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            public giftbox_details: POGOProtos.Rpc.IGiftBoxDetailsProto[];
            public codename: string;
            public nickname: string;
            public open_trade_expire_ms: (number|Long);
            public is_lucky: boolean;
            public lucky_count: number;
            public static encode(message: POGOProtos.Rpc.IFriendshipDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FriendshipDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FriendshipDataProto;
            public static toObject(message: POGOProtos.Rpc.FriendshipDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFriendshipLevelDataProto {
            bucket?: (number|Long|null);
            points_earned_today?: (number|null);
            awarded_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            current_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            next_friendship_milestone_progress_percentage?: (number|null);
            points_toward_next_milestone?: (number|null);
        }

        class FriendshipLevelDataProto implements IFriendshipLevelDataProto {
            constructor(properties?: POGOProtos.Rpc.IFriendshipLevelDataProto);
            public bucket: (number|Long);
            public points_earned_today: number;
            public awarded_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public current_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public next_friendship_milestone_progress_percentage: number;
            public points_toward_next_milestone: number;
            public static encode(message: POGOProtos.Rpc.IFriendshipLevelDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FriendshipLevelDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FriendshipLevelDataProto;
            public static toObject(message: POGOProtos.Rpc.FriendshipLevelDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFriendshipLevelMilestoneSettingsProto {
            min_points_to_reach?: (number|null);
            milestone_xp_reward?: (number|null);
            attack_bonus_percentage?: (number|null);
            raid_ball_bonus?: (number|null);
            unlocked_trading?: (POGOProtos.Rpc.FriendshipLevelMilestoneSettingsProto.PokemonTradingType[]|null);
            trading_discount?: (number|null);
            unlocked_lucky_friend_applicator?: (boolean|null);
        }

        class FriendshipLevelMilestoneSettingsProto implements IFriendshipLevelMilestoneSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IFriendshipLevelMilestoneSettingsProto);
            public min_points_to_reach: number;
            public milestone_xp_reward: number;
            public attack_bonus_percentage: number;
            public raid_ball_bonus: number;
            public unlocked_trading: POGOProtos.Rpc.FriendshipLevelMilestoneSettingsProto.PokemonTradingType[];
            public trading_discount: number;
            public unlocked_lucky_friend_applicator: boolean;
            public static encode(message: POGOProtos.Rpc.IFriendshipLevelMilestoneSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FriendshipLevelMilestoneSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FriendshipLevelMilestoneSettingsProto;
            public static toObject(message: POGOProtos.Rpc.FriendshipLevelMilestoneSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FriendshipLevelMilestoneSettingsProto {

            enum PokemonTradingType {
                UNSET = 0,
                REGULAR_IN_POKEDEX = 1,
                SPECIAL_IN_POKEDEX = 2,
                REGULAR_NON_POKEDEX = 3,
                REGIONAL_NON_POKEDEX = 4,
                FORM_NON_POKEDEX = 5,
                LEGENDARY_NON_POKEDEX = 6,
                SHINY_NON_POKEDEX = 7,
                GMAX_NON_POKEDEX = 8,
                GMAX_IN_POKEDEX = 9
            }
        }

        interface IFriendshipMilestoneRewardNotificationProto {
            friend_id?: (string|null);
            friend_codename?: (string|null);
            friendship_milestone_level?: (number|null);
            xp_reward?: (number|Long|null);
        }

        class FriendshipMilestoneRewardNotificationProto implements IFriendshipMilestoneRewardNotificationProto {
            constructor(properties?: POGOProtos.Rpc.IFriendshipMilestoneRewardNotificationProto);
            public friend_id: string;
            public friend_codename: string;
            public friendship_milestone_level: number;
            public xp_reward: (number|Long);
            public static encode(message: POGOProtos.Rpc.IFriendshipMilestoneRewardNotificationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FriendshipMilestoneRewardNotificationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FriendshipMilestoneRewardNotificationProto;
            public static toObject(message: POGOProtos.Rpc.FriendshipMilestoneRewardNotificationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFriendshipMilestoneRewardProto {
            friend_id?: (string|null);
            friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            nia_account_id?: (string|null);
        }

        class FriendshipMilestoneRewardProto implements IFriendshipMilestoneRewardProto {
            constructor(properties?: POGOProtos.Rpc.IFriendshipMilestoneRewardProto);
            public friend_id: string;
            public friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IFriendshipMilestoneRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FriendshipMilestoneRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FriendshipMilestoneRewardProto;
            public static toObject(message: POGOProtos.Rpc.FriendshipMilestoneRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFusePokemonRequestProto {
            pokemon_id?: (number|Long|null);
            target_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            component_pokemon_id?: (number|Long|null);
        }

        class FusePokemonRequestProto implements IFusePokemonRequestProto {
            constructor(properties?: POGOProtos.Rpc.IFusePokemonRequestProto);
            public pokemon_id: (number|Long);
            public target_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public component_pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IFusePokemonRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FusePokemonRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FusePokemonRequestProto;
            public static toObject(message: POGOProtos.Rpc.FusePokemonRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IFusePokemonResponseProto {
            result?: (POGOProtos.Rpc.FusePokemonResponseProto.Result|null);
            fused_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            exp_awarded?: (number|null);
            candy_awarded?: (number|null);
        }

        class FusePokemonResponseProto implements IFusePokemonResponseProto {
            constructor(properties?: POGOProtos.Rpc.IFusePokemonResponseProto);
            public result: POGOProtos.Rpc.FusePokemonResponseProto.Result;
            public fused_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public exp_awarded: number;
            public candy_awarded: number;
            public static encode(message: POGOProtos.Rpc.IFusePokemonResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FusePokemonResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FusePokemonResponseProto;
            public static toObject(message: POGOProtos.Rpc.FusePokemonResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace FusePokemonResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_MISSING = 2,
                ERROR_INSUFFICIENT_RESOURCES = 3,
                ERROR_QUEST_INCOMPLETE = 4,
                ERROR_POKEMON_CANNOT_CHANGE = 5,
                ERROR_POKEMON_DEPLOYED = 6,
                ERROR_FEATURE_DISABLED = 7,
                ERROR_UNKNOWN = 8
            }
        }

        interface IFusionPokemonDetailsProto {
            component_pokemon_id?: (number|Long|null);
            base_move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
            base_move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
            base_move3?: (POGOProtos.Rpc.HoloPokemonMove|null);
            base_location_card?: (POGOProtos.Rpc.ILocationCardDisplayProto|null);
        }

        class FusionPokemonDetailsProto implements IFusionPokemonDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IFusionPokemonDetailsProto);
            public component_pokemon_id: (number|Long);
            public base_move1: POGOProtos.Rpc.HoloPokemonMove;
            public base_move2: POGOProtos.Rpc.HoloPokemonMove;
            public base_move3: POGOProtos.Rpc.HoloPokemonMove;
            public base_location_card?: (POGOProtos.Rpc.ILocationCardDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IFusionPokemonDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.FusionPokemonDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.FusionPokemonDetailsProto;
            public static toObject(message: POGOProtos.Rpc.FusionPokemonDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGMaxDetails {
            powerspot_id?: (string|null);
            bread_battle_seed?: (number|Long|null);
            lat?: (number|null);
            lng?: (number|null);
            powerspot_title?: (string|null);
            battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
            battle_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            battle_window_start_ms?: (number|Long|null);
            battle_window_end_ms?: (number|Long|null);
        }

        class GMaxDetails implements IGMaxDetails {
            constructor(properties?: POGOProtos.Rpc.IGMaxDetails);
            public powerspot_id: string;
            public bread_battle_seed: (number|Long);
            public lat: number;
            public lng: number;
            public powerspot_title: string;
            public battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public battle_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public battle_window_start_ms: (number|Long);
            public battle_window_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGMaxDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GMaxDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GMaxDetails;
            public static toObject(message: POGOProtos.Rpc.GMaxDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGamDetails {
            gam_request_keywords?: (string[]|null);
            gam_request_extras?: ({ [k: string]: string }|null);
        }

        class GamDetails implements IGamDetails {
            constructor(properties?: POGOProtos.Rpc.IGamDetails);
            public gam_request_keywords: string[];
            public gam_request_extras: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IGamDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GamDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GamDetails;
            public static toObject(message: POGOProtos.Rpc.GamDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGameMasterClientTemplateProto {
            template_id?: (string|null);
            pokemon?: (POGOProtos.Rpc.IPokemonSettingsProto|null);
            item?: (POGOProtos.Rpc.IItemSettingsProto|null);
            move?: (POGOProtos.Rpc.IMoveSettingsProto|null);
            move_sequence?: (POGOProtos.Rpc.IMoveSequenceSettingsProto|null);
            type_effective?: (POGOProtos.Rpc.ITypeEffectiveSettingsProto|null);
            badge?: (POGOProtos.Rpc.IBadgeSettingsProto|null);
            player_level?: (POGOProtos.Rpc.IPlayerLevelSettingsProto|null);
            battle_settings?: (POGOProtos.Rpc.IGymBattleSettingsProto|null);
            encounter_settings?: (POGOProtos.Rpc.IEncounterSettingsProto|null);
            iap_item_display?: (POGOProtos.Rpc.IIapItemDisplayProto|null);
            iap_settings?: (POGOProtos.Rpc.IIapSettingsProto|null);
            pokemon_upgrades?: (POGOProtos.Rpc.IPokemonUpgradeSettingsProto|null);
            quest_settings?: (POGOProtos.Rpc.IQuestSettingsProto|null);
            avatar_customization?: (POGOProtos.Rpc.IAvatarCustomizationProto|null);
            form_settings?: (POGOProtos.Rpc.IFormSettingsProto|null);
            gender_settings?: (POGOProtos.Rpc.IClientGenderSettingsProto|null);
            gym_badge_settings?: (POGOProtos.Rpc.IGymBadgeGmtSettingsProto|null);
            weather_affinities?: (POGOProtos.Rpc.IWeatherAffinityProto|null);
            weather_bonus_settings?: (POGOProtos.Rpc.IWeatherBonusProto|null);
            pokemon_scale_settings?: (POGOProtos.Rpc.IPokemonScaleSettingProto|null);
            iap_category_display?: (POGOProtos.Rpc.IIapItemCategoryDisplayProto|null);
            beluga_pokemon_whitelist?: (POGOProtos.Rpc.IBelugaPokemonWhitelist|null);
            onboarding_settings?: (POGOProtos.Rpc.IOnboardingSettingsProto|null);
            friendship_milestone_settings?: (POGOProtos.Rpc.IFriendshipLevelMilestoneSettingsProto|null);
            lucky_pokemon_settings?: (POGOProtos.Rpc.ILuckyPokemonSettingsProto|null);
            combat_settings?: (POGOProtos.Rpc.ICombatSettingsProto|null);
            combat_league_settings?: (POGOProtos.Rpc.ICombatLeagueSettingsProto|null);
            combat_league?: (POGOProtos.Rpc.ICombatLeagueProto|null);
            combat_move?: (POGOProtos.Rpc.ICombatMoveSettingsProto|null);
            background_mode_settings?: (POGOProtos.Rpc.IBackgroundModeSettingsProto|null);
            combat_stat_stage_settings?: (POGOProtos.Rpc.ICombatStatStageSettingsProto|null);
            combat_npc_trainer?: (POGOProtos.Rpc.ICombatNpcTrainerProto|null);
            combat_npc_personality?: (POGOProtos.Rpc.ICombatNpcPersonalityProto|null);
            party_recommendation_settings?: (POGOProtos.Rpc.IPartyRecommendationSettingsProto|null);
            pokecoin_purchase_display_gmt?: (POGOProtos.Rpc.IPokecoinPurchaseDisplayGmtProto|null);
            invasion_npc_display_settings?: (POGOProtos.Rpc.IInvasionNpcDisplaySettingsProto|null);
            combat_competitive_season_settings?: (POGOProtos.Rpc.ICombatCompetitiveSeasonSettingsProto|null);
            combat_ranking_proto_settings?: (POGOProtos.Rpc.ICombatRankingSettingsProto|null);
            combat_type?: (POGOProtos.Rpc.ICombatTypeProto|null);
            buddy_level_settings?: (POGOProtos.Rpc.IBuddyLevelSettings|null);
            buddy_activity_category_settings?: (POGOProtos.Rpc.IBuddyActivityCategorySettings|null);
            buddy_swap_settings?: (POGOProtos.Rpc.IBuddySwapSettings|null);
            route_creation_settings?: (POGOProtos.Rpc.IRoutesCreationSettingsProto|null);
            vs_seeker_client_settings?: (POGOProtos.Rpc.IVsSeekerClientSettingsProto|null);
            buddy_encounter_cameo_settings?: (POGOProtos.Rpc.IBuddyEncounterCameoSettings|null);
            limited_purchase_sku_settings?: (POGOProtos.Rpc.ILimitedPurchaseSkuSettingsProto|null);
            buddy_emotion_level_settings?: (POGOProtos.Rpc.IBuddyEmotionLevelSettings|null);
            pokestop_invasion_availability_settings?: (POGOProtos.Rpc.IInvasionAvailabilitySettingsProto|null);
            buddy_interaction_settings?: (POGOProtos.Rpc.IBuddyInteractionSettings|null);
            vs_seeker_loot_proto?: (POGOProtos.Rpc.IVsSeekerLootProto|null);
            vs_seeker_pokemon_rewards?: (POGOProtos.Rpc.IVsSeekerPokemonRewardsProto|null);
            battle_hub_order_settings?: (POGOProtos.Rpc.IBattleHubOrderSettings|null);
            battle_hub_badge_settings?: (POGOProtos.Rpc.IBattleHubBadgeSettings|null);
            map_buddy_settings?: (POGOProtos.Rpc.IMapBuddySettingsProto|null);
            buddy_walk_settings?: (POGOProtos.Rpc.IBuddyWalkSettings|null);
            buddy_hunger_settings?: (POGOProtos.Rpc.IBuddyHungerSettings|null);
            project_vacation?: (POGOProtos.Rpc.IProjectVacationProto|null);
            mega_evo_settings?: (POGOProtos.Rpc.IMegaEvoSettingsProto|null);
            temporary_evolution_settings?: (POGOProtos.Rpc.ITemporaryEvolutionSettingsProto|null);
            avatar_group_settings?: (POGOProtos.Rpc.IAvatarGroupSettingsProto|null);
            pokemon_family?: (POGOProtos.Rpc.IPokemonFamilySettingsProto|null);
            monodepth_settings?: (POGOProtos.Rpc.IMonodepthSettingsProto|null);
            level_up_rewards?: (POGOProtos.Rpc.ILevelUpRewardsSettingsProto|null);
            raid_settings_proto?: (POGOProtos.Rpc.IRaidClientSettingsProto|null);
            tappable_settings?: (POGOProtos.Rpc.ITappableSettingsProto|null);
            route_play_settings?: (POGOProtos.Rpc.IRoutePlaySettingsProto|null);
            sponsored_geofence_gift_settings?: (POGOProtos.Rpc.ISponsoredGeofenceGiftSettingsProto|null);
            sticker_metadata?: (POGOProtos.Rpc.IStickerMetadataProto|null);
            cross_game_social_settings?: (POGOProtos.Rpc.ICrossGameSocialSettingsProto|null);
            map_display_settings?: (POGOProtos.Rpc.IMapDisplaySettingsProto|null);
            pokemon_home_energy_costs?: (POGOProtos.Rpc.IPokemonHomeEnergyCostsProto|null);
            pokemon_home_settings?: (POGOProtos.Rpc.IPokemonHomeSettingsProto|null);
            ar_telemetry_settings?: (POGOProtos.Rpc.IArTelemetrySettingsProto|null);
            battle_party_settings?: (POGOProtos.Rpc.IBattlePartySettingsProto|null);
            pokemon_home_form_reversion?: (POGOProtos.Rpc.IPokemonHomeFormReversionProto|null);
            deep_linking_settings?: (POGOProtos.Rpc.IDeepLinkingSettingsProto|null);
            gui_search_settings?: (POGOProtos.Rpc.IGuiSearchSettingsProto|null);
            evolution_quest_template?: (POGOProtos.Rpc.IClientEvolutionQuestTemplateProto|null);
            geotargeted_quest_settings?: (POGOProtos.Rpc.IGeotargetedQuestSettingsProto|null);
            pokemon_tag_settings?: (POGOProtos.Rpc.IPokemonTagSettingsProto|null);
            recommended_search_proto?: (POGOProtos.Rpc.IRecommendedSearchProto|null);
            inventory_settings?: (POGOProtos.Rpc.IInventorySettingsProto|null);
            route_discovery_settings?: (POGOProtos.Rpc.IRouteDiscoverySettingsProto|null);
            fort_power_up_level_settings?: (POGOProtos.Rpc.IFortPowerUpLevelSettings|null);
            power_up_pokestops_settings?: (POGOProtos.Rpc.IPowerUpPokestopsSharedSettingsProto|null);
            incident_priority_settings?: (POGOProtos.Rpc.IIncidentPrioritySettingsProto|null);
            referral_settings?: (POGOProtos.Rpc.IReferralSettingsProto|null);
            pokedex_categories_settings?: (POGOProtos.Rpc.IPokedexCategoriesSettingsProto|null);
            battle_visual_settings?: (POGOProtos.Rpc.IBattleVisualSettingsProto|null);
            addressable_pokemon_settings?: (POGOProtos.Rpc.IAddressablePokemonProto|null);
            verbose_log_raid_settings?: (POGOProtos.Rpc.IVerboseLogRaidProto|null);
            shared_move_settings?: (POGOProtos.Rpc.ISharedMoveSettingsProto|null);
            address_book_import_settings?: (POGOProtos.Rpc.IAddressBookImportSettingsProto|null);
            music_settings?: (POGOProtos.Rpc.IMusicSettingsProto|null);
            map_objects_interaction_range_settings?: (POGOProtos.Rpc.IClientMapObjectsInteractionRangeSettingsProto|null);
            external_addressable_assets_settings?: (POGOProtos.Rpc.IExternalAddressableAssetsProto|null);
            username_suggestion_settings?: (POGOProtos.Rpc.IUsernameSuggestionSettingsProto|null);
            tutorial_settings?: (POGOProtos.Rpc.ITutorialsSettingsProto|null);
            egg_hatch_improvements_settings?: (POGOProtos.Rpc.IEggHatchImprovementsSettingsProto|null);
            feature_unlock_level_settings?: (POGOProtos.Rpc.IFeatureUnlockLevelSettings|null);
            in_app_survey_settings?: (POGOProtos.Rpc.IInAppSurveySettingsProto|null);
            incident_visibility_settings?: (POGOProtos.Rpc.IIncidentVisibilitySettingsProto|null);
            postcard_collection_settings?: (POGOProtos.Rpc.IPostcardCollectionGmtSettingsProto|null);
            verbose_log_combat_settings?: (POGOProtos.Rpc.IVerboseLogCombatProto|null);
            mega_evo_level_settings?: (POGOProtos.Rpc.IMegaEvolutionLevelSettingsProto|null);
            advanced_settings?: (POGOProtos.Rpc.IAdvancedSettingsProto|null);
            impression_tracking_settings?: (POGOProtos.Rpc.IImpressionTrackingSettingsProto|null);
            garbage_collection_settings?: (POGOProtos.Rpc.IGarbageCollectionSettingsProto|null);
            evolution_chain_display_settings?: (POGOProtos.Rpc.IEvolutionChainDisplaySettingsProto|null);
            route_stamp_category_settings?: (POGOProtos.Rpc.IRouteStampCategorySettingsProto|null);
            popup_control_settings?: (POGOProtos.Rpc.IPopupControlSettingsProto|null);
            ticket_gifting_settings?: (POGOProtos.Rpc.ITicketGiftingSettingsProto|null);
            language_selector_settings?: (POGOProtos.Rpc.ILanguageSelectorSettingsProto|null);
            gifting_settings?: (POGOProtos.Rpc.IGiftingSettingsProto|null);
            campfire_settings?: (POGOProtos.Rpc.ICampfireSettingsProto|null);
            photo_settings?: (POGOProtos.Rpc.IPhotoSettingsProto|null);
            daily_adventure_incense_settings?: (POGOProtos.Rpc.IDailyAdventureIncenseSettingsProto|null);
            item_inventory_update_settings?: (POGOProtos.Rpc.IItemInventoryUpdateSettingsProto|null);
            sticker_category_settings?: (POGOProtos.Rpc.IStickerCategorySettingsProto|null);
            home_widget_settings?: (POGOProtos.Rpc.IHomeWidgetSettingsProto|null);
            vs_seeker_schedule_settings?: (POGOProtos.Rpc.IVsSeekerScheduleSettingsProto|null);
            pokedex_size_stats_system_settings?: (POGOProtos.Rpc.IPokedexSizeStatsSystemSettingsProto|null);
            asset_refresh_proto?: (POGOProtos.Rpc.IAssetRefreshProto|null);
            pokemon_fx_settings?: (POGOProtos.Rpc.IPokemonFxSettingsProto|null);
            butterfly_collector_settings?: (POGOProtos.Rpc.IButterflyCollectorSettings|null);
            language_settings?: (POGOProtos.Rpc.ILanguageSettingsProto|null);
            pokemon_extended_settings?: (POGOProtos.Rpc.IPokemonExtendedSettingsProto|null);
            primal_evo_settings?: (POGOProtos.Rpc.IPrimalEvoSettingsProto|null);
            nia_id_migration_settings?: (POGOProtos.Rpc.INiaIdMigrationSettingsProto|null);
            location_card_settings?: (POGOProtos.Rpc.ILocationCardSettingsProto|null);
            conversation_settings?: (POGOProtos.Rpc.IConversationSettingsProto|null);
            vps_event_settings?: (POGOProtos.Rpc.IVpsEventSettingsProto|null);
            catch_radius_multiplier_settings?: (POGOProtos.Rpc.ICatchRadiusMultiplierSettingsProto|null);
            haptics_settings?: (POGOProtos.Rpc.IHapticsSettingsProto|null);
            raid_lobby_counter_settings?: (POGOProtos.Rpc.IRaidLobbyCounterSettingsProto|null);
            contest_settings?: (POGOProtos.Rpc.IContestSettingsProto|null);
            guest_account_game_settings_proto?: (POGOProtos.Rpc.IGuestAccountGameSettingsProto|null);
            neutral_avatar_settings?: (POGOProtos.Rpc.INeutralAvatarSettingsProto|null);
            squash_settings?: (POGOProtos.Rpc.ISquashSettingsProto|null);
            today_view_settings?: (POGOProtos.Rpc.ITodayViewSettingsProto|null);
            route_pin_settings?: (POGOProtos.Rpc.IRoutePinSettingsProto|null);
            style_shop_settings?: (POGOProtos.Rpc.IStyleShopSettingsProto|null);
            party_play_general_settings?: (POGOProtos.Rpc.IPartyPlayGeneralSettingsProto|null);
            optimizations_proto?: (POGOProtos.Rpc.IOptimizationsProto|null);
            nearby_pokemon_settings?: (POGOProtos.Rpc.INearbyPokemonSettings|null);
            party_player_summary_settings?: (POGOProtos.Rpc.IPartySummarySettingsProto|null);
            party_shared_quest_settings?: (POGOProtos.Rpc.IPartySharedQuestSettingsProto|null);
            client_poi_decoration_group?: (POGOProtos.Rpc.IClientPoiDecorationGroupProto|null);
            map_coord_overlay?: (POGOProtos.Rpc.IMapCoordOverlayProto|null);
            vista_general_settings?: (POGOProtos.Rpc.IVistaGeneralSettingsProto|null);
            route_badge_settings?: (POGOProtos.Rpc.IRouteBadgeSettingsProto|null);
            party_dark_launch_settings?: (POGOProtos.Rpc.IPartyDarkLaunchSettingsProto|null);
            routes_party_play_interop_settings?: (POGOProtos.Rpc.IRoutesPartyPlayInteroperabilitySettingsProto|null);
            routes_nearby_notif_settings?: (POGOProtos.Rpc.IRoutesNearbyNotifSettingsProto|null);
            non_combat_move_settings?: (POGOProtos.Rpc.INonCombatMoveSettingsProto|null);
            player_bonus_system_settings?: (POGOProtos.Rpc.IPlayerBonusSystemSettingsProto|null);
            ptc_oauth_settings?: (POGOProtos.Rpc.IPtcOAuthSettingsProto|null);
            graphics_capabilities_settings?: (POGOProtos.Rpc.IGraphicsCapabilitiesSettingsProto|null);
            party_iap_boosts_settings?: (POGOProtos.Rpc.IPartyIapBoostsSettingsProto|null);
            language_bundle?: (POGOProtos.Rpc.ILanguageBundleProto|null);
            bulk_healing_settings?: (POGOProtos.Rpc.IBulkHealingSettingsProto|null);
            photo_sets_settings_proto?: (POGOProtos.Rpc.IPokemonPhotoSetsProto|null);
            main_menu_camera_button_settings?: (POGOProtos.Rpc.IMainMenuCameraButtonSettingsProto|null);
            shared_fusion_settings?: (POGOProtos.Rpc.ISharedFusionSettingsProto|null);
            iris_social_settings?: (POGOProtos.Rpc.IIrisSocialSettingsProto|null);
            additive_scene_settings?: (POGOProtos.Rpc.IAdditiveSceneSettingsProto|null);
            mp_settings?: (POGOProtos.Rpc.IMpSharedSettingsProto|null);
            bread_feature_flags?: (POGOProtos.Rpc.IBreadFeatureFlagsProto|null);
            bread_settings?: (POGOProtos.Rpc.IBreadSharedSettingsProto|null);
            settings_override_rule?: (POGOProtos.Rpc.ISettingsOverrideRuleProto|null);
            save_for_later_settings?: (POGOProtos.Rpc.ISaveForLaterSettingsProto|null);
            iris_social_ux_funnel_settings?: (POGOProtos.Rpc.IIrisSocialUserExperienceFunnelSettingsProto|null);
            map_icon_sort_order?: (POGOProtos.Rpc.IMapIconSortOrderProto|null);
            bread_battle_client_settings?: (POGOProtos.Rpc.IBreadBattleClientSettingsProto|null);
            error_reporting_settings?: (POGOProtos.Rpc.IErrorReportingSettingsProto|null);
            bread_move_level_settings?: (POGOProtos.Rpc.IBreadMoveLevelSettingsProto|null);
            item_expiration_settings?: (POGOProtos.Rpc.IItemExpirationSettingsProto|null);
            bread_move_mappings?: (POGOProtos.Rpc.IBreadMoveMappingSettingsProto|null);
            station_reward_settings?: (POGOProtos.Rpc.IStationRewardSettingsProto|null);
            stationed_pokemon_table_settings?: (POGOProtos.Rpc.IStationedPokemonTableSettingsProto|null);
            accessibility_settings?: (POGOProtos.Rpc.IAccessibilitySettingsProto|null);
            bread_lobby_counter_settings?: (POGOProtos.Rpc.IBreadLobbyCounterSettingsProto|null);
            bread_pokemon_scaling_settings?: (POGOProtos.Rpc.IBreadPokemonScalingSettingsProto|null);
            pokeball_throw_property_settings?: (POGOProtos.Rpc.IPokeballThrowPropertySettingsProto|null);
            sourdough_move_mapping_settings?: (POGOProtos.Rpc.ISourdoughMoveMappingSettingsProto|null);
            event_map_decoration_settings?: (POGOProtos.Rpc.IEventMapDecorationSettingsProto|null);
            event_map_decoration_system_settings?: (POGOProtos.Rpc.IEventMapDecorationSystemSettingsProto|null);
            pokemon_info_panel_settings?: (POGOProtos.Rpc.IPokemonInfoPanelSettingsProto|null);
            stamp_collection_settings?: (POGOProtos.Rpc.IStampCollectionSettingsProto|null);
            iap_store_banner?: (POGOProtos.Rpc.IIapStoreBannerProto|null);
            avatar_item_display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            pokedexv2_feature_flags?: (POGOProtos.Rpc.IPokedexV2FeatureFlagProto|null);
            code_gate_proto?: (POGOProtos.Rpc.ICodeGateProto|null);
            pokedex_v2_settings?: (POGOProtos.Rpc.IPokedexV2SettingsProto|null);
            join_raid_via_friend_list_settings?: (POGOProtos.Rpc.IJoinRaidViaFriendListSettingsProto|null);
            event_pass_settings?: (POGOProtos.Rpc.IEventPassSettingsProto|null);
            event_pass_tier_settings?: (POGOProtos.Rpc.IEventPassTierSettingsProto|null);
            smart_glasses_feature_flags?: (POGOProtos.Rpc.ISmartGlassesFeatureFlagProto|null);
            planner_settings?: (POGOProtos.Rpc.IPlannerSettingsProto|null);
            map_scene_feature_flags?: (POGOProtos.Rpc.IMapSceneFeatureFlagsProto|null);
            bread_lobby_update_settings?: (POGOProtos.Rpc.IBreadLobbyUpdateSettingsProto|null);
            anti_leak_settings?: (POGOProtos.Rpc.IAntiLeakSettingsProto|null);
            battle_input_buffer_settings?: (POGOProtos.Rpc.IBattleInputBufferSettingsProto|null);
            client_quest_template?: (POGOProtos.Rpc.IClientQuestProto|null);
            event_pass_system_settings?: (POGOProtos.Rpc.IEventPassSystemSettingsProto|null);
            pvp_next_feature_flags?: (POGOProtos.Rpc.IPvpNextFeatureFlagsProto|null);
            neutral_avatar_mapping?: (POGOProtos.Rpc.INeutralAvatarMappingProto|null);
            feature_gate?: (POGOProtos.Rpc.IFeatureGateProto|null);
            roll_back?: (POGOProtos.Rpc.IRollBackProto|null);
            ibfc_lightweight_settings?: (POGOProtos.Rpc.IIBFCLightweightSettings|null);
            avatar_store_footer_flags?: (POGOProtos.Rpc.IAvatarStoreFooterEnabledProto|null);
            avatar_store_subcategory_filtering_flags?: (POGOProtos.Rpc.IAvatarStoreSubcategoryFilteringEnabledProto|null);
            two_for_one_flags?: (POGOProtos.Rpc.ITwoForOneEnabledProto|null);
            event_planner_popular_notification_settings?: (POGOProtos.Rpc.IEventPlannerPopularNotificationSettings|null);
            neutral_avatar_item_mapping?: (POGOProtos.Rpc.INeutralAvatarItemMappingProto|null);
        }

        class GameMasterClientTemplateProto implements IGameMasterClientTemplateProto {
            constructor(properties?: POGOProtos.Rpc.IGameMasterClientTemplateProto);
            public template_id: string;
            public pokemon?: (POGOProtos.Rpc.IPokemonSettingsProto|null);
            public item?: (POGOProtos.Rpc.IItemSettingsProto|null);
            public move?: (POGOProtos.Rpc.IMoveSettingsProto|null);
            public move_sequence?: (POGOProtos.Rpc.IMoveSequenceSettingsProto|null);
            public type_effective?: (POGOProtos.Rpc.ITypeEffectiveSettingsProto|null);
            public badge?: (POGOProtos.Rpc.IBadgeSettingsProto|null);
            public player_level?: (POGOProtos.Rpc.IPlayerLevelSettingsProto|null);
            public battle_settings?: (POGOProtos.Rpc.IGymBattleSettingsProto|null);
            public encounter_settings?: (POGOProtos.Rpc.IEncounterSettingsProto|null);
            public iap_item_display?: (POGOProtos.Rpc.IIapItemDisplayProto|null);
            public iap_settings?: (POGOProtos.Rpc.IIapSettingsProto|null);
            public pokemon_upgrades?: (POGOProtos.Rpc.IPokemonUpgradeSettingsProto|null);
            public quest_settings?: (POGOProtos.Rpc.IQuestSettingsProto|null);
            public avatar_customization?: (POGOProtos.Rpc.IAvatarCustomizationProto|null);
            public form_settings?: (POGOProtos.Rpc.IFormSettingsProto|null);
            public gender_settings?: (POGOProtos.Rpc.IClientGenderSettingsProto|null);
            public gym_badge_settings?: (POGOProtos.Rpc.IGymBadgeGmtSettingsProto|null);
            public weather_affinities?: (POGOProtos.Rpc.IWeatherAffinityProto|null);
            public weather_bonus_settings?: (POGOProtos.Rpc.IWeatherBonusProto|null);
            public pokemon_scale_settings?: (POGOProtos.Rpc.IPokemonScaleSettingProto|null);
            public iap_category_display?: (POGOProtos.Rpc.IIapItemCategoryDisplayProto|null);
            public beluga_pokemon_whitelist?: (POGOProtos.Rpc.IBelugaPokemonWhitelist|null);
            public onboarding_settings?: (POGOProtos.Rpc.IOnboardingSettingsProto|null);
            public friendship_milestone_settings?: (POGOProtos.Rpc.IFriendshipLevelMilestoneSettingsProto|null);
            public lucky_pokemon_settings?: (POGOProtos.Rpc.ILuckyPokemonSettingsProto|null);
            public combat_settings?: (POGOProtos.Rpc.ICombatSettingsProto|null);
            public combat_league_settings?: (POGOProtos.Rpc.ICombatLeagueSettingsProto|null);
            public combat_league?: (POGOProtos.Rpc.ICombatLeagueProto|null);
            public combat_move?: (POGOProtos.Rpc.ICombatMoveSettingsProto|null);
            public background_mode_settings?: (POGOProtos.Rpc.IBackgroundModeSettingsProto|null);
            public combat_stat_stage_settings?: (POGOProtos.Rpc.ICombatStatStageSettingsProto|null);
            public combat_npc_trainer?: (POGOProtos.Rpc.ICombatNpcTrainerProto|null);
            public combat_npc_personality?: (POGOProtos.Rpc.ICombatNpcPersonalityProto|null);
            public party_recommendation_settings?: (POGOProtos.Rpc.IPartyRecommendationSettingsProto|null);
            public pokecoin_purchase_display_gmt?: (POGOProtos.Rpc.IPokecoinPurchaseDisplayGmtProto|null);
            public invasion_npc_display_settings?: (POGOProtos.Rpc.IInvasionNpcDisplaySettingsProto|null);
            public combat_competitive_season_settings?: (POGOProtos.Rpc.ICombatCompetitiveSeasonSettingsProto|null);
            public combat_ranking_proto_settings?: (POGOProtos.Rpc.ICombatRankingSettingsProto|null);
            public combat_type?: (POGOProtos.Rpc.ICombatTypeProto|null);
            public buddy_level_settings?: (POGOProtos.Rpc.IBuddyLevelSettings|null);
            public buddy_activity_category_settings?: (POGOProtos.Rpc.IBuddyActivityCategorySettings|null);
            public buddy_swap_settings?: (POGOProtos.Rpc.IBuddySwapSettings|null);
            public route_creation_settings?: (POGOProtos.Rpc.IRoutesCreationSettingsProto|null);
            public vs_seeker_client_settings?: (POGOProtos.Rpc.IVsSeekerClientSettingsProto|null);
            public buddy_encounter_cameo_settings?: (POGOProtos.Rpc.IBuddyEncounterCameoSettings|null);
            public limited_purchase_sku_settings?: (POGOProtos.Rpc.ILimitedPurchaseSkuSettingsProto|null);
            public buddy_emotion_level_settings?: (POGOProtos.Rpc.IBuddyEmotionLevelSettings|null);
            public pokestop_invasion_availability_settings?: (POGOProtos.Rpc.IInvasionAvailabilitySettingsProto|null);
            public buddy_interaction_settings?: (POGOProtos.Rpc.IBuddyInteractionSettings|null);
            public vs_seeker_loot_proto?: (POGOProtos.Rpc.IVsSeekerLootProto|null);
            public vs_seeker_pokemon_rewards?: (POGOProtos.Rpc.IVsSeekerPokemonRewardsProto|null);
            public battle_hub_order_settings?: (POGOProtos.Rpc.IBattleHubOrderSettings|null);
            public battle_hub_badge_settings?: (POGOProtos.Rpc.IBattleHubBadgeSettings|null);
            public map_buddy_settings?: (POGOProtos.Rpc.IMapBuddySettingsProto|null);
            public buddy_walk_settings?: (POGOProtos.Rpc.IBuddyWalkSettings|null);
            public buddy_hunger_settings?: (POGOProtos.Rpc.IBuddyHungerSettings|null);
            public project_vacation?: (POGOProtos.Rpc.IProjectVacationProto|null);
            public mega_evo_settings?: (POGOProtos.Rpc.IMegaEvoSettingsProto|null);
            public temporary_evolution_settings?: (POGOProtos.Rpc.ITemporaryEvolutionSettingsProto|null);
            public avatar_group_settings?: (POGOProtos.Rpc.IAvatarGroupSettingsProto|null);
            public pokemon_family?: (POGOProtos.Rpc.IPokemonFamilySettingsProto|null);
            public monodepth_settings?: (POGOProtos.Rpc.IMonodepthSettingsProto|null);
            public level_up_rewards?: (POGOProtos.Rpc.ILevelUpRewardsSettingsProto|null);
            public raid_settings_proto?: (POGOProtos.Rpc.IRaidClientSettingsProto|null);
            public tappable_settings?: (POGOProtos.Rpc.ITappableSettingsProto|null);
            public route_play_settings?: (POGOProtos.Rpc.IRoutePlaySettingsProto|null);
            public sponsored_geofence_gift_settings?: (POGOProtos.Rpc.ISponsoredGeofenceGiftSettingsProto|null);
            public sticker_metadata?: (POGOProtos.Rpc.IStickerMetadataProto|null);
            public cross_game_social_settings?: (POGOProtos.Rpc.ICrossGameSocialSettingsProto|null);
            public map_display_settings?: (POGOProtos.Rpc.IMapDisplaySettingsProto|null);
            public pokemon_home_energy_costs?: (POGOProtos.Rpc.IPokemonHomeEnergyCostsProto|null);
            public pokemon_home_settings?: (POGOProtos.Rpc.IPokemonHomeSettingsProto|null);
            public ar_telemetry_settings?: (POGOProtos.Rpc.IArTelemetrySettingsProto|null);
            public battle_party_settings?: (POGOProtos.Rpc.IBattlePartySettingsProto|null);
            public pokemon_home_form_reversion?: (POGOProtos.Rpc.IPokemonHomeFormReversionProto|null);
            public deep_linking_settings?: (POGOProtos.Rpc.IDeepLinkingSettingsProto|null);
            public gui_search_settings?: (POGOProtos.Rpc.IGuiSearchSettingsProto|null);
            public evolution_quest_template?: (POGOProtos.Rpc.IClientEvolutionQuestTemplateProto|null);
            public geotargeted_quest_settings?: (POGOProtos.Rpc.IGeotargetedQuestSettingsProto|null);
            public pokemon_tag_settings?: (POGOProtos.Rpc.IPokemonTagSettingsProto|null);
            public recommended_search_proto?: (POGOProtos.Rpc.IRecommendedSearchProto|null);
            public inventory_settings?: (POGOProtos.Rpc.IInventorySettingsProto|null);
            public route_discovery_settings?: (POGOProtos.Rpc.IRouteDiscoverySettingsProto|null);
            public fort_power_up_level_settings?: (POGOProtos.Rpc.IFortPowerUpLevelSettings|null);
            public power_up_pokestops_settings?: (POGOProtos.Rpc.IPowerUpPokestopsSharedSettingsProto|null);
            public incident_priority_settings?: (POGOProtos.Rpc.IIncidentPrioritySettingsProto|null);
            public referral_settings?: (POGOProtos.Rpc.IReferralSettingsProto|null);
            public pokedex_categories_settings?: (POGOProtos.Rpc.IPokedexCategoriesSettingsProto|null);
            public battle_visual_settings?: (POGOProtos.Rpc.IBattleVisualSettingsProto|null);
            public addressable_pokemon_settings?: (POGOProtos.Rpc.IAddressablePokemonProto|null);
            public verbose_log_raid_settings?: (POGOProtos.Rpc.IVerboseLogRaidProto|null);
            public shared_move_settings?: (POGOProtos.Rpc.ISharedMoveSettingsProto|null);
            public address_book_import_settings?: (POGOProtos.Rpc.IAddressBookImportSettingsProto|null);
            public music_settings?: (POGOProtos.Rpc.IMusicSettingsProto|null);
            public map_objects_interaction_range_settings?: (POGOProtos.Rpc.IClientMapObjectsInteractionRangeSettingsProto|null);
            public external_addressable_assets_settings?: (POGOProtos.Rpc.IExternalAddressableAssetsProto|null);
            public username_suggestion_settings?: (POGOProtos.Rpc.IUsernameSuggestionSettingsProto|null);
            public tutorial_settings?: (POGOProtos.Rpc.ITutorialsSettingsProto|null);
            public egg_hatch_improvements_settings?: (POGOProtos.Rpc.IEggHatchImprovementsSettingsProto|null);
            public feature_unlock_level_settings?: (POGOProtos.Rpc.IFeatureUnlockLevelSettings|null);
            public in_app_survey_settings?: (POGOProtos.Rpc.IInAppSurveySettingsProto|null);
            public incident_visibility_settings?: (POGOProtos.Rpc.IIncidentVisibilitySettingsProto|null);
            public postcard_collection_settings?: (POGOProtos.Rpc.IPostcardCollectionGmtSettingsProto|null);
            public verbose_log_combat_settings?: (POGOProtos.Rpc.IVerboseLogCombatProto|null);
            public mega_evo_level_settings?: (POGOProtos.Rpc.IMegaEvolutionLevelSettingsProto|null);
            public advanced_settings?: (POGOProtos.Rpc.IAdvancedSettingsProto|null);
            public impression_tracking_settings?: (POGOProtos.Rpc.IImpressionTrackingSettingsProto|null);
            public garbage_collection_settings?: (POGOProtos.Rpc.IGarbageCollectionSettingsProto|null);
            public evolution_chain_display_settings?: (POGOProtos.Rpc.IEvolutionChainDisplaySettingsProto|null);
            public route_stamp_category_settings?: (POGOProtos.Rpc.IRouteStampCategorySettingsProto|null);
            public popup_control_settings?: (POGOProtos.Rpc.IPopupControlSettingsProto|null);
            public ticket_gifting_settings?: (POGOProtos.Rpc.ITicketGiftingSettingsProto|null);
            public language_selector_settings?: (POGOProtos.Rpc.ILanguageSelectorSettingsProto|null);
            public gifting_settings?: (POGOProtos.Rpc.IGiftingSettingsProto|null);
            public campfire_settings?: (POGOProtos.Rpc.ICampfireSettingsProto|null);
            public photo_settings?: (POGOProtos.Rpc.IPhotoSettingsProto|null);
            public daily_adventure_incense_settings?: (POGOProtos.Rpc.IDailyAdventureIncenseSettingsProto|null);
            public item_inventory_update_settings?: (POGOProtos.Rpc.IItemInventoryUpdateSettingsProto|null);
            public sticker_category_settings?: (POGOProtos.Rpc.IStickerCategorySettingsProto|null);
            public home_widget_settings?: (POGOProtos.Rpc.IHomeWidgetSettingsProto|null);
            public vs_seeker_schedule_settings?: (POGOProtos.Rpc.IVsSeekerScheduleSettingsProto|null);
            public pokedex_size_stats_system_settings?: (POGOProtos.Rpc.IPokedexSizeStatsSystemSettingsProto|null);
            public asset_refresh_proto?: (POGOProtos.Rpc.IAssetRefreshProto|null);
            public pokemon_fx_settings?: (POGOProtos.Rpc.IPokemonFxSettingsProto|null);
            public butterfly_collector_settings?: (POGOProtos.Rpc.IButterflyCollectorSettings|null);
            public language_settings?: (POGOProtos.Rpc.ILanguageSettingsProto|null);
            public pokemon_extended_settings?: (POGOProtos.Rpc.IPokemonExtendedSettingsProto|null);
            public primal_evo_settings?: (POGOProtos.Rpc.IPrimalEvoSettingsProto|null);
            public nia_id_migration_settings?: (POGOProtos.Rpc.INiaIdMigrationSettingsProto|null);
            public location_card_settings?: (POGOProtos.Rpc.ILocationCardSettingsProto|null);
            public conversation_settings?: (POGOProtos.Rpc.IConversationSettingsProto|null);
            public vps_event_settings?: (POGOProtos.Rpc.IVpsEventSettingsProto|null);
            public catch_radius_multiplier_settings?: (POGOProtos.Rpc.ICatchRadiusMultiplierSettingsProto|null);
            public haptics_settings?: (POGOProtos.Rpc.IHapticsSettingsProto|null);
            public raid_lobby_counter_settings?: (POGOProtos.Rpc.IRaidLobbyCounterSettingsProto|null);
            public contest_settings?: (POGOProtos.Rpc.IContestSettingsProto|null);
            public guest_account_game_settings_proto?: (POGOProtos.Rpc.IGuestAccountGameSettingsProto|null);
            public neutral_avatar_settings?: (POGOProtos.Rpc.INeutralAvatarSettingsProto|null);
            public squash_settings?: (POGOProtos.Rpc.ISquashSettingsProto|null);
            public today_view_settings?: (POGOProtos.Rpc.ITodayViewSettingsProto|null);
            public route_pin_settings?: (POGOProtos.Rpc.IRoutePinSettingsProto|null);
            public style_shop_settings?: (POGOProtos.Rpc.IStyleShopSettingsProto|null);
            public party_play_general_settings?: (POGOProtos.Rpc.IPartyPlayGeneralSettingsProto|null);
            public optimizations_proto?: (POGOProtos.Rpc.IOptimizationsProto|null);
            public nearby_pokemon_settings?: (POGOProtos.Rpc.INearbyPokemonSettings|null);
            public party_player_summary_settings?: (POGOProtos.Rpc.IPartySummarySettingsProto|null);
            public party_shared_quest_settings?: (POGOProtos.Rpc.IPartySharedQuestSettingsProto|null);
            public client_poi_decoration_group?: (POGOProtos.Rpc.IClientPoiDecorationGroupProto|null);
            public map_coord_overlay?: (POGOProtos.Rpc.IMapCoordOverlayProto|null);
            public vista_general_settings?: (POGOProtos.Rpc.IVistaGeneralSettingsProto|null);
            public route_badge_settings?: (POGOProtos.Rpc.IRouteBadgeSettingsProto|null);
            public party_dark_launch_settings?: (POGOProtos.Rpc.IPartyDarkLaunchSettingsProto|null);
            public routes_party_play_interop_settings?: (POGOProtos.Rpc.IRoutesPartyPlayInteroperabilitySettingsProto|null);
            public routes_nearby_notif_settings?: (POGOProtos.Rpc.IRoutesNearbyNotifSettingsProto|null);
            public non_combat_move_settings?: (POGOProtos.Rpc.INonCombatMoveSettingsProto|null);
            public player_bonus_system_settings?: (POGOProtos.Rpc.IPlayerBonusSystemSettingsProto|null);
            public ptc_oauth_settings?: (POGOProtos.Rpc.IPtcOAuthSettingsProto|null);
            public graphics_capabilities_settings?: (POGOProtos.Rpc.IGraphicsCapabilitiesSettingsProto|null);
            public party_iap_boosts_settings?: (POGOProtos.Rpc.IPartyIapBoostsSettingsProto|null);
            public language_bundle?: (POGOProtos.Rpc.ILanguageBundleProto|null);
            public bulk_healing_settings?: (POGOProtos.Rpc.IBulkHealingSettingsProto|null);
            public photo_sets_settings_proto?: (POGOProtos.Rpc.IPokemonPhotoSetsProto|null);
            public main_menu_camera_button_settings?: (POGOProtos.Rpc.IMainMenuCameraButtonSettingsProto|null);
            public shared_fusion_settings?: (POGOProtos.Rpc.ISharedFusionSettingsProto|null);
            public iris_social_settings?: (POGOProtos.Rpc.IIrisSocialSettingsProto|null);
            public additive_scene_settings?: (POGOProtos.Rpc.IAdditiveSceneSettingsProto|null);
            public mp_settings?: (POGOProtos.Rpc.IMpSharedSettingsProto|null);
            public bread_feature_flags?: (POGOProtos.Rpc.IBreadFeatureFlagsProto|null);
            public bread_settings?: (POGOProtos.Rpc.IBreadSharedSettingsProto|null);
            public settings_override_rule?: (POGOProtos.Rpc.ISettingsOverrideRuleProto|null);
            public save_for_later_settings?: (POGOProtos.Rpc.ISaveForLaterSettingsProto|null);
            public iris_social_ux_funnel_settings?: (POGOProtos.Rpc.IIrisSocialUserExperienceFunnelSettingsProto|null);
            public map_icon_sort_order?: (POGOProtos.Rpc.IMapIconSortOrderProto|null);
            public bread_battle_client_settings?: (POGOProtos.Rpc.IBreadBattleClientSettingsProto|null);
            public error_reporting_settings?: (POGOProtos.Rpc.IErrorReportingSettingsProto|null);
            public bread_move_level_settings?: (POGOProtos.Rpc.IBreadMoveLevelSettingsProto|null);
            public item_expiration_settings?: (POGOProtos.Rpc.IItemExpirationSettingsProto|null);
            public bread_move_mappings?: (POGOProtos.Rpc.IBreadMoveMappingSettingsProto|null);
            public station_reward_settings?: (POGOProtos.Rpc.IStationRewardSettingsProto|null);
            public stationed_pokemon_table_settings?: (POGOProtos.Rpc.IStationedPokemonTableSettingsProto|null);
            public accessibility_settings?: (POGOProtos.Rpc.IAccessibilitySettingsProto|null);
            public bread_lobby_counter_settings?: (POGOProtos.Rpc.IBreadLobbyCounterSettingsProto|null);
            public bread_pokemon_scaling_settings?: (POGOProtos.Rpc.IBreadPokemonScalingSettingsProto|null);
            public pokeball_throw_property_settings?: (POGOProtos.Rpc.IPokeballThrowPropertySettingsProto|null);
            public sourdough_move_mapping_settings?: (POGOProtos.Rpc.ISourdoughMoveMappingSettingsProto|null);
            public event_map_decoration_settings?: (POGOProtos.Rpc.IEventMapDecorationSettingsProto|null);
            public event_map_decoration_system_settings?: (POGOProtos.Rpc.IEventMapDecorationSystemSettingsProto|null);
            public pokemon_info_panel_settings?: (POGOProtos.Rpc.IPokemonInfoPanelSettingsProto|null);
            public stamp_collection_settings?: (POGOProtos.Rpc.IStampCollectionSettingsProto|null);
            public iap_store_banner?: (POGOProtos.Rpc.IIapStoreBannerProto|null);
            public avatar_item_display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            public pokedexv2_feature_flags?: (POGOProtos.Rpc.IPokedexV2FeatureFlagProto|null);
            public code_gate_proto?: (POGOProtos.Rpc.ICodeGateProto|null);
            public pokedex_v2_settings?: (POGOProtos.Rpc.IPokedexV2SettingsProto|null);
            public join_raid_via_friend_list_settings?: (POGOProtos.Rpc.IJoinRaidViaFriendListSettingsProto|null);
            public event_pass_settings?: (POGOProtos.Rpc.IEventPassSettingsProto|null);
            public event_pass_tier_settings?: (POGOProtos.Rpc.IEventPassTierSettingsProto|null);
            public smart_glasses_feature_flags?: (POGOProtos.Rpc.ISmartGlassesFeatureFlagProto|null);
            public planner_settings?: (POGOProtos.Rpc.IPlannerSettingsProto|null);
            public map_scene_feature_flags?: (POGOProtos.Rpc.IMapSceneFeatureFlagsProto|null);
            public bread_lobby_update_settings?: (POGOProtos.Rpc.IBreadLobbyUpdateSettingsProto|null);
            public anti_leak_settings?: (POGOProtos.Rpc.IAntiLeakSettingsProto|null);
            public battle_input_buffer_settings?: (POGOProtos.Rpc.IBattleInputBufferSettingsProto|null);
            public client_quest_template?: (POGOProtos.Rpc.IClientQuestProto|null);
            public event_pass_system_settings?: (POGOProtos.Rpc.IEventPassSystemSettingsProto|null);
            public pvp_next_feature_flags?: (POGOProtos.Rpc.IPvpNextFeatureFlagsProto|null);
            public neutral_avatar_mapping?: (POGOProtos.Rpc.INeutralAvatarMappingProto|null);
            public feature_gate?: (POGOProtos.Rpc.IFeatureGateProto|null);
            public roll_back?: (POGOProtos.Rpc.IRollBackProto|null);
            public ibfc_lightweight_settings?: (POGOProtos.Rpc.IIBFCLightweightSettings|null);
            public avatar_store_footer_flags?: (POGOProtos.Rpc.IAvatarStoreFooterEnabledProto|null);
            public avatar_store_subcategory_filtering_flags?: (POGOProtos.Rpc.IAvatarStoreSubcategoryFilteringEnabledProto|null);
            public two_for_one_flags?: (POGOProtos.Rpc.ITwoForOneEnabledProto|null);
            public event_planner_popular_notification_settings?: (POGOProtos.Rpc.IEventPlannerPopularNotificationSettings|null);
            public neutral_avatar_item_mapping?: (POGOProtos.Rpc.INeutralAvatarItemMappingProto|null);
            public Data?: ("pokemon"|"item"|"move"|"move_sequence"|"type_effective"|"badge"|"player_level"|"battle_settings"|"encounter_settings"|"iap_item_display"|"iap_settings"|"pokemon_upgrades"|"quest_settings"|"avatar_customization"|"form_settings"|"gender_settings"|"gym_badge_settings"|"weather_affinities"|"weather_bonus_settings"|"pokemon_scale_settings"|"iap_category_display"|"beluga_pokemon_whitelist"|"onboarding_settings"|"friendship_milestone_settings"|"lucky_pokemon_settings"|"combat_settings"|"combat_league_settings"|"combat_league"|"combat_move"|"background_mode_settings"|"combat_stat_stage_settings"|"combat_npc_trainer"|"combat_npc_personality"|"party_recommendation_settings"|"pokecoin_purchase_display_gmt"|"invasion_npc_display_settings"|"combat_competitive_season_settings"|"combat_ranking_proto_settings"|"combat_type"|"buddy_level_settings"|"buddy_activity_category_settings"|"buddy_swap_settings"|"route_creation_settings"|"vs_seeker_client_settings"|"buddy_encounter_cameo_settings"|"limited_purchase_sku_settings"|"buddy_emotion_level_settings"|"pokestop_invasion_availability_settings"|"buddy_interaction_settings"|"vs_seeker_loot_proto"|"vs_seeker_pokemon_rewards"|"battle_hub_order_settings"|"battle_hub_badge_settings"|"map_buddy_settings"|"buddy_walk_settings"|"buddy_hunger_settings"|"project_vacation"|"mega_evo_settings"|"temporary_evolution_settings"|"avatar_group_settings"|"pokemon_family"|"monodepth_settings"|"level_up_rewards"|"raid_settings_proto"|"tappable_settings"|"route_play_settings"|"sponsored_geofence_gift_settings"|"sticker_metadata"|"cross_game_social_settings"|"map_display_settings"|"pokemon_home_energy_costs"|"pokemon_home_settings"|"ar_telemetry_settings"|"battle_party_settings"|"pokemon_home_form_reversion"|"deep_linking_settings"|"gui_search_settings"|"evolution_quest_template"|"geotargeted_quest_settings"|"pokemon_tag_settings"|"recommended_search_proto"|"inventory_settings"|"route_discovery_settings"|"fort_power_up_level_settings"|"power_up_pokestops_settings"|"incident_priority_settings"|"referral_settings"|"pokedex_categories_settings"|"battle_visual_settings"|"addressable_pokemon_settings"|"verbose_log_raid_settings"|"shared_move_settings"|"address_book_import_settings"|"music_settings"|"map_objects_interaction_range_settings"|"external_addressable_assets_settings"|"username_suggestion_settings"|"tutorial_settings"|"egg_hatch_improvements_settings"|"feature_unlock_level_settings"|"in_app_survey_settings"|"incident_visibility_settings"|"postcard_collection_settings"|"verbose_log_combat_settings"|"mega_evo_level_settings"|"advanced_settings"|"impression_tracking_settings"|"garbage_collection_settings"|"evolution_chain_display_settings"|"route_stamp_category_settings"|"popup_control_settings"|"ticket_gifting_settings"|"language_selector_settings"|"gifting_settings"|"campfire_settings"|"photo_settings"|"daily_adventure_incense_settings"|"item_inventory_update_settings"|"sticker_category_settings"|"home_widget_settings"|"vs_seeker_schedule_settings"|"pokedex_size_stats_system_settings"|"asset_refresh_proto"|"pokemon_fx_settings"|"butterfly_collector_settings"|"language_settings"|"pokemon_extended_settings"|"primal_evo_settings"|"nia_id_migration_settings"|"location_card_settings"|"conversation_settings"|"vps_event_settings"|"catch_radius_multiplier_settings"|"haptics_settings"|"raid_lobby_counter_settings"|"contest_settings"|"guest_account_game_settings_proto"|"neutral_avatar_settings"|"squash_settings"|"today_view_settings"|"route_pin_settings"|"style_shop_settings"|"party_play_general_settings"|"optimizations_proto"|"nearby_pokemon_settings"|"party_player_summary_settings"|"party_shared_quest_settings"|"client_poi_decoration_group"|"map_coord_overlay"|"vista_general_settings"|"route_badge_settings"|"party_dark_launch_settings"|"routes_party_play_interop_settings"|"routes_nearby_notif_settings"|"non_combat_move_settings"|"player_bonus_system_settings"|"ptc_oauth_settings"|"graphics_capabilities_settings"|"party_iap_boosts_settings"|"language_bundle"|"bulk_healing_settings"|"photo_sets_settings_proto"|"main_menu_camera_button_settings"|"shared_fusion_settings"|"iris_social_settings"|"additive_scene_settings"|"mp_settings"|"bread_feature_flags"|"bread_settings"|"settings_override_rule"|"save_for_later_settings"|"iris_social_ux_funnel_settings"|"map_icon_sort_order"|"bread_battle_client_settings"|"error_reporting_settings"|"bread_move_level_settings"|"item_expiration_settings"|"bread_move_mappings"|"station_reward_settings"|"stationed_pokemon_table_settings"|"accessibility_settings"|"bread_lobby_counter_settings"|"bread_pokemon_scaling_settings"|"pokeball_throw_property_settings"|"sourdough_move_mapping_settings"|"event_map_decoration_settings"|"event_map_decoration_system_settings"|"pokemon_info_panel_settings"|"stamp_collection_settings"|"iap_store_banner"|"avatar_item_display"|"pokedexv2_feature_flags"|"code_gate_proto"|"pokedex_v2_settings"|"join_raid_via_friend_list_settings"|"event_pass_settings"|"event_pass_tier_settings"|"smart_glasses_feature_flags"|"planner_settings"|"map_scene_feature_flags"|"bread_lobby_update_settings"|"anti_leak_settings"|"battle_input_buffer_settings"|"client_quest_template"|"event_pass_system_settings"|"pvp_next_feature_flags"|"neutral_avatar_mapping"|"feature_gate"|"roll_back"|"ibfc_lightweight_settings"|"avatar_store_footer_flags"|"avatar_store_subcategory_filtering_flags"|"two_for_one_flags"|"event_planner_popular_notification_settings"|"neutral_avatar_item_mapping");
            public static encode(message: POGOProtos.Rpc.IGameMasterClientTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameMasterClientTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameMasterClientTemplateProto;
            public static toObject(message: POGOProtos.Rpc.GameMasterClientTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGameMasterLocalProto {
            templates?: (POGOProtos.Rpc.IGameMasterClientTemplateProto[]|null);
        }

        class GameMasterLocalProto implements IGameMasterLocalProto {
            constructor(properties?: POGOProtos.Rpc.IGameMasterLocalProto);
            public templates: POGOProtos.Rpc.IGameMasterClientTemplateProto[];
            public static encode(message: POGOProtos.Rpc.IGameMasterLocalProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameMasterLocalProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameMasterLocalProto;
            public static toObject(message: POGOProtos.Rpc.GameMasterLocalProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGameObjectLocationData {
            anchor_id?: (string|null);
            offset?: (POGOProtos.Rpc.GameObjectLocationData.IOffsetPosition|null);
            offset_rotation?: (POGOProtos.Rpc.GameObjectLocationData.IOffsetRotation|null);
        }

        class GameObjectLocationData implements IGameObjectLocationData {
            constructor(properties?: POGOProtos.Rpc.IGameObjectLocationData);
            public anchor_id: string;
            public offset?: (POGOProtos.Rpc.GameObjectLocationData.IOffsetPosition|null);
            public offset_rotation?: (POGOProtos.Rpc.GameObjectLocationData.IOffsetRotation|null);
            public static encode(message: POGOProtos.Rpc.IGameObjectLocationData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameObjectLocationData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameObjectLocationData;
            public static toObject(message: POGOProtos.Rpc.GameObjectLocationData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GameObjectLocationData {

            interface IOffsetPosition {
                offset_x?: (number|null);
                offset_y?: (number|null);
                offset_z?: (number|null);
            }

            class OffsetPosition implements IOffsetPosition {
                constructor(properties?: POGOProtos.Rpc.GameObjectLocationData.IOffsetPosition);
                public offset_x: number;
                public offset_y: number;
                public offset_z: number;
                public static encode(message: POGOProtos.Rpc.GameObjectLocationData.IOffsetPosition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameObjectLocationData.OffsetPosition;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameObjectLocationData.OffsetPosition;
                public static toObject(message: POGOProtos.Rpc.GameObjectLocationData.OffsetPosition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOffsetRotation {
                offset_w?: (number|null);
                offset_x?: (number|null);
                offset_y?: (number|null);
                offset_z?: (number|null);
            }

            class OffsetRotation implements IOffsetRotation {
                constructor(properties?: POGOProtos.Rpc.GameObjectLocationData.IOffsetRotation);
                public offset_w: number;
                public offset_x: number;
                public offset_y: number;
                public offset_z: number;
                public static encode(message: POGOProtos.Rpc.GameObjectLocationData.IOffsetRotation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameObjectLocationData.OffsetRotation;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameObjectLocationData.OffsetRotation;
                public static toObject(message: POGOProtos.Rpc.GameObjectLocationData.OffsetRotation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGameboardSettings {
            min_s2_cell_level?: (number|null);
            max_s2_cell_level?: (number|null);
            max_s2_cells_per_view?: (number|null);
            map_query_max_s2_cells_per_request?: (number|null);
            map_query_min_update_interval_ms?: (number|null);
            map_query_max_update_interval_ms?: (number|null);
        }

        class GameboardSettings implements IGameboardSettings {
            constructor(properties?: POGOProtos.Rpc.IGameboardSettings);
            public min_s2_cell_level: number;
            public max_s2_cell_level: number;
            public max_s2_cells_per_view: number;
            public map_query_max_s2_cells_per_request: number;
            public map_query_min_update_interval_ms: number;
            public map_query_max_update_interval_ms: number;
            public static encode(message: POGOProtos.Rpc.IGameboardSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameboardSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameboardSettings;
            public static toObject(message: POGOProtos.Rpc.GameboardSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGameplayWeatherProto {
            gameplay_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
        }

        class GameplayWeatherProto implements IGameplayWeatherProto {
            constructor(properties?: POGOProtos.Rpc.IGameplayWeatherProto);
            public gameplay_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public static encode(message: POGOProtos.Rpc.IGameplayWeatherProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GameplayWeatherProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GameplayWeatherProto;
            public static toObject(message: POGOProtos.Rpc.GameplayWeatherProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GameplayWeatherProto {

            enum WeatherCondition {
                NONE = 0,
                CLEAR = 1,
                RAINY = 2,
                PARTLY_CLOUDY = 3,
                OVERCAST = 4,
                WINDY = 5,
                SNOW = 6,
                FOG = 7
            }
        }

        interface IGarProxyRequestProto {
            action?: (number|null);
            payload?: (Uint8Array|null);
        }

        class GarProxyRequestProto implements IGarProxyRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGarProxyRequestProto);
            public action: number;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IGarProxyRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GarProxyRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GarProxyRequestProto;
            public static toObject(message: POGOProtos.Rpc.GarProxyRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGarProxyResponseProto {
            status?: (POGOProtos.Rpc.GarProxyResponseProto.Status|null);
            error_message?: (string|null);
            payload?: (Uint8Array|null);
        }

        class GarProxyResponseProto implements IGarProxyResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGarProxyResponseProto);
            public status: POGOProtos.Rpc.GarProxyResponseProto.Status;
            public error_message: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IGarProxyResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GarProxyResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GarProxyResponseProto;
            public static toObject(message: POGOProtos.Rpc.GarProxyResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GarProxyResponseProto {

            enum Status {
                OK = 0,
                ERROR_UNKNOWN = 2,
                ERROR_PERMISSION_DENIED = 7,
                ERROR_UNAVAILABLE = 14,
                ERROR_UNAUTHENTICATED = 16
            }
        }

        interface IGarbageCollectionSettingsProto {
            player_idle_threshold_ms?: (number|null);
            normal_unload_unused_assets_threshold?: (number|null);
            low_unload_unused_assets_threshold?: (number|null);
            extra_low_unload_unused_assets_threshold?: (number|null);
            force_unload_unused_assets_factor?: (number|null);
        }

        class GarbageCollectionSettingsProto implements IGarbageCollectionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGarbageCollectionSettingsProto);
            public player_idle_threshold_ms: number;
            public normal_unload_unused_assets_threshold: number;
            public low_unload_unused_assets_threshold: number;
            public extra_low_unload_unused_assets_threshold: number;
            public force_unload_unused_assets_factor: number;
            public static encode(message: POGOProtos.Rpc.IGarbageCollectionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GarbageCollectionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GarbageCollectionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GarbageCollectionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGcmToken {
            registration_id?: (string|null);
            client_operating_system?: (POGOProtos.Rpc.ClientOperatingSystem|null);
        }

        class GcmToken implements IGcmToken {
            constructor(properties?: POGOProtos.Rpc.IGcmToken);
            public registration_id: string;
            public client_operating_system: POGOProtos.Rpc.ClientOperatingSystem;
            public static encode(message: POGOProtos.Rpc.IGcmToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GcmToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GcmToken;
            public static toObject(message: POGOProtos.Rpc.GcmToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGenerateCombatChallengeIdData {
            rpc_id?: (number|null);
        }

        class GenerateCombatChallengeIdData implements IGenerateCombatChallengeIdData {
            constructor(properties?: POGOProtos.Rpc.IGenerateCombatChallengeIdData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IGenerateCombatChallengeIdData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenerateCombatChallengeIdData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenerateCombatChallengeIdData;
            public static toObject(message: POGOProtos.Rpc.GenerateCombatChallengeIdData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGenerateCombatChallengeIdOutProto {
            result?: (POGOProtos.Rpc.GenerateCombatChallengeIdOutProto.Result|null);
            challenge_id?: (string|null);
        }

        class GenerateCombatChallengeIdOutProto implements IGenerateCombatChallengeIdOutProto {
            constructor(properties?: POGOProtos.Rpc.IGenerateCombatChallengeIdOutProto);
            public result: POGOProtos.Rpc.GenerateCombatChallengeIdOutProto.Result;
            public challenge_id: string;
            public static encode(message: POGOProtos.Rpc.IGenerateCombatChallengeIdOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenerateCombatChallengeIdOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenerateCombatChallengeIdOutProto;
            public static toObject(message: POGOProtos.Rpc.GenerateCombatChallengeIdOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GenerateCombatChallengeIdOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 2,
                ERROR_ACCESS_DENIED = 3
            }
        }

        interface IGenerateCombatChallengeIdProto {
        }

        class GenerateCombatChallengeIdProto implements IGenerateCombatChallengeIdProto {
            constructor(properties?: POGOProtos.Rpc.IGenerateCombatChallengeIdProto);
            public static encode(message: POGOProtos.Rpc.IGenerateCombatChallengeIdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenerateCombatChallengeIdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenerateCombatChallengeIdProto;
            public static toObject(message: POGOProtos.Rpc.GenerateCombatChallengeIdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGenerateCombatChallengeIdResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.GenerateCombatChallengeIdOutProto.Result|null);
        }

        class GenerateCombatChallengeIdResponseData implements IGenerateCombatChallengeIdResponseData {
            constructor(properties?: POGOProtos.Rpc.IGenerateCombatChallengeIdResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.GenerateCombatChallengeIdOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IGenerateCombatChallengeIdResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenerateCombatChallengeIdResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenerateCombatChallengeIdResponseData;
            public static toObject(message: POGOProtos.Rpc.GenerateCombatChallengeIdResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGenerateGmapSignedUrlOutProto {
            result?: (POGOProtos.Rpc.GenerateGmapSignedUrlOutProto.Result|null);
            signed_url?: (string|null);
        }

        class GenerateGmapSignedUrlOutProto implements IGenerateGmapSignedUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IGenerateGmapSignedUrlOutProto);
            public result: POGOProtos.Rpc.GenerateGmapSignedUrlOutProto.Result;
            public signed_url: string;
            public static encode(message: POGOProtos.Rpc.IGenerateGmapSignedUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenerateGmapSignedUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenerateGmapSignedUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.GenerateGmapSignedUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GenerateGmapSignedUrlOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_VALID = 2,
                ERROR_RATE_LIMITED = 3,
                ERROR_MISSING_INPUT = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IGenerateGmapSignedUrlProto {
            latitude?: (number|null);
            longitude?: (number|null);
            width?: (number|null);
            height?: (number|null);
            zoom?: (number|null);
            language_code?: (string|null);
            country_code?: (string|null);
            map_style?: (string|null);
            map_type?: (string|null);
            icon_params?: (string|null);
        }

        class GenerateGmapSignedUrlProto implements IGenerateGmapSignedUrlProto {
            constructor(properties?: POGOProtos.Rpc.IGenerateGmapSignedUrlProto);
            public latitude: number;
            public longitude: number;
            public width: number;
            public height: number;
            public zoom: number;
            public language_code: string;
            public country_code: string;
            public map_style: string;
            public map_type: string;
            public icon_params: string;
            public static encode(message: POGOProtos.Rpc.IGenerateGmapSignedUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenerateGmapSignedUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenerateGmapSignedUrlProto;
            public static toObject(message: POGOProtos.Rpc.GenerateGmapSignedUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeneratedCodeInfo {
        }

        class GeneratedCodeInfo implements IGeneratedCodeInfo {
            constructor(properties?: POGOProtos.Rpc.IGeneratedCodeInfo);
            public static encode(message: POGOProtos.Rpc.IGeneratedCodeInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeneratedCodeInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeneratedCodeInfo;
            public static toObject(message: POGOProtos.Rpc.GeneratedCodeInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GeneratedCodeInfo {

            interface IAnnotation {
                source_file?: (string|null);
                begin?: (number|null);
                end?: (number|null);
            }

            class Annotation implements IAnnotation {
                constructor(properties?: POGOProtos.Rpc.GeneratedCodeInfo.IAnnotation);
                public source_file: string;
                public begin: number;
                public end: number;
                public static encode(message: POGOProtos.Rpc.GeneratedCodeInfo.IAnnotation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeneratedCodeInfo.Annotation;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeneratedCodeInfo.Annotation;
                public static toObject(message: POGOProtos.Rpc.GeneratedCodeInfo.Annotation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGenericClickTelemetry {
            generic_click_id?: (POGOProtos.Rpc.GenericClickTelemetryIds|null);
        }

        class GenericClickTelemetry implements IGenericClickTelemetry {
            constructor(properties?: POGOProtos.Rpc.IGenericClickTelemetry);
            public generic_click_id: POGOProtos.Rpc.GenericClickTelemetryIds;
            public static encode(message: POGOProtos.Rpc.IGenericClickTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GenericClickTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GenericClickTelemetry;
            public static toObject(message: POGOProtos.Rpc.GenericClickTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeoAssociation {
            rotation?: (POGOProtos.Rpc.IQuaternion|null);
            latitude_degrees?: (number|null);
            longitude_degrees?: (number|null);
            altitude_metres?: (number|null);
            placement_accuracy?: (POGOProtos.Rpc.IPlacementAccuracy|null);
        }

        class GeoAssociation implements IGeoAssociation {
            constructor(properties?: POGOProtos.Rpc.IGeoAssociation);
            public rotation?: (POGOProtos.Rpc.IQuaternion|null);
            public latitude_degrees: number;
            public longitude_degrees: number;
            public altitude_metres: number;
            public placement_accuracy?: (POGOProtos.Rpc.IPlacementAccuracy|null);
            public static encode(message: POGOProtos.Rpc.IGeoAssociation, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeoAssociation;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeoAssociation;
            public static toObject(message: POGOProtos.Rpc.GeoAssociation, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeofenceMetadata {
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
            radius?: (number|null);
            identifier?: (string|null);
            expiration_ms?: (number|Long|null);
            dwell_time_ms?: (number|Long|null);
            fire_on_entrance?: (boolean|null);
            fire_on_exit?: (boolean|null);
        }

        class GeofenceMetadata implements IGeofenceMetadata {
            constructor(properties?: POGOProtos.Rpc.IGeofenceMetadata);
            public latitude_deg: number;
            public longitude_deg: number;
            public radius: number;
            public identifier: string;
            public expiration_ms: (number|Long);
            public dwell_time_ms: (number|Long);
            public fire_on_entrance: boolean;
            public fire_on_exit: boolean;
            public static encode(message: POGOProtos.Rpc.IGeofenceMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeofenceMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeofenceMetadata;
            public static toObject(message: POGOProtos.Rpc.GeofenceMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeofenceUpdateOutProto {
            geofence?: (POGOProtos.Rpc.IGeofenceMetadata[]|null);
        }

        class GeofenceUpdateOutProto implements IGeofenceUpdateOutProto {
            constructor(properties?: POGOProtos.Rpc.IGeofenceUpdateOutProto);
            public geofence: POGOProtos.Rpc.IGeofenceMetadata[];
            public static encode(message: POGOProtos.Rpc.IGeofenceUpdateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeofenceUpdateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeofenceUpdateOutProto;
            public static toObject(message: POGOProtos.Rpc.GeofenceUpdateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeofenceUpdateProto {
            number_of_points?: (number|null);
            minimum_point_radius_m?: (number|null);
        }

        class GeofenceUpdateProto implements IGeofenceUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IGeofenceUpdateProto);
            public number_of_points: number;
            public minimum_point_radius_m: number;
            public static encode(message: POGOProtos.Rpc.IGeofenceUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeofenceUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeofenceUpdateProto;
            public static toObject(message: POGOProtos.Rpc.GeofenceUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeometry {
            points?: (POGOProtos.Rpc.IPointList|null);
            polylines?: (POGOProtos.Rpc.IPolylineList|null);
            triangles?: (POGOProtos.Rpc.ITriangleList|null);
        }

        class Geometry implements IGeometry {
            constructor(properties?: POGOProtos.Rpc.IGeometry);
            public points?: (POGOProtos.Rpc.IPointList|null);
            public polylines?: (POGOProtos.Rpc.IPolylineList|null);
            public triangles?: (POGOProtos.Rpc.ITriangleList|null);
            public Geometry?: ("points"|"polylines"|"triangles");
            public static encode(message: POGOProtos.Rpc.IGeometry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Geometry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Geometry;
            public static toObject(message: POGOProtos.Rpc.Geometry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeotargetedQuestProto {
            name?: (string|null);
            call_to_action_link?: (string|null);
            image_url?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            fort_id?: (string|null);
        }

        class GeotargetedQuestProto implements IGeotargetedQuestProto {
            constructor(properties?: POGOProtos.Rpc.IGeotargetedQuestProto);
            public name: string;
            public call_to_action_link: string;
            public image_url: string;
            public latitude: number;
            public longitude: number;
            public fort_id: string;
            public static encode(message: POGOProtos.Rpc.IGeotargetedQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeotargetedQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeotargetedQuestProto;
            public static toObject(message: POGOProtos.Rpc.GeotargetedQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeotargetedQuestSettingsProto {
            enable_geotargeted_quests?: (boolean|null);
        }

        class GeotargetedQuestSettingsProto implements IGeotargetedQuestSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGeotargetedQuestSettingsProto);
            public enable_geotargeted_quests: boolean;
            public static encode(message: POGOProtos.Rpc.IGeotargetedQuestSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeotargetedQuestSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeotargetedQuestSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GeotargetedQuestSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGeotargetedQuestValidation {
            fort_id?: (string|null);
        }

        class GeotargetedQuestValidation implements IGeotargetedQuestValidation {
            constructor(properties?: POGOProtos.Rpc.IGeotargetedQuestValidation);
            public fort_id: string;
            public static encode(message: POGOProtos.Rpc.IGeotargetedQuestValidation, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GeotargetedQuestValidation;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GeotargetedQuestValidation;
            public static toObject(message: POGOProtos.Rpc.GeotargetedQuestValidation, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetActionLogRequest {
        }

        class GetActionLogRequest implements IGetActionLogRequest {
            constructor(properties?: POGOProtos.Rpc.IGetActionLogRequest);
            public static encode(message: POGOProtos.Rpc.IGetActionLogRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetActionLogRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetActionLogRequest;
            public static toObject(message: POGOProtos.Rpc.GetActionLogRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetActionLogResponse {
            result?: (POGOProtos.Rpc.GetActionLogResponse.Result|null);
            log?: (POGOProtos.Rpc.IActionLogEntry[]|null);
        }

        class GetActionLogResponse implements IGetActionLogResponse {
            constructor(properties?: POGOProtos.Rpc.IGetActionLogResponse);
            public result: POGOProtos.Rpc.GetActionLogResponse.Result;
            public log: POGOProtos.Rpc.IActionLogEntry[];
            public static encode(message: POGOProtos.Rpc.IGetActionLogResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetActionLogResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetActionLogResponse;
            public static toObject(message: POGOProtos.Rpc.GetActionLogResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetActionLogResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IGetAdditionalPokemonDetailsOutProto {
            origin_party_nicknames?: (string[]|null);
            fusion_detail?: (POGOProtos.Rpc.IFusionPokemonDetailsProto|null);
            component_detail?: (POGOProtos.Rpc.IComponentPokemonDetailsProto|null);
            training_quests?: (POGOProtos.Rpc.IPokemonTrainingQuestProto|null);
        }

        class GetAdditionalPokemonDetailsOutProto implements IGetAdditionalPokemonDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdditionalPokemonDetailsOutProto);
            public origin_party_nicknames: string[];
            public fusion_detail?: (POGOProtos.Rpc.IFusionPokemonDetailsProto|null);
            public component_detail?: (POGOProtos.Rpc.IComponentPokemonDetailsProto|null);
            public training_quests?: (POGOProtos.Rpc.IPokemonTrainingQuestProto|null);
            public static encode(message: POGOProtos.Rpc.IGetAdditionalPokemonDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdditionalPokemonDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdditionalPokemonDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetAdditionalPokemonDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAdditionalPokemonDetailsProto {
            id?: (number|Long|null);
        }

        class GetAdditionalPokemonDetailsProto implements IGetAdditionalPokemonDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdditionalPokemonDetailsProto);
            public id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetAdditionalPokemonDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdditionalPokemonDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdditionalPokemonDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetAdditionalPokemonDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAdventureSyncFitnessReportRequestProto {
            num_of_days?: (number|null);
            num_of_weeks?: (number|null);
        }

        class GetAdventureSyncFitnessReportRequestProto implements IGetAdventureSyncFitnessReportRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdventureSyncFitnessReportRequestProto);
            public num_of_days: number;
            public num_of_weeks: number;
            public static encode(message: POGOProtos.Rpc.IGetAdventureSyncFitnessReportRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdventureSyncFitnessReportRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdventureSyncFitnessReportRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetAdventureSyncFitnessReportRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAdventureSyncFitnessReportResponseProto {
            status?: (POGOProtos.Rpc.GetAdventureSyncFitnessReportResponseProto.Status|null);
            daily_reports?: (POGOProtos.Rpc.IFitnessReportProto[]|null);
            weekly_reports?: (POGOProtos.Rpc.IFitnessReportProto[]|null);
            week_reset_timestamp_since_monday_ms?: (number|Long|null);
        }

        class GetAdventureSyncFitnessReportResponseProto implements IGetAdventureSyncFitnessReportResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdventureSyncFitnessReportResponseProto);
            public status: POGOProtos.Rpc.GetAdventureSyncFitnessReportResponseProto.Status;
            public daily_reports: POGOProtos.Rpc.IFitnessReportProto[];
            public weekly_reports: POGOProtos.Rpc.IFitnessReportProto[];
            public week_reset_timestamp_since_monday_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetAdventureSyncFitnessReportResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdventureSyncFitnessReportResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdventureSyncFitnessReportResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetAdventureSyncFitnessReportResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetAdventureSyncFitnessReportResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_FOUND = 2,
                ERROR_RECORDS_NOT_FOUND = 3,
                ERROR_INVALID_WINDOW = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IGetAdventureSyncProgressOutProto {
            status?: (POGOProtos.Rpc.GetAdventureSyncProgressOutProto.Status|null);
            progress?: (POGOProtos.Rpc.IAdventureSyncProgress|null);
        }

        class GetAdventureSyncProgressOutProto implements IGetAdventureSyncProgressOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdventureSyncProgressOutProto);
            public status: POGOProtos.Rpc.GetAdventureSyncProgressOutProto.Status;
            public progress?: (POGOProtos.Rpc.IAdventureSyncProgress|null);
            public static encode(message: POGOProtos.Rpc.IGetAdventureSyncProgressOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdventureSyncProgressOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdventureSyncProgressOutProto;
            public static toObject(message: POGOProtos.Rpc.GetAdventureSyncProgressOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetAdventureSyncProgressOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                DISABLED = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IGetAdventureSyncProgressProto {
            request?: (Uint8Array|null);
        }

        class GetAdventureSyncProgressProto implements IGetAdventureSyncProgressProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdventureSyncProgressProto);
            public request: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IGetAdventureSyncProgressProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdventureSyncProgressProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdventureSyncProgressProto;
            public static toObject(message: POGOProtos.Rpc.GetAdventureSyncProgressProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAdventureSyncSettingsRequestProto {
        }

        class GetAdventureSyncSettingsRequestProto implements IGetAdventureSyncSettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdventureSyncSettingsRequestProto);
            public static encode(message: POGOProtos.Rpc.IGetAdventureSyncSettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdventureSyncSettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdventureSyncSettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetAdventureSyncSettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAdventureSyncSettingsResponseProto {
            status?: (POGOProtos.Rpc.GetAdventureSyncSettingsResponseProto.Status|null);
            adventure_sync_settings?: (POGOProtos.Rpc.IAdventureSyncSettingsProto|null);
        }

        class GetAdventureSyncSettingsResponseProto implements IGetAdventureSyncSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetAdventureSyncSettingsResponseProto);
            public status: POGOProtos.Rpc.GetAdventureSyncSettingsResponseProto.Status;
            public adventure_sync_settings?: (POGOProtos.Rpc.IAdventureSyncSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IGetAdventureSyncSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAdventureSyncSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAdventureSyncSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetAdventureSyncSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetAdventureSyncSettingsResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IGetAppRequestTokenRedirectURLPlatformRequestProto {
            service?: (string|null);
            state?: (string|null);
            refresh_token_required?: (boolean|null);
            continue_url?: (string|null);
        }

        class GetAppRequestTokenRedirectURLPlatformRequestProto implements IGetAppRequestTokenRedirectURLPlatformRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetAppRequestTokenRedirectURLPlatformRequestProto);
            public service: string;
            public state: string;
            public refresh_token_required: boolean;
            public continue_url: string;
            public static encode(message: POGOProtos.Rpc.IGetAppRequestTokenRedirectURLPlatformRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAppRequestTokenRedirectURLPlatformResponseProto {
            status?: (POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformResponseProto.Status|null);
            redirect_url?: (string|null);
        }

        class GetAppRequestTokenRedirectURLPlatformResponseProto implements IGetAppRequestTokenRedirectURLPlatformResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetAppRequestTokenRedirectURLPlatformResponseProto);
            public status: POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformResponseProto.Status;
            public redirect_url: string;
            public static encode(message: POGOProtos.Rpc.IGetAppRequestTokenRedirectURLPlatformResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetAppRequestTokenRedirectURLPlatformResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetAppRequestTokenRedirectURLPlatformResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                INVALID_REQUEST = 3,
                UNKNOWN = 4
            }
        }

        interface IGetAvailableSubmissionsOutProto {
            submissions_left?: (number|null);
            min_player_level?: (number|null);
            has_valid_email?: (boolean|null);
            is_feature_enabled?: (boolean|null);
            time_window_for_submissions_limit_ms?: (number|Long|null);
        }

        class GetAvailableSubmissionsOutProto implements IGetAvailableSubmissionsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetAvailableSubmissionsOutProto);
            public submissions_left: number;
            public min_player_level: number;
            public has_valid_email: boolean;
            public is_feature_enabled: boolean;
            public time_window_for_submissions_limit_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetAvailableSubmissionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAvailableSubmissionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAvailableSubmissionsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetAvailableSubmissionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetAvailableSubmissionsProto {
        }

        class GetAvailableSubmissionsProto implements IGetAvailableSubmissionsProto {
            constructor(properties?: POGOProtos.Rpc.IGetAvailableSubmissionsProto);
            public static encode(message: POGOProtos.Rpc.IGetAvailableSubmissionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetAvailableSubmissionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetAvailableSubmissionsProto;
            public static toObject(message: POGOProtos.Rpc.GetAvailableSubmissionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBackgroundModeSettingsOutProto {
            status?: (POGOProtos.Rpc.GetBackgroundModeSettingsOutProto.Status|null);
            settings?: (POGOProtos.Rpc.IBackgroundModeClientSettingsProto|null);
        }

        class GetBackgroundModeSettingsOutProto implements IGetBackgroundModeSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetBackgroundModeSettingsOutProto);
            public status: POGOProtos.Rpc.GetBackgroundModeSettingsOutProto.Status;
            public settings?: (POGOProtos.Rpc.IBackgroundModeClientSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IGetBackgroundModeSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBackgroundModeSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBackgroundModeSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetBackgroundModeSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetBackgroundModeSettingsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IGetBackgroundModeSettingsProto {
        }

        class GetBackgroundModeSettingsProto implements IGetBackgroundModeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGetBackgroundModeSettingsProto);
            public static encode(message: POGOProtos.Rpc.IGetBackgroundModeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBackgroundModeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBackgroundModeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GetBackgroundModeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBonusAttractedPokemonOutProto {
            result?: (POGOProtos.Rpc.GetBonusAttractedPokemonOutProto.Status|null);
            bonus_attracted_pokemon?: (POGOProtos.Rpc.IAttractedPokemonClientProto[]|null);
        }

        class GetBonusAttractedPokemonOutProto implements IGetBonusAttractedPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetBonusAttractedPokemonOutProto);
            public result: POGOProtos.Rpc.GetBonusAttractedPokemonOutProto.Status;
            public bonus_attracted_pokemon: POGOProtos.Rpc.IAttractedPokemonClientProto[];
            public static encode(message: POGOProtos.Rpc.IGetBonusAttractedPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBonusAttractedPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBonusAttractedPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.GetBonusAttractedPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetBonusAttractedPokemonOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IGetBonusAttractedPokemonProto {
        }

        class GetBonusAttractedPokemonProto implements IGetBonusAttractedPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IGetBonusAttractedPokemonProto);
            public static encode(message: POGOProtos.Rpc.IGetBonusAttractedPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBonusAttractedPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBonusAttractedPokemonProto;
            public static toObject(message: POGOProtos.Rpc.GetBonusAttractedPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBonusesOutProto {
            result?: (POGOProtos.Rpc.GetBonusesOutProto.Result|null);
            bonus_boxes?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
        }

        class GetBonusesOutProto implements IGetBonusesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetBonusesOutProto);
            public result: POGOProtos.Rpc.GetBonusesOutProto.Result;
            public bonus_boxes: POGOProtos.Rpc.IBonusBoxProto[];
            public static encode(message: POGOProtos.Rpc.IGetBonusesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBonusesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBonusesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetBonusesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetBonusesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NO_LOCATION = 2
            }
        }

        interface IGetBonusesProto {
        }

        class GetBonusesProto implements IGetBonusesProto {
            constructor(properties?: POGOProtos.Rpc.IGetBonusesProto);
            public static encode(message: POGOProtos.Rpc.IGetBonusesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBonusesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBonusesProto;
            public static toObject(message: POGOProtos.Rpc.GetBonusesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBreadLobbyDetailsOutProto {
            bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            result?: (POGOProtos.Rpc.GetBreadLobbyDetailsOutProto.Result|null);
            display_high_user_warning?: (boolean|null);
            num_friend_invites_remaining?: (number|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            player_can_join_bread_lobby?: (boolean|null);
            bread_battle_detail?: (POGOProtos.Rpc.IBreadBattleDetailProto|null);
            num_players_in_bread_lobby?: (number|null);
            power_crystal_used?: (boolean|null);
            bread_lobby_creation_ms?: (number|Long|null);
            bread_lobby_join_end_ms?: (number|Long|null);
            received_rewards?: (boolean|null);
            rvn_battle_completed?: (boolean|null);
            rvn_battle_flushed?: (boolean|null);
            rvn_battle_is_victory?: (boolean|null);
            concurrent_player_boost_level?: (number|null);
            server_timestamp_ms?: (number|Long|null);
            is_fully_completed?: (boolean|null);
            remote_ticket_used?: (boolean|null);
        }

        class GetBreadLobbyDetailsOutProto implements IGetBreadLobbyDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetBreadLobbyDetailsOutProto);
            public bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            public result: POGOProtos.Rpc.GetBreadLobbyDetailsOutProto.Result;
            public display_high_user_warning: boolean;
            public num_friend_invites_remaining: number;
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public player_can_join_bread_lobby: boolean;
            public bread_battle_detail?: (POGOProtos.Rpc.IBreadBattleDetailProto|null);
            public num_players_in_bread_lobby: number;
            public power_crystal_used: boolean;
            public bread_lobby_creation_ms: (number|Long);
            public bread_lobby_join_end_ms: (number|Long);
            public received_rewards: boolean;
            public rvn_battle_completed: boolean;
            public rvn_battle_flushed: boolean;
            public rvn_battle_is_victory: boolean;
            public concurrent_player_boost_level: number;
            public server_timestamp_ms: (number|Long);
            public is_fully_completed: boolean;
            public remote_ticket_used: boolean;
            public static encode(message: POGOProtos.Rpc.IGetBreadLobbyDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBreadLobbyDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBreadLobbyDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetBreadLobbyDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetBreadLobbyDetailsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_BREAD_BATTLE_COMPLETED = 3,
                ERROR_BREAD_BATTLE_UNAVAILABLE = 4,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 5,
                ERROR_STATION_INACCESSIBLE = 6
            }
        }

        interface IGetBreadLobbyDetailsProto {
            bread_battle_seed?: (number|Long|null);
            station_id?: (string|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
            bread_battle_entry_point?: (POGOProtos.Rpc.BreadBattleEntryPoint|null);
            inviter_id?: (string|null);
        }

        class GetBreadLobbyDetailsProto implements IGetBreadLobbyDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetBreadLobbyDetailsProto);
            public bread_battle_seed: (number|Long);
            public station_id: string;
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public bread_battle_entry_point: POGOProtos.Rpc.BreadBattleEntryPoint;
            public inviter_id: string;
            public static encode(message: POGOProtos.Rpc.IGetBreadLobbyDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBreadLobbyDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBreadLobbyDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetBreadLobbyDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBuddyHistoryOutProto {
            result?: (POGOProtos.Rpc.GetBuddyHistoryOutProto.Result|null);
            buddy_history?: (POGOProtos.Rpc.IBuddyHistoryData[]|null);
        }

        class GetBuddyHistoryOutProto implements IGetBuddyHistoryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetBuddyHistoryOutProto);
            public result: POGOProtos.Rpc.GetBuddyHistoryOutProto.Result;
            public buddy_history: POGOProtos.Rpc.IBuddyHistoryData[];
            public static encode(message: POGOProtos.Rpc.IGetBuddyHistoryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBuddyHistoryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBuddyHistoryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetBuddyHistoryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetBuddyHistoryOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IGetBuddyHistoryProto {
        }

        class GetBuddyHistoryProto implements IGetBuddyHistoryProto {
            constructor(properties?: POGOProtos.Rpc.IGetBuddyHistoryProto);
            public static encode(message: POGOProtos.Rpc.IGetBuddyHistoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBuddyHistoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBuddyHistoryProto;
            public static toObject(message: POGOProtos.Rpc.GetBuddyHistoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBuddyWalkedOutProto {
            success?: (boolean|null);
            family_candy_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            candy_earned_count?: (number|null);
            km_remaining?: (number|null);
            last_km_awarded?: (number|null);
            mega_energy_earned_count?: (number|null);
            mega_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            xl_candy?: (number|null);
            awarded_loot?: (POGOProtos.Rpc.ILootProto|null);
            mega_pokemon_energy_awards?: (POGOProtos.Rpc.IBuddyWalkedMegaEnergyProto[]|null);
        }

        class GetBuddyWalkedOutProto implements IGetBuddyWalkedOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetBuddyWalkedOutProto);
            public success: boolean;
            public family_candy_id: POGOProtos.Rpc.HoloPokemonFamilyId;
            public candy_earned_count: number;
            public km_remaining: number;
            public last_km_awarded: number;
            public mega_energy_earned_count: number;
            public mega_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public xl_candy: number;
            public awarded_loot?: (POGOProtos.Rpc.ILootProto|null);
            public mega_pokemon_energy_awards: POGOProtos.Rpc.IBuddyWalkedMegaEnergyProto[];
            public static encode(message: POGOProtos.Rpc.IGetBuddyWalkedOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBuddyWalkedOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBuddyWalkedOutProto;
            public static toObject(message: POGOProtos.Rpc.GetBuddyWalkedOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetBuddyWalkedProto {
            buddy_home_widget_active?: (boolean|null);
        }

        class GetBuddyWalkedProto implements IGetBuddyWalkedProto {
            constructor(properties?: POGOProtos.Rpc.IGetBuddyWalkedProto);
            public buddy_home_widget_active: boolean;
            public static encode(message: POGOProtos.Rpc.IGetBuddyWalkedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetBuddyWalkedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetBuddyWalkedProto;
            public static toObject(message: POGOProtos.Rpc.GetBuddyWalkedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetChangePokemonFormPreviewRequestProto {
            pokemon_id?: (number|Long|null);
            target_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class GetChangePokemonFormPreviewRequestProto implements IGetChangePokemonFormPreviewRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetChangePokemonFormPreviewRequestProto);
            public pokemon_id: (number|Long);
            public target_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IGetChangePokemonFormPreviewRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetChangePokemonFormPreviewRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetChangePokemonFormPreviewRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetChangePokemonFormPreviewRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetChangePokemonFormPreviewResponseProto {
            result?: (POGOProtos.Rpc.ChangePokemonFormOutProto.Result|null);
            changed_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class GetChangePokemonFormPreviewResponseProto implements IGetChangePokemonFormPreviewResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetChangePokemonFormPreviewResponseProto);
            public result: POGOProtos.Rpc.ChangePokemonFormOutProto.Result;
            public changed_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IGetChangePokemonFormPreviewResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetChangePokemonFormPreviewResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetChangePokemonFormPreviewResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetChangePokemonFormPreviewResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatChallengeData {
            rpc_id?: (number|null);
        }

        class GetCombatChallengeData implements IGetCombatChallengeData {
            constructor(properties?: POGOProtos.Rpc.IGetCombatChallengeData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IGetCombatChallengeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatChallengeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatChallengeData;
            public static toObject(message: POGOProtos.Rpc.GetCombatChallengeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatChallengeOutProto {
            result?: (POGOProtos.Rpc.GetCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
        }

        class GetCombatChallengeOutProto implements IGetCombatChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetCombatChallengeOutProto);
            public result: POGOProtos.Rpc.GetCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public static encode(message: POGOProtos.Rpc.IGetCombatChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.GetCombatChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetCombatChallengeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_CHALLENGE_NOT_FOUND = 2
            }
        }

        interface IGetCombatChallengeProto {
            challenge_id?: (string|null);
        }

        class GetCombatChallengeProto implements IGetCombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.IGetCombatChallengeProto);
            public challenge_id: string;
            public static encode(message: POGOProtos.Rpc.IGetCombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.GetCombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatChallengeResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.GetCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
        }

        class GetCombatChallengeResponseData implements IGetCombatChallengeResponseData {
            constructor(properties?: POGOProtos.Rpc.IGetCombatChallengeResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.GetCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
            public static encode(message: POGOProtos.Rpc.IGetCombatChallengeResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatChallengeResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatChallengeResponseData;
            public static toObject(message: POGOProtos.Rpc.GetCombatChallengeResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatPlayerProfileData {
            rpc_id?: (number|null);
        }

        class GetCombatPlayerProfileData implements IGetCombatPlayerProfileData {
            constructor(properties?: POGOProtos.Rpc.IGetCombatPlayerProfileData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IGetCombatPlayerProfileData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatPlayerProfileData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatPlayerProfileData;
            public static toObject(message: POGOProtos.Rpc.GetCombatPlayerProfileData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatPlayerProfileOutProto {
            result?: (POGOProtos.Rpc.GetCombatPlayerProfileOutProto.Result|null);
            profile?: (POGOProtos.Rpc.ICombatPlayerProfileProto|null);
            calling_player_eligible_leagues?: (string[]|null);
        }

        class GetCombatPlayerProfileOutProto implements IGetCombatPlayerProfileOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetCombatPlayerProfileOutProto);
            public result: POGOProtos.Rpc.GetCombatPlayerProfileOutProto.Result;
            public profile?: (POGOProtos.Rpc.ICombatPlayerProfileProto|null);
            public calling_player_eligible_leagues: string[];
            public static encode(message: POGOProtos.Rpc.IGetCombatPlayerProfileOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatPlayerProfileOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatPlayerProfileOutProto;
            public static toObject(message: POGOProtos.Rpc.GetCombatPlayerProfileOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetCombatPlayerProfileOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_FOUND = 2,
                ERROR_ACCESS_DENIED = 3
            }
        }

        interface IGetCombatPlayerProfileProto {
            player_id?: (string|null);
        }

        class GetCombatPlayerProfileProto implements IGetCombatPlayerProfileProto {
            constructor(properties?: POGOProtos.Rpc.IGetCombatPlayerProfileProto);
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.IGetCombatPlayerProfileProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatPlayerProfileProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatPlayerProfileProto;
            public static toObject(message: POGOProtos.Rpc.GetCombatPlayerProfileProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatPlayerProfileResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.GetCombatPlayerProfileOutProto.Result|null);
        }

        class GetCombatPlayerProfileResponseData implements IGetCombatPlayerProfileResponseData {
            constructor(properties?: POGOProtos.Rpc.IGetCombatPlayerProfileResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.GetCombatPlayerProfileOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IGetCombatPlayerProfileResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatPlayerProfileResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatPlayerProfileResponseData;
            public static toObject(message: POGOProtos.Rpc.GetCombatPlayerProfileResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetCombatResultsOutProto {
            result?: (POGOProtos.Rpc.GetCombatResultsOutProto.Result|null);
            reward_status?: (POGOProtos.Rpc.CombatRewardStatus|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            friend_level_up?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            number_rewarded_battles_today?: (number|null);
            combat_player_finish_state?: (POGOProtos.Rpc.CombatPlayerFinishState|null);
            combat_rematch?: (POGOProtos.Rpc.GetCombatResultsOutProto.ICombatRematchProto|null);
        }

        class GetCombatResultsOutProto implements IGetCombatResultsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetCombatResultsOutProto);
            public result: POGOProtos.Rpc.GetCombatResultsOutProto.Result;
            public reward_status: POGOProtos.Rpc.CombatRewardStatus;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public friend_level_up?: (POGOProtos.Rpc.ILeveledUpFriendsProto|null);
            public number_rewarded_battles_today: number;
            public combat_player_finish_state: POGOProtos.Rpc.CombatPlayerFinishState;
            public combat_rematch?: (POGOProtos.Rpc.GetCombatResultsOutProto.ICombatRematchProto|null);
            public static encode(message: POGOProtos.Rpc.IGetCombatResultsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatResultsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatResultsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetCombatResultsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetCombatResultsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_COMBAT_STATE = 2,
                ERROR_COMBAT_NOT_FOUND = 3,
                ERROR_PLAYER_QUIT = 4
            }

            interface ICombatRematchProto {
                combat_rematch_id?: (string|null);
                combat_league_template_id?: (string|null);
            }

            class CombatRematchProto implements ICombatRematchProto {
                constructor(properties?: POGOProtos.Rpc.GetCombatResultsOutProto.ICombatRematchProto);
                public combat_rematch_id: string;
                public combat_league_template_id: string;
                public static encode(message: POGOProtos.Rpc.GetCombatResultsOutProto.ICombatRematchProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatResultsOutProto.CombatRematchProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatResultsOutProto.CombatRematchProto;
                public static toObject(message: POGOProtos.Rpc.GetCombatResultsOutProto.CombatRematchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetCombatResultsProto {
            combat_id?: (string|null);
        }

        class GetCombatResultsProto implements IGetCombatResultsProto {
            constructor(properties?: POGOProtos.Rpc.IGetCombatResultsProto);
            public combat_id: string;
            public static encode(message: POGOProtos.Rpc.IGetCombatResultsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetCombatResultsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetCombatResultsProto;
            public static toObject(message: POGOProtos.Rpc.GetCombatResultsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetContestDataOutProto {
            status?: (POGOProtos.Rpc.GetContestDataOutProto.Status|null);
            contest_incident?: (POGOProtos.Rpc.IClientContestIncidentProto|null);
        }

        class GetContestDataOutProto implements IGetContestDataOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestDataOutProto);
            public status: POGOProtos.Rpc.GetContestDataOutProto.Status;
            public contest_incident?: (POGOProtos.Rpc.IClientContestIncidentProto|null);
            public static encode(message: POGOProtos.Rpc.IGetContestDataOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestDataOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestDataOutProto;
            public static toObject(message: POGOProtos.Rpc.GetContestDataOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetContestDataOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_FORT_ID_INVALID = 2,
                ERROR_NOT_CONTEST_POI = 3,
                ERROR_CHEATING_DETECTED = 4
            }
        }

        interface IGetContestDataProto {
            fort_id?: (string|null);
        }

        class GetContestDataProto implements IGetContestDataProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestDataProto);
            public fort_id: string;
            public static encode(message: POGOProtos.Rpc.IGetContestDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestDataProto;
            public static toObject(message: POGOProtos.Rpc.GetContestDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetContestEntryOutProto {
            status?: (POGOProtos.Rpc.GetContestEntryOutProto.Status|null);
            total_entries?: (number|null);
            contest_entries?: (POGOProtos.Rpc.IContestEntryProto[]|null);
        }

        class GetContestEntryOutProto implements IGetContestEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestEntryOutProto);
            public status: POGOProtos.Rpc.GetContestEntryOutProto.Status;
            public total_entries: number;
            public contest_entries: POGOProtos.Rpc.IContestEntryProto[];
            public static encode(message: POGOProtos.Rpc.IGetContestEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetContestEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetContestEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                INVALID_INDEX = 3,
                ENTRY_NOT_FOUND = 4
            }
        }

        interface IGetContestEntryProto {
            contest_id?: (string|null);
            start_index?: (number|null);
            end_index?: (number|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            is_relative_to_player?: (boolean|null);
        }

        class GetContestEntryProto implements IGetContestEntryProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestEntryProto);
            public contest_id: string;
            public start_index: number;
            public end_index: number;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public is_relative_to_player: boolean;
            public static encode(message: POGOProtos.Rpc.IGetContestEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestEntryProto;
            public static toObject(message: POGOProtos.Rpc.GetContestEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetContestFriendEntryOutProto {
            status?: (POGOProtos.Rpc.GetContestFriendEntryOutProto.Status|null);
            total_friend_entries?: (number|null);
            contest_friend_entries?: (POGOProtos.Rpc.IContestFriendEntryProto[]|null);
        }

        class GetContestFriendEntryOutProto implements IGetContestFriendEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestFriendEntryOutProto);
            public status: POGOProtos.Rpc.GetContestFriendEntryOutProto.Status;
            public total_friend_entries: number;
            public contest_friend_entries: POGOProtos.Rpc.IContestFriendEntryProto[];
            public static encode(message: POGOProtos.Rpc.IGetContestFriendEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestFriendEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestFriendEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetContestFriendEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetContestFriendEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ACCESS_DENIED = 3
            }
        }

        interface IGetContestFriendEntryProto {
            contest_id?: (string|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
        }

        class GetContestFriendEntryProto implements IGetContestFriendEntryProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestFriendEntryProto);
            public contest_id: string;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public static encode(message: POGOProtos.Rpc.IGetContestFriendEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestFriendEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestFriendEntryProto;
            public static toObject(message: POGOProtos.Rpc.GetContestFriendEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetContestsUnclaimedRewardsOutProto {
            status?: (POGOProtos.Rpc.GetContestsUnclaimedRewardsOutProto.Status|null);
            contest_info_summaries?: (POGOProtos.Rpc.IContestInfoSummaryProto[]|null);
        }

        class GetContestsUnclaimedRewardsOutProto implements IGetContestsUnclaimedRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestsUnclaimedRewardsOutProto);
            public status: POGOProtos.Rpc.GetContestsUnclaimedRewardsOutProto.Status;
            public contest_info_summaries: POGOProtos.Rpc.IContestInfoSummaryProto[];
            public static encode(message: POGOProtos.Rpc.IGetContestsUnclaimedRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestsUnclaimedRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestsUnclaimedRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetContestsUnclaimedRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetContestsUnclaimedRewardsOutProto {

            enum Status {
                UNSET = 0,
                REWARDS_PENDING_CLAIM = 1,
                NO_REWARDS_PENDING_CLAIM = 2,
                ERROR = 3
            }
        }

        interface IGetContestsUnclaimedRewardsProto {
        }

        class GetContestsUnclaimedRewardsProto implements IGetContestsUnclaimedRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IGetContestsUnclaimedRewardsProto);
            public static encode(message: POGOProtos.Rpc.IGetContestsUnclaimedRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetContestsUnclaimedRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetContestsUnclaimedRewardsProto;
            public static toObject(message: POGOProtos.Rpc.GetContestsUnclaimedRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetDailyEncounterOutProto {
            result?: (POGOProtos.Rpc.GetDailyEncounterOutProto.Result|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            lat?: (number|null);
            lng?: (number|null);
            encounter_location?: (string|null);
            encounter_id?: (number|Long|null);
            disappear_time_ms?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class GetDailyEncounterOutProto implements IGetDailyEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetDailyEncounterOutProto);
            public result: POGOProtos.Rpc.GetDailyEncounterOutProto.Result;
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public lat: number;
            public lng: number;
            public encounter_location: string;
            public encounter_id: (number|Long);
            public disappear_time_ms: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IGetDailyEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetDailyEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetDailyEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.GetDailyEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetDailyEncounterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ALREADY_FINISHED_FOR_TODAY = 2,
                MISSED_FOR_TODAY = 3,
                NO_POKEMON_AVAILABLE = 4,
                DISABLED = 5
            }
        }

        interface IGetDailyEncounterProto {
        }

        class GetDailyEncounterProto implements IGetDailyEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IGetDailyEncounterProto);
            public static encode(message: POGOProtos.Rpc.IGetDailyEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetDailyEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetDailyEncounterProto;
            public static toObject(message: POGOProtos.Rpc.GetDailyEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetEligibleCombatLeaguesOutProto {
            result?: (POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.Result|null);
            player_eligible_leagues?: (POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.IPlayerEligibleCombatLeaguesProto|null);
            other_players_eligible_leagues?: (POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.IPlayerEligibleCombatLeaguesProto[]|null);
            skipped_player_ids?: (string[]|null);
        }

        class GetEligibleCombatLeaguesOutProto implements IGetEligibleCombatLeaguesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetEligibleCombatLeaguesOutProto);
            public result: POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.Result;
            public player_eligible_leagues?: (POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.IPlayerEligibleCombatLeaguesProto|null);
            public other_players_eligible_leagues: POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.IPlayerEligibleCombatLeaguesProto[];
            public skipped_player_ids: string[];
            public static encode(message: POGOProtos.Rpc.IGetEligibleCombatLeaguesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetEligibleCombatLeaguesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ACCESS_DENIED = 2,
                ERROR_TOO_MANY_PLAYER_IDS = 3
            }

            interface IPlayerEligibleCombatLeaguesProto {
                player_id?: (string|null);
                combat_player_preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
                eligible_combat_leagues?: (string[]|null);
            }

            class PlayerEligibleCombatLeaguesProto implements IPlayerEligibleCombatLeaguesProto {
                constructor(properties?: POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.IPlayerEligibleCombatLeaguesProto);
                public player_id: string;
                public combat_player_preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
                public eligible_combat_leagues: string[];
                public static encode(message: POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.IPlayerEligibleCombatLeaguesProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.PlayerEligibleCombatLeaguesProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.PlayerEligibleCombatLeaguesProto;
                public static toObject(message: POGOProtos.Rpc.GetEligibleCombatLeaguesOutProto.PlayerEligibleCombatLeaguesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetEligibleCombatLeaguesProto {
            player_ids?: (string[]|null);
        }

        class GetEligibleCombatLeaguesProto implements IGetEligibleCombatLeaguesProto {
            constructor(properties?: POGOProtos.Rpc.IGetEligibleCombatLeaguesProto);
            public player_ids: string[];
            public static encode(message: POGOProtos.Rpc.IGetEligibleCombatLeaguesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEligibleCombatLeaguesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEligibleCombatLeaguesProto;
            public static toObject(message: POGOProtos.Rpc.GetEligibleCombatLeaguesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetEnteredContestOutProto {
            status?: (POGOProtos.Rpc.GetEnteredContestOutProto.Status|null);
            contest_info?: (POGOProtos.Rpc.IContestInfoProto[]|null);
        }

        class GetEnteredContestOutProto implements IGetEnteredContestOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetEnteredContestOutProto);
            public status: POGOProtos.Rpc.GetEnteredContestOutProto.Status;
            public contest_info: POGOProtos.Rpc.IContestInfoProto[];
            public static encode(message: POGOProtos.Rpc.IGetEnteredContestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEnteredContestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEnteredContestOutProto;
            public static toObject(message: POGOProtos.Rpc.GetEnteredContestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetEnteredContestOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IGetEnteredContestProto {
            include_ranking?: (boolean|null);
        }

        class GetEnteredContestProto implements IGetEnteredContestProto {
            constructor(properties?: POGOProtos.Rpc.IGetEnteredContestProto);
            public include_ranking: boolean;
            public static encode(message: POGOProtos.Rpc.IGetEnteredContestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEnteredContestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEnteredContestProto;
            public static toObject(message: POGOProtos.Rpc.GetEnteredContestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetEventRsvpCountOutProto {
            status?: (POGOProtos.Rpc.GetEventRsvpCountOutProto.Result|null);
            rsvp_details?: (POGOProtos.Rpc.IRsvpCountDetails[]|null);
        }

        class GetEventRsvpCountOutProto implements IGetEventRsvpCountOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetEventRsvpCountOutProto);
            public status: POGOProtos.Rpc.GetEventRsvpCountOutProto.Result;
            public rsvp_details: POGOProtos.Rpc.IRsvpCountDetails[];
            public static encode(message: POGOProtos.Rpc.IGetEventRsvpCountOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEventRsvpCountOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEventRsvpCountOutProto;
            public static toObject(message: POGOProtos.Rpc.GetEventRsvpCountOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetEventRsvpCountOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_LOCATION_DETAILS = 3
            }
        }

        interface IGetEventRsvpCountProto {
            location_id?: (string[]|null);
        }

        class GetEventRsvpCountProto implements IGetEventRsvpCountProto {
            constructor(properties?: POGOProtos.Rpc.IGetEventRsvpCountProto);
            public location_id: string[];
            public static encode(message: POGOProtos.Rpc.IGetEventRsvpCountProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEventRsvpCountProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEventRsvpCountProto;
            public static toObject(message: POGOProtos.Rpc.GetEventRsvpCountProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetEventRsvpsOutProto {
            status?: (POGOProtos.Rpc.GetEventRsvpsOutProto.Result|null);
            rsvp_timeslots?: (POGOProtos.Rpc.IEventRsvpTimeslotProto[]|null);
        }

        class GetEventRsvpsOutProto implements IGetEventRsvpsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetEventRsvpsOutProto);
            public status: POGOProtos.Rpc.GetEventRsvpsOutProto.Result;
            public rsvp_timeslots: POGOProtos.Rpc.IEventRsvpTimeslotProto[];
            public static encode(message: POGOProtos.Rpc.IGetEventRsvpsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEventRsvpsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEventRsvpsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetEventRsvpsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetEventRsvpsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_EVENT_DETAILS = 3
            }
        }

        interface IGetEventRsvpsProto {
            raid?: (POGOProtos.Rpc.IRaidDetails|null);
            gmax_battle?: (POGOProtos.Rpc.IGMaxDetails|null);
            time_slots?: ((number|Long)[]|null);
        }

        class GetEventRsvpsProto implements IGetEventRsvpsProto {
            constructor(properties?: POGOProtos.Rpc.IGetEventRsvpsProto);
            public raid?: (POGOProtos.Rpc.IRaidDetails|null);
            public gmax_battle?: (POGOProtos.Rpc.IGMaxDetails|null);
            public time_slots: (number|Long)[];
            public EventDetails?: ("raid"|"gmax_battle");
            public static encode(message: POGOProtos.Rpc.IGetEventRsvpsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetEventRsvpsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetEventRsvpsProto;
            public static toObject(message: POGOProtos.Rpc.GetEventRsvpsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetFitnessReportOutProto {
            status?: (POGOProtos.Rpc.GetFitnessReportOutProto.Status|null);
            daily_reports?: (POGOProtos.Rpc.IFitnessReportProto[]|null);
            weekly_reports?: (POGOProtos.Rpc.IFitnessReportProto[]|null);
            week_reset_timestamp_since_monday_ms?: (number|Long|null);
            hourly_reports?: (POGOProtos.Rpc.IFitnessReportProto[]|null);
        }

        class GetFitnessReportOutProto implements IGetFitnessReportOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetFitnessReportOutProto);
            public status: POGOProtos.Rpc.GetFitnessReportOutProto.Status;
            public daily_reports: POGOProtos.Rpc.IFitnessReportProto[];
            public weekly_reports: POGOProtos.Rpc.IFitnessReportProto[];
            public week_reset_timestamp_since_monday_ms: (number|Long);
            public hourly_reports: POGOProtos.Rpc.IFitnessReportProto[];
            public static encode(message: POGOProtos.Rpc.IGetFitnessReportOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetFitnessReportOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetFitnessReportOutProto;
            public static toObject(message: POGOProtos.Rpc.GetFitnessReportOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetFitnessReportOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_FOUND = 2,
                ERROR_RECORDS_NOT_FOUND = 3,
                ERROR_INVALID_WINDOW = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IGetFitnessReportProto {
            num_of_days?: (number|null);
            num_of_weeks?: (number|null);
            num_of_hours?: (number|null);
        }

        class GetFitnessReportProto implements IGetFitnessReportProto {
            constructor(properties?: POGOProtos.Rpc.IGetFitnessReportProto);
            public num_of_days: number;
            public num_of_weeks: number;
            public num_of_hours: number;
            public static encode(message: POGOProtos.Rpc.IGetFitnessReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetFitnessReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetFitnessReportProto;
            public static toObject(message: POGOProtos.Rpc.GetFitnessReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetFitnessRewardsOutProto {
            result?: (POGOProtos.Rpc.GetFitnessRewardsOutProto.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class GetFitnessRewardsOutProto implements IGetFitnessRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetFitnessRewardsOutProto);
            public result: POGOProtos.Rpc.GetFitnessRewardsOutProto.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IGetFitnessRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetFitnessRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetFitnessRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetFitnessRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetFitnessRewardsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                REWARDS_ALREADY_COLLECTED = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IGetFitnessRewardsProto {
        }

        class GetFitnessRewardsProto implements IGetFitnessRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IGetFitnessRewardsProto);
            public static encode(message: POGOProtos.Rpc.IGetFitnessRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetFitnessRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetFitnessRewardsProto;
            public static toObject(message: POGOProtos.Rpc.GetFitnessRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetFriendshipRewardsOutProto {
            result?: (POGOProtos.Rpc.GetFriendshipRewardsOutProto.Result|null);
            xp_reward?: (number|Long|null);
            friend_id?: (string|null);
        }

        class GetFriendshipRewardsOutProto implements IGetFriendshipRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetFriendshipRewardsOutProto);
            public result: POGOProtos.Rpc.GetFriendshipRewardsOutProto.Result;
            public xp_reward: (number|Long);
            public friend_id: string;
            public static encode(message: POGOProtos.Rpc.IGetFriendshipRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetFriendshipRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetFriendshipRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetFriendshipRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetFriendshipRewardsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FRIENDS = 3,
                ERROR_MILESTONE_ALREADY_AWARDED = 4,
                ERROR_FAILED_TO_UPDATE = 5
            }
        }

        interface IGetFriendshipRewardsProto {
            friend_id?: (string|null);
        }

        class GetFriendshipRewardsProto implements IGetFriendshipRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IGetFriendshipRewardsProto);
            public friend_id: string;
            public static encode(message: POGOProtos.Rpc.IGetFriendshipRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetFriendshipRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetFriendshipRewardsProto;
            public static toObject(message: POGOProtos.Rpc.GetFriendshipRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGameConfigVersionsOutProto {
            result?: (POGOProtos.Rpc.GetGameConfigVersionsOutProto.Result|null);
            game_master_timestamp?: (number|Long|null);
            asset_digest_timestamp?: (number|Long|null);
            experiment_id?: (number[]|null);
        }

        class GetGameConfigVersionsOutProto implements IGetGameConfigVersionsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGameConfigVersionsOutProto);
            public result: POGOProtos.Rpc.GetGameConfigVersionsOutProto.Result;
            public game_master_timestamp: (number|Long);
            public asset_digest_timestamp: (number|Long);
            public experiment_id: number[];
            public static encode(message: POGOProtos.Rpc.IGetGameConfigVersionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGameConfigVersionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGameConfigVersionsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGameConfigVersionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetGameConfigVersionsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IGetGameConfigVersionsProto {
            platform?: (POGOProtos.Rpc.Platform|null);
            device_manufacturer?: (string|null);
            device_model?: (string|null);
            locale?: (string|null);
            app_version?: (number|null);
            store?: (POGOProtos.Rpc.Store|null);
            carrier?: (string|null);
            user_date_of_birth?: (string|null);
            sentry_id?: (string|null);
        }

        class GetGameConfigVersionsProto implements IGetGameConfigVersionsProto {
            constructor(properties?: POGOProtos.Rpc.IGetGameConfigVersionsProto);
            public platform: POGOProtos.Rpc.Platform;
            public device_manufacturer: string;
            public device_model: string;
            public locale: string;
            public app_version: number;
            public store: POGOProtos.Rpc.Store;
            public carrier: string;
            public user_date_of_birth: string;
            public sentry_id: string;
            public static encode(message: POGOProtos.Rpc.IGetGameConfigVersionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGameConfigVersionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGameConfigVersionsProto;
            public static toObject(message: POGOProtos.Rpc.GetGameConfigVersionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGameMasterClientTemplatesOutProto {
            result?: (POGOProtos.Rpc.GetGameMasterClientTemplatesOutProto.Result|null);
            items?: (POGOProtos.Rpc.IGameMasterClientTemplateProto[]|null);
            timestamp?: (number|Long|null);
            page_offset?: (number|null);
        }

        class GetGameMasterClientTemplatesOutProto implements IGetGameMasterClientTemplatesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGameMasterClientTemplatesOutProto);
            public result: POGOProtos.Rpc.GetGameMasterClientTemplatesOutProto.Result;
            public items: POGOProtos.Rpc.IGameMasterClientTemplateProto[];
            public timestamp: (number|Long);
            public page_offset: number;
            public static encode(message: POGOProtos.Rpc.IGetGameMasterClientTemplatesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGameMasterClientTemplatesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGameMasterClientTemplatesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGameMasterClientTemplatesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetGameMasterClientTemplatesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                PAGE = 2,
                RETRY = 3
            }
        }

        interface IGetGameMasterClientTemplatesProto {
            paginate?: (boolean|null);
            page_offset?: (number|null);
            page_timestamp?: (number|Long|null);
        }

        class GetGameMasterClientTemplatesProto implements IGetGameMasterClientTemplatesProto {
            constructor(properties?: POGOProtos.Rpc.IGetGameMasterClientTemplatesProto);
            public paginate: boolean;
            public page_offset: number;
            public page_timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetGameMasterClientTemplatesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGameMasterClientTemplatesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGameMasterClientTemplatesProto;
            public static toObject(message: POGOProtos.Rpc.GetGameMasterClientTemplatesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGeofencedAdOutProto {
            result?: (POGOProtos.Rpc.GetGeofencedAdOutProto.Result|null);
            sponsored_gift?: (POGOProtos.Rpc.IAdDetails|null);
            ad?: (POGOProtos.Rpc.IAdProto|null);
        }

        class GetGeofencedAdOutProto implements IGetGeofencedAdOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGeofencedAdOutProto);
            public result: POGOProtos.Rpc.GetGeofencedAdOutProto.Result;
            public sponsored_gift?: (POGOProtos.Rpc.IAdDetails|null);
            public ad?: (POGOProtos.Rpc.IAdProto|null);
            public static encode(message: POGOProtos.Rpc.IGetGeofencedAdOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGeofencedAdOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGeofencedAdOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGeofencedAdOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetGeofencedAdOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS_AD_RECEIVED = 1,
                SUCCESS_NO_ADS_AVAILABLE = 2,
                ERROR_REQUEST_FAILED = 3,
                SUCCESS_GAM_ELIGIBLE = 4,
                SUCCESS_AD_RECEIVED_BUT_CHECK_GAM = 5
            }
        }

        interface IGetGeofencedAdProto {
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            ad_targeting_info?: (POGOProtos.Rpc.IAdTargetingInfoProto|null);
            allowed_ad_type?: (POGOProtos.Rpc.AdType[]|null);
        }

        class GetGeofencedAdProto implements IGetGeofencedAdProto {
            constructor(properties?: POGOProtos.Rpc.IGetGeofencedAdProto);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public ad_targeting_info?: (POGOProtos.Rpc.IAdTargetingInfoProto|null);
            public allowed_ad_type: POGOProtos.Rpc.AdType[];
            public static encode(message: POGOProtos.Rpc.IGetGeofencedAdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGeofencedAdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGeofencedAdProto;
            public static toObject(message: POGOProtos.Rpc.GetGeofencedAdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGiftBoxDetailsOutProto {
            result?: (POGOProtos.Rpc.GetGiftBoxDetailsOutProto.Result|null);
            gift_boxes?: (POGOProtos.Rpc.IGiftBoxDetailsProto[]|null);
        }

        class GetGiftBoxDetailsOutProto implements IGetGiftBoxDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGiftBoxDetailsOutProto);
            public result: POGOProtos.Rpc.GetGiftBoxDetailsOutProto.Result;
            public gift_boxes: POGOProtos.Rpc.IGiftBoxDetailsProto[];
            public static encode(message: POGOProtos.Rpc.IGetGiftBoxDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGiftBoxDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGiftBoxDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGiftBoxDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetGiftBoxDetailsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_GIFT_DOES_NOT_EXIST = 3,
                ERROR_INVALID_PLAYER_ID = 4,
                ERROR_FRIEND_NOT_FOUND = 5,
                ERROR_FORT_SEARCH = 6
            }
        }

        interface IGetGiftBoxDetailsProto {
            giftbox_id?: ((number|Long)[]|null);
            player_id?: (string|null);
        }

        class GetGiftBoxDetailsProto implements IGetGiftBoxDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetGiftBoxDetailsProto);
            public giftbox_id: (number|Long)[];
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.IGetGiftBoxDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGiftBoxDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGiftBoxDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetGiftBoxDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGmapSettingsOutProto {
            result?: (POGOProtos.Rpc.GetGmapSettingsOutProto.Result|null);
            gmap_template_url?: (string|null);
            max_poi_distance_in_meters?: (number|null);
        }

        class GetGmapSettingsOutProto implements IGetGmapSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGmapSettingsOutProto);
            public result: POGOProtos.Rpc.GetGmapSettingsOutProto.Result;
            public gmap_template_url: string;
            public max_poi_distance_in_meters: number;
            public static encode(message: POGOProtos.Rpc.IGetGmapSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGmapSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGmapSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGmapSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetGmapSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_MISSING_CONFIG = 3,
                ERROR_NO_UNIQUE_ID = 4
            }
        }

        interface IGetGmapSettingsProto {
        }

        class GetGmapSettingsProto implements IGetGmapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGetGmapSettingsProto);
            public static encode(message: POGOProtos.Rpc.IGetGmapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGmapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGmapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GetGmapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGymBadgeDetailsOutProto {
            gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            gym_defender?: (POGOProtos.Rpc.IGymDefenderProto|null);
            success?: (boolean|null);
        }

        class GetGymBadgeDetailsOutProto implements IGetGymBadgeDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGymBadgeDetailsOutProto);
            public gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            public gym_defender?: (POGOProtos.Rpc.IGymDefenderProto|null);
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.IGetGymBadgeDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGymBadgeDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGymBadgeDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGymBadgeDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGymBadgeDetailsProto {
            fort_id?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class GetGymBadgeDetailsProto implements IGetGymBadgeDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetGymBadgeDetailsProto);
            public fort_id: string;
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IGetGymBadgeDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGymBadgeDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGymBadgeDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetGymBadgeDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetGymDetailsOutProto {
            gym_state?: (POGOProtos.Rpc.IGymStateProto|null);
            name?: (string|null);
            url?: (string[]|null);
            result?: (POGOProtos.Rpc.GetGymDetailsOutProto.Result|null);
            description?: (string|null);
            secondary_url?: (string[]|null);
            checkin_image_url?: (string|null);
            event_info?: (POGOProtos.Rpc.IEventInfoProto|null);
        }

        class GetGymDetailsOutProto implements IGetGymDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetGymDetailsOutProto);
            public gym_state?: (POGOProtos.Rpc.IGymStateProto|null);
            public name: string;
            public url: string[];
            public result: POGOProtos.Rpc.GetGymDetailsOutProto.Result;
            public description: string;
            public secondary_url: string[];
            public checkin_image_url: string;
            public event_info?: (POGOProtos.Rpc.IEventInfoProto|null);
            public static encode(message: POGOProtos.Rpc.IGetGymDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGymDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGymDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetGymDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetGymDetailsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2
            }
        }

        interface IGetGymDetailsProto {
            gym_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
            client_version?: (string|null);
        }

        class GetGymDetailsProto implements IGetGymDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetGymDetailsProto);
            public gym_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public client_version: string;
            public static encode(message: POGOProtos.Rpc.IGetGymDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetGymDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetGymDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetGymDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetHatchedEggsOutProto {
            success?: (boolean|null);
            pokemon_id?: ((number|Long)[]|null);
            exp_awarded?: (number[]|null);
            candy_awarded?: (number[]|null);
            stardust_awarded?: (number[]|null);
            egg_km_walked?: (number[]|null);
            hatched_pokemon?: (POGOProtos.Rpc.IPokemonProto[]|null);
            xl_candy_awarded?: (number[]|null);
            items_awarded?: (POGOProtos.Rpc.ILootProto[]|null);
        }

        class GetHatchedEggsOutProto implements IGetHatchedEggsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetHatchedEggsOutProto);
            public success: boolean;
            public pokemon_id: (number|Long)[];
            public exp_awarded: number[];
            public candy_awarded: number[];
            public stardust_awarded: number[];
            public egg_km_walked: number[];
            public hatched_pokemon: POGOProtos.Rpc.IPokemonProto[];
            public xl_candy_awarded: number[];
            public items_awarded: POGOProtos.Rpc.ILootProto[];
            public static encode(message: POGOProtos.Rpc.IGetHatchedEggsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetHatchedEggsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetHatchedEggsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetHatchedEggsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetHatchedEggsProto {
        }

        class GetHatchedEggsProto implements IGetHatchedEggsProto {
            constructor(properties?: POGOProtos.Rpc.IGetHatchedEggsProto);
            public static encode(message: POGOProtos.Rpc.IGetHatchedEggsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetHatchedEggsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetHatchedEggsProto;
            public static toObject(message: POGOProtos.Rpc.GetHatchedEggsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetHoloholoInventoryOutProto {
            success?: (boolean|null);
            inventory_delta?: (POGOProtos.Rpc.IInventoryDeltaProto|null);
        }

        class GetHoloholoInventoryOutProto implements IGetHoloholoInventoryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetHoloholoInventoryOutProto);
            public success: boolean;
            public inventory_delta?: (POGOProtos.Rpc.IInventoryDeltaProto|null);
            public static encode(message: POGOProtos.Rpc.IGetHoloholoInventoryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetHoloholoInventoryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetHoloholoInventoryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetHoloholoInventoryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetHoloholoInventoryProto {
            timestamp_millis?: (number|Long|null);
            item_been_seen?: (POGOProtos.Rpc.Item[]|null);
        }

        class GetHoloholoInventoryProto implements IGetHoloholoInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IGetHoloholoInventoryProto);
            public timestamp_millis: (number|Long);
            public item_been_seen: POGOProtos.Rpc.Item[];
            public static encode(message: POGOProtos.Rpc.IGetHoloholoInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetHoloholoInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetHoloholoInventoryProto;
            public static toObject(message: POGOProtos.Rpc.GetHoloholoInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetInboxOutProto {
            result?: (POGOProtos.Rpc.GetInboxOutProto.Result|null);
            inbox?: (POGOProtos.Rpc.IClientInbox|null);
        }

        class GetInboxOutProto implements IGetInboxOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetInboxOutProto);
            public result: POGOProtos.Rpc.GetInboxOutProto.Result;
            public inbox?: (POGOProtos.Rpc.IClientInbox|null);
            public static encode(message: POGOProtos.Rpc.IGetInboxOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetInboxOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetInboxOutProto;
            public static toObject(message: POGOProtos.Rpc.GetInboxOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetInboxOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                TIMED_OUT = 3
            }
        }

        interface IGetInboxProto {
            is_history?: (boolean|null);
            is_reverse?: (boolean|null);
            not_before_ms?: (number|Long|null);
        }

        class GetInboxProto implements IGetInboxProto {
            constructor(properties?: POGOProtos.Rpc.IGetInboxProto);
            public is_history: boolean;
            public is_reverse: boolean;
            public not_before_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetInboxProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetInboxProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetInboxProto;
            public static toObject(message: POGOProtos.Rpc.GetInboxProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetIncensePokemonOutProto {
            result?: (POGOProtos.Rpc.GetIncensePokemonOutProto.Result|null);
            pokemon_type_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            lat?: (number|null);
            lng?: (number|null);
            encounter_location?: (string|null);
            encounter_id?: (number|Long|null);
            disappear_time_ms?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class GetIncensePokemonOutProto implements IGetIncensePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetIncensePokemonOutProto);
            public result: POGOProtos.Rpc.GetIncensePokemonOutProto.Result;
            public pokemon_type_id: POGOProtos.Rpc.HoloPokemonId;
            public lat: number;
            public lng: number;
            public encounter_location: string;
            public encounter_id: (number|Long);
            public disappear_time_ms: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IGetIncensePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetIncensePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetIncensePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.GetIncensePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetIncensePokemonOutProto {

            enum Result {
                INCENSE_ENCOUNTER_UNKNOWN = 0,
                INCENSE_ENCOUNTER_AVAILABLE = 1,
                INCENSE_ENCOUNTER_NOT_AVAILABLE = 2
            }
        }

        interface IGetIncensePokemonProto {
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class GetIncensePokemonProto implements IGetIncensePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IGetIncensePokemonProto);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IGetIncensePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetIncensePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetIncensePokemonProto;
            public static toObject(message: POGOProtos.Rpc.GetIncensePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetIncenseRecapOutProto {
            result?: (POGOProtos.Rpc.GetIncenseRecapOutProto.Result|null);
            display_protos?: (POGOProtos.Rpc.IDailyAdventureIncenseRecapDayDisplayProto[]|null);
        }

        class GetIncenseRecapOutProto implements IGetIncenseRecapOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetIncenseRecapOutProto);
            public result: POGOProtos.Rpc.GetIncenseRecapOutProto.Result;
            public display_protos: POGOProtos.Rpc.IDailyAdventureIncenseRecapDayDisplayProto[];
            public static encode(message: POGOProtos.Rpc.IGetIncenseRecapOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetIncenseRecapOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetIncenseRecapOutProto;
            public static toObject(message: POGOProtos.Rpc.GetIncenseRecapOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetIncenseRecapOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ALREADY_SEEN = 2,
                ERROR_INVALID_DAY_BUCKET = 3,
                ERROR_FEATURE_DISABLED = 4
            }
        }

        interface IGetIncenseRecapProto {
            day_bucket?: (number|Long|null);
        }

        class GetIncenseRecapProto implements IGetIncenseRecapProto {
            constructor(properties?: POGOProtos.Rpc.IGetIncenseRecapProto);
            public day_bucket: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetIncenseRecapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetIncenseRecapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetIncenseRecapProto;
            public static toObject(message: POGOProtos.Rpc.GetIncenseRecapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetInventoryProto {
            timestamp_millis?: (number|Long|null);
        }

        class GetInventoryProto implements IGetInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IGetInventoryProto);
            public timestamp_millis: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetInventoryProto;
            public static toObject(message: POGOProtos.Rpc.GetInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetInventoryResponseProto {
            success?: (boolean|null);
            inventory_delta?: (POGOProtos.Rpc.IInventoryDeltaProto|null);
        }

        class GetInventoryResponseProto implements IGetInventoryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetInventoryResponseProto);
            public success: boolean;
            public inventory_delta?: (POGOProtos.Rpc.IInventoryDeltaProto|null);
            public static encode(message: POGOProtos.Rpc.IGetInventoryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetInventoryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetInventoryResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetInventoryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetIrisSocialSceneOutProto {
            status?: (POGOProtos.Rpc.GetIrisSocialSceneOutProto.Status|null);
            placed_pokemon?: (POGOProtos.Rpc.IIrisPokemonObjectProto[]|null);
            player_public_profiles?: (POGOProtos.Rpc.IIrisPlayerPublicProfileInfo[]|null);
        }

        class GetIrisSocialSceneOutProto implements IGetIrisSocialSceneOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetIrisSocialSceneOutProto);
            public status: POGOProtos.Rpc.GetIrisSocialSceneOutProto.Status;
            public placed_pokemon: POGOProtos.Rpc.IIrisPokemonObjectProto[];
            public player_public_profiles: POGOProtos.Rpc.IIrisPlayerPublicProfileInfo[];
            public static encode(message: POGOProtos.Rpc.IGetIrisSocialSceneOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetIrisSocialSceneOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetIrisSocialSceneOutProto;
            public static toObject(message: POGOProtos.Rpc.GetIrisSocialSceneOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetIrisSocialSceneOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_FORT_ID_NOT_FOUND = 2,
                ERROR_FORT_ID_NOT_VPS_ELIGIBLE = 3,
                ERROR_FEATURE_DISABLED = 4,
                ERROR_FORT_ID_NOT_SPECIFIED = 5
            }
        }

        interface IGetIrisSocialSceneProto {
            fort_id?: (string|null);
            iris_session_id?: (string|null);
            vps_session_id?: (string|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
            get_player_profiles?: (boolean|null);
        }

        class GetIrisSocialSceneProto implements IGetIrisSocialSceneProto {
            constructor(properties?: POGOProtos.Rpc.IGetIrisSocialSceneProto);
            public fort_id: string;
            public iris_session_id: string;
            public vps_session_id: string;
            public fort_lat: number;
            public fort_lng: number;
            public get_player_profiles: boolean;
            public static encode(message: POGOProtos.Rpc.IGetIrisSocialSceneProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetIrisSocialSceneProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetIrisSocialSceneProto;
            public static toObject(message: POGOProtos.Rpc.GetIrisSocialSceneProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetKeysRequest {
            kind?: (string|null);
        }

        class GetKeysRequest implements IGetKeysRequest {
            constructor(properties?: POGOProtos.Rpc.IGetKeysRequest);
            public kind: string;
            public static encode(message: POGOProtos.Rpc.IGetKeysRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetKeysRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetKeysRequest;
            public static toObject(message: POGOProtos.Rpc.GetKeysRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetKeysResponse {
            keys?: (POGOProtos.Rpc.IKey[]|null);
        }

        class GetKeysResponse implements IGetKeysResponse {
            constructor(properties?: POGOProtos.Rpc.IGetKeysResponse);
            public keys: POGOProtos.Rpc.IKey[];
            public static encode(message: POGOProtos.Rpc.IGetKeysResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetKeysResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetKeysResponse;
            public static toObject(message: POGOProtos.Rpc.GetKeysResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetLocalTimeOutProto {
            status?: (POGOProtos.Rpc.GetLocalTimeOutProto.Status|null);
            local_times?: (POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto[]|null);
        }

        class GetLocalTimeOutProto implements IGetLocalTimeOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetLocalTimeOutProto);
            public status: POGOProtos.Rpc.GetLocalTimeOutProto.Status;
            public local_times: POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto[];
            public static encode(message: POGOProtos.Rpc.IGetLocalTimeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetLocalTimeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetLocalTimeOutProto;
            public static toObject(message: POGOProtos.Rpc.GetLocalTimeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetLocalTimeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }

            interface ILocalTimeProto {
                timestamp_ms?: (number|Long|null);
                year?: (number|null);
                month?: (number|null);
                day_of_month?: (number|null);
                day_of_week?: (number|null);
                hours?: (number|null);
                minutes?: (number|null);
                seconds?: (number|null);
                milliseconds?: (number|null);
                timezone_id?: (string|null);
            }

            class LocalTimeProto implements ILocalTimeProto {
                constructor(properties?: POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto);
                public timestamp_ms: (number|Long);
                public year: number;
                public month: number;
                public day_of_month: number;
                public day_of_week: number;
                public hours: number;
                public minutes: number;
                public seconds: number;
                public milliseconds: number;
                public timezone_id: string;
                public static encode(message: POGOProtos.Rpc.GetLocalTimeOutProto.ILocalTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetLocalTimeOutProto.LocalTimeProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetLocalTimeOutProto.LocalTimeProto;
                public static toObject(message: POGOProtos.Rpc.GetLocalTimeOutProto.LocalTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetLocalTimeProto {
            timestamp_ms?: ((number|Long)[]|null);
        }

        class GetLocalTimeProto implements IGetLocalTimeProto {
            constructor(properties?: POGOProtos.Rpc.IGetLocalTimeProto);
            public timestamp_ms: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IGetLocalTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetLocalTimeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetLocalTimeProto;
            public static toObject(message: POGOProtos.Rpc.GetLocalTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMapFortsOutProto {
            fort?: (POGOProtos.Rpc.GetMapFortsOutProto.IFortProto[]|null);
            status?: (POGOProtos.Rpc.GetMapFortsOutProto.Status|null);
        }

        class GetMapFortsOutProto implements IGetMapFortsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMapFortsOutProto);
            public fort: POGOProtos.Rpc.GetMapFortsOutProto.IFortProto[];
            public status: POGOProtos.Rpc.GetMapFortsOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IGetMapFortsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapFortsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapFortsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMapFortsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMapFortsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }

            interface IFortProto {
                id?: (string|null);
                name?: (string|null);
                latitude?: (number|null);
                longitude?: (number|null);
                image?: (POGOProtos.Rpc.GetMapFortsOutProto.IImage[]|null);
            }

            class FortProto implements IFortProto {
                constructor(properties?: POGOProtos.Rpc.GetMapFortsOutProto.IFortProto);
                public id: string;
                public name: string;
                public latitude: number;
                public longitude: number;
                public image: POGOProtos.Rpc.GetMapFortsOutProto.IImage[];
                public static encode(message: POGOProtos.Rpc.GetMapFortsOutProto.IFortProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapFortsOutProto.FortProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapFortsOutProto.FortProto;
                public static toObject(message: POGOProtos.Rpc.GetMapFortsOutProto.FortProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IImage {
                url?: (string|null);
                id?: (string|null);
            }

            class Image implements IImage {
                constructor(properties?: POGOProtos.Rpc.GetMapFortsOutProto.IImage);
                public url: string;
                public id: string;
                public static encode(message: POGOProtos.Rpc.GetMapFortsOutProto.IImage, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapFortsOutProto.Image;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapFortsOutProto.Image;
                public static toObject(message: POGOProtos.Rpc.GetMapFortsOutProto.Image, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetMapFortsProto {
            cell_id?: ((number|Long)[]|null);
        }

        class GetMapFortsProto implements IGetMapFortsProto {
            constructor(properties?: POGOProtos.Rpc.IGetMapFortsProto);
            public cell_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IGetMapFortsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapFortsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapFortsProto;
            public static toObject(message: POGOProtos.Rpc.GetMapFortsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMapObjectsOutProto {
            map_cell?: (POGOProtos.Rpc.IClientMapCellProto[]|null);
            status?: (POGOProtos.Rpc.GetMapObjectsOutProto.Status|null);
            time_of_day?: (POGOProtos.Rpc.GetMapObjectsOutProto.TimeOfDay|null);
            client_weather?: (POGOProtos.Rpc.IClientWeatherProto[]|null);
            moon_phase?: (POGOProtos.Rpc.GetMapObjectsOutProto.MoonPhase|null);
            twilight_period?: (POGOProtos.Rpc.GetMapObjectsOutProto.TwilightPeriod|null);
        }

        class GetMapObjectsOutProto implements IGetMapObjectsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMapObjectsOutProto);
            public map_cell: POGOProtos.Rpc.IClientMapCellProto[];
            public status: POGOProtos.Rpc.GetMapObjectsOutProto.Status;
            public time_of_day: POGOProtos.Rpc.GetMapObjectsOutProto.TimeOfDay;
            public client_weather: POGOProtos.Rpc.IClientWeatherProto[];
            public moon_phase: POGOProtos.Rpc.GetMapObjectsOutProto.MoonPhase;
            public twilight_period: POGOProtos.Rpc.GetMapObjectsOutProto.TwilightPeriod;
            public static encode(message: POGOProtos.Rpc.IGetMapObjectsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapObjectsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapObjectsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMapObjectsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMapObjectsOutProto {

            enum MoonPhase {
                NOT_SET = 0,
                FULL = 1
            }

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                LOCATION_UNSET = 2,
                ERROR = 3
            }

            enum TimeOfDay {
                NONE = 0,
                DAY = 1,
                NIGHT = 2
            }

            enum TwilightPeriod {
                NONE_TWILIGHT_PERIOD = 0,
                DUSK = 1,
                DAWN = 2
            }
        }

        interface IGetMapObjectsProto {
            cell_id?: ((number|Long)[]|null);
            since_time_ms?: ((number|Long)[]|null);
            player_lat?: (number|null);
            player_lng?: (number|null);
        }

        class GetMapObjectsProto implements IGetMapObjectsProto {
            constructor(properties?: POGOProtos.Rpc.IGetMapObjectsProto);
            public cell_id: (number|Long)[];
            public since_time_ms: (number|Long)[];
            public player_lat: number;
            public player_lng: number;
            public static encode(message: POGOProtos.Rpc.IGetMapObjectsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapObjectsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapObjectsProto;
            public static toObject(message: POGOProtos.Rpc.GetMapObjectsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMapObjectsTriggerTelemetry {
            trigger_type?: (POGOProtos.Rpc.GetMapObjectsTriggerTelemetry.TriggerType|null);
        }

        class GetMapObjectsTriggerTelemetry implements IGetMapObjectsTriggerTelemetry {
            constructor(properties?: POGOProtos.Rpc.IGetMapObjectsTriggerTelemetry);
            public trigger_type: POGOProtos.Rpc.GetMapObjectsTriggerTelemetry.TriggerType;
            public static encode(message: POGOProtos.Rpc.IGetMapObjectsTriggerTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMapObjectsTriggerTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMapObjectsTriggerTelemetry;
            public static toObject(message: POGOProtos.Rpc.GetMapObjectsTriggerTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMapObjectsTriggerTelemetry {

            enum TriggerType {
                UNSET = 0,
                TIME = 1,
                SPACE = 2
            }
        }

        interface IGetMaptilesSettingsRequest {
            unity_sdk_version?: (string|null);
            eighth_wall_module_version?: (string|null);
        }

        class GetMaptilesSettingsRequest implements IGetMaptilesSettingsRequest {
            constructor(properties?: POGOProtos.Rpc.IGetMaptilesSettingsRequest);
            public unity_sdk_version?: (string|null);
            public eighth_wall_module_version?: (string|null);
            public ClientVersion?: ("unity_sdk_version"|"eighth_wall_module_version");
            public static encode(message: POGOProtos.Rpc.IGetMaptilesSettingsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMaptilesSettingsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMaptilesSettingsRequest;
            public static toObject(message: POGOProtos.Rpc.GetMaptilesSettingsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMaptilesSettingsResponse {
            map_composition_root?: (POGOProtos.Rpc.IMapCompositionRoot|null);
            status?: (POGOProtos.Rpc.GetMaptilesSettingsResponse.Status|null);
            error_message?: (string|null);
        }

        class GetMaptilesSettingsResponse implements IGetMaptilesSettingsResponse {
            constructor(properties?: POGOProtos.Rpc.IGetMaptilesSettingsResponse);
            public map_composition_root?: (POGOProtos.Rpc.IMapCompositionRoot|null);
            public status: POGOProtos.Rpc.GetMaptilesSettingsResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IGetMaptilesSettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMaptilesSettingsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMaptilesSettingsResponse;
            public static toObject(message: POGOProtos.Rpc.GetMaptilesSettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMaptilesSettingsResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_REQUEST = 2,
                INTERNAL_ERROR = 3
            }
        }

        interface IGetMatchmakingStatusData {
            rpc_id?: (number|null);
        }

        class GetMatchmakingStatusData implements IGetMatchmakingStatusData {
            constructor(properties?: POGOProtos.Rpc.IGetMatchmakingStatusData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IGetMatchmakingStatusData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMatchmakingStatusData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMatchmakingStatusData;
            public static toObject(message: POGOProtos.Rpc.GetMatchmakingStatusData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMatchmakingStatusOutProto {
            result?: (POGOProtos.Rpc.GetMatchmakingStatusOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            queue_id?: (string|null);
        }

        class GetMatchmakingStatusOutProto implements IGetMatchmakingStatusOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMatchmakingStatusOutProto);
            public result: POGOProtos.Rpc.GetMatchmakingStatusOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public queue_id: string;
            public static encode(message: POGOProtos.Rpc.IGetMatchmakingStatusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMatchmakingStatusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMatchmakingStatusOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMatchmakingStatusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMatchmakingStatusOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS_OPPONENT_FOUND = 1,
                SUCCESS_QUEUED = 2,
                SUCCESS_NOT_MATCHED_EXPIRED = 3,
                ERROR_PLAYER_NOT_FOUND = 4,
                ERROR_QUEUE_NOT_FOUND = 5,
                ERROR_RETRY_UNSUCCESSFUL = 6
            }
        }

        interface IGetMatchmakingStatusProto {
            queue_id?: (string|null);
        }

        class GetMatchmakingStatusProto implements IGetMatchmakingStatusProto {
            constructor(properties?: POGOProtos.Rpc.IGetMatchmakingStatusProto);
            public queue_id: string;
            public static encode(message: POGOProtos.Rpc.IGetMatchmakingStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMatchmakingStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMatchmakingStatusProto;
            public static toObject(message: POGOProtos.Rpc.GetMatchmakingStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMatchmakingStatusResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.GetMatchmakingStatusOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
        }

        class GetMatchmakingStatusResponseData implements IGetMatchmakingStatusResponseData {
            constructor(properties?: POGOProtos.Rpc.IGetMatchmakingStatusResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.GetMatchmakingStatusOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
            public static encode(message: POGOProtos.Rpc.IGetMatchmakingStatusResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMatchmakingStatusResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMatchmakingStatusResponseData;
            public static toObject(message: POGOProtos.Rpc.GetMatchmakingStatusResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMementoListOutProto {
            status?: (POGOProtos.Rpc.GetMementoListOutProto.Status|null);
            mementos?: (POGOProtos.Rpc.IMementoAttributesProto[]|null);
            memento_list_hash?: (string|null);
        }

        class GetMementoListOutProto implements IGetMementoListOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMementoListOutProto);
            public status: POGOProtos.Rpc.GetMementoListOutProto.Status;
            public mementos: POGOProtos.Rpc.IMementoAttributesProto[];
            public memento_list_hash: string;
            public static encode(message: POGOProtos.Rpc.IGetMementoListOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMementoListOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMementoListOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMementoListOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMementoListOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_MEMENTO_TYPE_NOT_ENABLED = 2,
                ERROR_INVALID_REQUEST = 3,
                NOT_MODIFIED = 4
            }
        }

        interface IGetMementoListProto {
            memento_types?: (POGOProtos.Rpc.MementoType[]|null);
            s2_cell_location_bounds?: ((number|Long)[]|null);
            time_bound_start_ms?: (number|Long|null);
            time_bound_end_ms?: (number|Long|null);
            memento_list_hash?: (string|null);
        }

        class GetMementoListProto implements IGetMementoListProto {
            constructor(properties?: POGOProtos.Rpc.IGetMementoListProto);
            public memento_types: POGOProtos.Rpc.MementoType[];
            public s2_cell_location_bounds: (number|Long)[];
            public time_bound_start_ms: (number|Long);
            public time_bound_end_ms: (number|Long);
            public memento_list_hash: string;
            public static encode(message: POGOProtos.Rpc.IGetMementoListProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMementoListProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMementoListProto;
            public static toObject(message: POGOProtos.Rpc.GetMementoListProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMilestonesOutProto {
            referrer_milestone?: (POGOProtos.Rpc.IReferralMilestonesProto[]|null);
            referee_milestone?: (POGOProtos.Rpc.IReferralMilestonesProto[]|null);
            status?: (POGOProtos.Rpc.GetMilestonesOutProto.Status|null);
        }

        class GetMilestonesOutProto implements IGetMilestonesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMilestonesOutProto);
            public referrer_milestone: POGOProtos.Rpc.IReferralMilestonesProto[];
            public referee_milestone: POGOProtos.Rpc.IReferralMilestonesProto[];
            public status: POGOProtos.Rpc.GetMilestonesOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IGetMilestonesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMilestonesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMilestonesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMilestonesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMilestonesOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IGetMilestonesPreviewOutProto {
            status?: (POGOProtos.Rpc.GetMilestonesPreviewOutProto.Status|null);
            referrer_milestones?: (POGOProtos.Rpc.IReferralMilestonesProto|null);
        }

        class GetMilestonesPreviewOutProto implements IGetMilestonesPreviewOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMilestonesPreviewOutProto);
            public status: POGOProtos.Rpc.GetMilestonesPreviewOutProto.Status;
            public referrer_milestones?: (POGOProtos.Rpc.IReferralMilestonesProto|null);
            public static encode(message: POGOProtos.Rpc.IGetMilestonesPreviewOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMilestonesPreviewOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMilestonesPreviewOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMilestonesPreviewOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetMilestonesPreviewOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2
            }
        }

        interface IGetMilestonesPreviewProto {
        }

        class GetMilestonesPreviewProto implements IGetMilestonesPreviewProto {
            constructor(properties?: POGOProtos.Rpc.IGetMilestonesPreviewProto);
            public static encode(message: POGOProtos.Rpc.IGetMilestonesPreviewProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMilestonesPreviewProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMilestonesPreviewProto;
            public static toObject(message: POGOProtos.Rpc.GetMilestonesPreviewProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMilestonesProto {
        }

        class GetMilestonesProto implements IGetMilestonesProto {
            constructor(properties?: POGOProtos.Rpc.IGetMilestonesProto);
            public static encode(message: POGOProtos.Rpc.IGetMilestonesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMilestonesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMilestonesProto;
            public static toObject(message: POGOProtos.Rpc.GetMilestonesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMpSummaryOutProto {
            mp_collected_today?: (number|null);
            mp_daily_limit?: (number|null);
        }

        class GetMpSummaryOutProto implements IGetMpSummaryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetMpSummaryOutProto);
            public mp_collected_today: number;
            public mp_daily_limit: number;
            public static encode(message: POGOProtos.Rpc.IGetMpSummaryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMpSummaryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMpSummaryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetMpSummaryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetMpSummaryProto {
        }

        class GetMpSummaryProto implements IGetMpSummaryProto {
            constructor(properties?: POGOProtos.Rpc.IGetMpSummaryProto);
            public static encode(message: POGOProtos.Rpc.IGetMpSummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetMpSummaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetMpSummaryProto;
            public static toObject(message: POGOProtos.Rpc.GetMpSummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetNewQuestsOutProto {
            status?: (POGOProtos.Rpc.GetNewQuestsOutProto.Status|null);
            quests?: (POGOProtos.Rpc.IClientQuestProto[]|null);
            version_changed_quests?: (POGOProtos.Rpc.IClientQuestProto[]|null);
        }

        class GetNewQuestsOutProto implements IGetNewQuestsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetNewQuestsOutProto);
            public status: POGOProtos.Rpc.GetNewQuestsOutProto.Status;
            public quests: POGOProtos.Rpc.IClientQuestProto[];
            public version_changed_quests: POGOProtos.Rpc.IClientQuestProto[];
            public static encode(message: POGOProtos.Rpc.IGetNewQuestsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNewQuestsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNewQuestsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetNewQuestsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetNewQuestsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_DISPLAY = 2
            }
        }

        interface IGetNewQuestsProto {
        }

        class GetNewQuestsProto implements IGetNewQuestsProto {
            constructor(properties?: POGOProtos.Rpc.IGetNewQuestsProto);
            public static encode(message: POGOProtos.Rpc.IGetNewQuestsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNewQuestsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNewQuestsProto;
            public static toObject(message: POGOProtos.Rpc.GetNewQuestsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetNintendoAccountOutProto {
            status?: (POGOProtos.Rpc.GetNintendoAccountOutProto.Status|null);
            linked_naid?: (string|null);
            pokemon_home_trainer_name?: (string|null);
            support_id?: (string|null);
        }

        class GetNintendoAccountOutProto implements IGetNintendoAccountOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetNintendoAccountOutProto);
            public status: POGOProtos.Rpc.GetNintendoAccountOutProto.Status;
            public linked_naid: string;
            public pokemon_home_trainer_name: string;
            public support_id: string;
            public static encode(message: POGOProtos.Rpc.IGetNintendoAccountOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNintendoAccountOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNintendoAccountOutProto;
            public static toObject(message: POGOProtos.Rpc.GetNintendoAccountOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetNintendoAccountOutProto {

            enum Status {
                UNKNOWN = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                ERROR_PLAYER_NOT_USING_PH_APP = 3,
                ERROR_PHAPI_UNKNOWN = 4,
                ERROR_RELOGIN_TO_PH_APP_NEEDED = 5
            }
        }

        interface IGetNintendoAccountProto {
        }

        class GetNintendoAccountProto implements IGetNintendoAccountProto {
            constructor(properties?: POGOProtos.Rpc.IGetNintendoAccountProto);
            public static encode(message: POGOProtos.Rpc.IGetNintendoAccountProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNintendoAccountProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNintendoAccountProto;
            public static toObject(message: POGOProtos.Rpc.GetNintendoAccountProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetNintendoOAuth2UrlOutProto {
            status?: (POGOProtos.Rpc.GetNintendoOAuth2UrlOutProto.Status|null);
            url?: (string|null);
        }

        class GetNintendoOAuth2UrlOutProto implements IGetNintendoOAuth2UrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetNintendoOAuth2UrlOutProto);
            public status: POGOProtos.Rpc.GetNintendoOAuth2UrlOutProto.Status;
            public url: string;
            public static encode(message: POGOProtos.Rpc.IGetNintendoOAuth2UrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNintendoOAuth2UrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNintendoOAuth2UrlOutProto;
            public static toObject(message: POGOProtos.Rpc.GetNintendoOAuth2UrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetNintendoOAuth2UrlOutProto {

            enum Status {
                UNKNOWN = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                ERROR_PLAYER_SIGNED_IN = 3
            }
        }

        interface IGetNintendoOAuth2UrlProto {
            deep_link_app_scheme?: (string|null);
        }

        class GetNintendoOAuth2UrlProto implements IGetNintendoOAuth2UrlProto {
            constructor(properties?: POGOProtos.Rpc.IGetNintendoOAuth2UrlProto);
            public deep_link_app_scheme: string;
            public static encode(message: POGOProtos.Rpc.IGetNintendoOAuth2UrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNintendoOAuth2UrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNintendoOAuth2UrlProto;
            public static toObject(message: POGOProtos.Rpc.GetNintendoOAuth2UrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetNpcCombatRewardsOutProto {
            result?: (POGOProtos.Rpc.GetNpcCombatRewardsOutProto.Result|null);
            reward_status?: (POGOProtos.Rpc.CombatRewardStatus|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            number_rewarded_npc_battles_today?: (number|null);
        }

        class GetNpcCombatRewardsOutProto implements IGetNpcCombatRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetNpcCombatRewardsOutProto);
            public result: POGOProtos.Rpc.GetNpcCombatRewardsOutProto.Result;
            public reward_status: POGOProtos.Rpc.CombatRewardStatus;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public number_rewarded_npc_battles_today: number;
            public static encode(message: POGOProtos.Rpc.IGetNpcCombatRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNpcCombatRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNpcCombatRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetNpcCombatRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetNpcCombatRewardsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALD_NUMBER_ATTACKING_POKEMON_IDS = 2
            }
        }

        interface IGetNpcCombatRewardsProto {
            combat_npc_trainer_template_id?: (string|null);
            finish_state?: (POGOProtos.Rpc.CombatPlayerFinishState|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            combat_id?: (string|null);
            combat_quest_update?: (POGOProtos.Rpc.ICombatQuestUpdateProto|null);
        }

        class GetNpcCombatRewardsProto implements IGetNpcCombatRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IGetNpcCombatRewardsProto);
            public combat_npc_trainer_template_id: string;
            public finish_state: POGOProtos.Rpc.CombatPlayerFinishState;
            public attacking_pokemon_id: (number|Long)[];
            public combat_id: string;
            public combat_quest_update?: (POGOProtos.Rpc.ICombatQuestUpdateProto|null);
            public static encode(message: POGOProtos.Rpc.IGetNpcCombatRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNpcCombatRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNpcCombatRewardsProto;
            public static toObject(message: POGOProtos.Rpc.GetNpcCombatRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetNumStationAssistsOutProto {
            num_station_assists?: (number|null);
            candy_amount?: (number|null);
            xl_candy_amount?: (number|null);
            powerspot_title?: (string|null);
        }

        class GetNumStationAssistsOutProto implements IGetNumStationAssistsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetNumStationAssistsOutProto);
            public num_station_assists: number;
            public candy_amount: number;
            public xl_candy_amount: number;
            public powerspot_title: string;
            public static encode(message: POGOProtos.Rpc.IGetNumStationAssistsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNumStationAssistsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNumStationAssistsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetNumStationAssistsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetNumStationAssistsProto {
            pokemon_id?: (number|Long|null);
        }

        class GetNumStationAssistsProto implements IGetNumStationAssistsProto {
            constructor(properties?: POGOProtos.Rpc.IGetNumStationAssistsProto);
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetNumStationAssistsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetNumStationAssistsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetNumStationAssistsProto;
            public static toObject(message: POGOProtos.Rpc.GetNumStationAssistsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetOutstandingWarningsRequestProto {
        }

        class GetOutstandingWarningsRequestProto implements IGetOutstandingWarningsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetOutstandingWarningsRequestProto);
            public static encode(message: POGOProtos.Rpc.IGetOutstandingWarningsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetOutstandingWarningsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetOutstandingWarningsRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetOutstandingWarningsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetOutstandingWarningsResponseProto {
            outstanding_warning?: (POGOProtos.Rpc.GetOutstandingWarningsResponseProto.IWarningInfo[]|null);
        }

        class GetOutstandingWarningsResponseProto implements IGetOutstandingWarningsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetOutstandingWarningsResponseProto);
            public outstanding_warning: POGOProtos.Rpc.GetOutstandingWarningsResponseProto.IWarningInfo[];
            public static encode(message: POGOProtos.Rpc.IGetOutstandingWarningsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetOutstandingWarningsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetOutstandingWarningsResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetOutstandingWarningsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetOutstandingWarningsResponseProto {

            interface IWarningInfo {
                type?: (POGOProtos.Rpc.PlatformWarningType|null);
                source?: (POGOProtos.Rpc.Source|null);
                start_timestamp_ms?: (number|Long|null);
                end_timestamp_ms?: (number|Long|null);
                reason_statements?: (POGOProtos.Rpc.IStatementOfReason[]|null);
            }

            class WarningInfo implements IWarningInfo {
                constructor(properties?: POGOProtos.Rpc.GetOutstandingWarningsResponseProto.IWarningInfo);
                public type: POGOProtos.Rpc.PlatformWarningType;
                public source: POGOProtos.Rpc.Source;
                public start_timestamp_ms: (number|Long);
                public end_timestamp_ms: (number|Long);
                public reason_statements: POGOProtos.Rpc.IStatementOfReason[];
                public static encode(message: POGOProtos.Rpc.GetOutstandingWarningsResponseProto.IWarningInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetOutstandingWarningsResponseProto.WarningInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetOutstandingWarningsResponseProto.WarningInfo;
                public static toObject(message: POGOProtos.Rpc.GetOutstandingWarningsResponseProto.WarningInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetPartyHistoryOutProto {
            result?: (POGOProtos.Rpc.GetPartyHistoryOutProto.Result|null);
            party_history?: (POGOProtos.Rpc.IPartyHistoryRpcProto|null);
        }

        class GetPartyHistoryOutProto implements IGetPartyHistoryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPartyHistoryOutProto);
            public result: POGOProtos.Rpc.GetPartyHistoryOutProto.Result;
            public party_history?: (POGOProtos.Rpc.IPartyHistoryRpcProto|null);
            public static encode(message: POGOProtos.Rpc.IGetPartyHistoryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyHistoryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyHistoryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPartyHistoryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPartyHistoryOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_PARTY_HISTORY_NOT_FOUND = 3,
                ERROR_PLAYER_NOT_IN_PARTY = 4
            }
        }

        interface IGetPartyHistoryProto {
            party_id?: (number|Long|null);
            party_seed?: (number|Long|null);
        }

        class GetPartyHistoryProto implements IGetPartyHistoryProto {
            constructor(properties?: POGOProtos.Rpc.IGetPartyHistoryProto);
            public party_id: (number|Long);
            public party_seed: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetPartyHistoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyHistoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyHistoryProto;
            public static toObject(message: POGOProtos.Rpc.GetPartyHistoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPartyOutProto {
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            result?: (POGOProtos.Rpc.GetPartyOutProto.Result|null);
            player_locations?: (POGOProtos.Rpc.IPartyLocationsRpcProto|null);
            activity_summary?: (POGOProtos.Rpc.IPartyActivitySummaryRpcProto|null);
            item_limits?: (POGOProtos.Rpc.GetPartyOutProto.IItemLimit[]|null);
            party_play_result?: (POGOProtos.Rpc.GetPartyOutProto.IPartyPlayProto|null);
            weekly_challenge_party_result?: (POGOProtos.Rpc.GetPartyOutProto.IWeeklyChallengePartyProto|null);
        }

        class GetPartyOutProto implements IGetPartyOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPartyOutProto);
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public result: POGOProtos.Rpc.GetPartyOutProto.Result;
            public player_locations?: (POGOProtos.Rpc.IPartyLocationsRpcProto|null);
            public activity_summary?: (POGOProtos.Rpc.IPartyActivitySummaryRpcProto|null);
            public item_limits: POGOProtos.Rpc.GetPartyOutProto.IItemLimit[];
            public party_play_result?: (POGOProtos.Rpc.GetPartyOutProto.IPartyPlayProto|null);
            public weekly_challenge_party_result?: (POGOProtos.Rpc.GetPartyOutProto.IWeeklyChallengePartyProto|null);
            public PartyResult?: ("party_play_result"|"weekly_challenge_party_result");
            public static encode(message: POGOProtos.Rpc.IGetPartyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPartyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPartyOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_PARTY_NOT_FOUND = 3,
                ERROR_PLAYER_NOT_IN_PARTY = 4,
                ERROR_FEATURE_DISABLED = 5,
                ERROR_PLAYER_LEVEL_TOO_LOW = 6,
                ERROR_REDIS_EXCEPTION = 7,
                ERROR_PARTY_TIMED_OUT = 8,
                ERROR_PLFE_REDIRECT_NEEDED = 9
            }

            interface IItemLimit {
                item?: (POGOProtos.Rpc.Item|null);
                limit_reached?: (boolean|null);
            }

            class ItemLimit implements IItemLimit {
                constructor(properties?: POGOProtos.Rpc.GetPartyOutProto.IItemLimit);
                public item: POGOProtos.Rpc.Item;
                public limit_reached: boolean;
                public static encode(message: POGOProtos.Rpc.GetPartyOutProto.IItemLimit, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyOutProto.ItemLimit;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyOutProto.ItemLimit;
                public static toObject(message: POGOProtos.Rpc.GetPartyOutProto.ItemLimit, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPartyPlayProto {
                party?: (POGOProtos.Rpc.IPartyRpcProto|null);
                player_locations?: (POGOProtos.Rpc.IPartyLocationsRpcProto|null);
                activity_summary?: (POGOProtos.Rpc.IPartyActivitySummaryRpcProto|null);
            }

            class PartyPlayProto implements IPartyPlayProto {
                constructor(properties?: POGOProtos.Rpc.GetPartyOutProto.IPartyPlayProto);
                public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
                public player_locations?: (POGOProtos.Rpc.IPartyLocationsRpcProto|null);
                public activity_summary?: (POGOProtos.Rpc.IPartyActivitySummaryRpcProto|null);
                public static encode(message: POGOProtos.Rpc.GetPartyOutProto.IPartyPlayProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyOutProto.PartyPlayProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyOutProto.PartyPlayProto;
                public static toObject(message: POGOProtos.Rpc.GetPartyOutProto.PartyPlayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWeeklyChallengePartyProto {
                parties?: (POGOProtos.Rpc.IPartyRpcProto[]|null);
                invites?: (POGOProtos.Rpc.IPartyInviteRpcProto[]|null);
            }

            class WeeklyChallengePartyProto implements IWeeklyChallengePartyProto {
                constructor(properties?: POGOProtos.Rpc.GetPartyOutProto.IWeeklyChallengePartyProto);
                public parties: POGOProtos.Rpc.IPartyRpcProto[];
                public invites: POGOProtos.Rpc.IPartyInviteRpcProto[];
                public static encode(message: POGOProtos.Rpc.GetPartyOutProto.IWeeklyChallengePartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyOutProto.WeeklyChallengePartyProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyOutProto.WeeklyChallengePartyProto;
                public static toObject(message: POGOProtos.Rpc.GetPartyOutProto.WeeklyChallengePartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetPartyProto {
            party_type?: (POGOProtos.Rpc.PartyType|null);
            activity_summary_requested?: (boolean|null);
            player_locations_requested?: (boolean|null);
            party_rpc_not_requested?: (boolean|null);
            invites_requested?: (boolean|null);
            party_id?: (number[]|null);
            party_seed?: (number|Long|null);
        }

        class GetPartyProto implements IGetPartyProto {
            constructor(properties?: POGOProtos.Rpc.IGetPartyProto);
            public party_type: POGOProtos.Rpc.PartyType;
            public activity_summary_requested: boolean;
            public player_locations_requested: boolean;
            public party_rpc_not_requested: boolean;
            public invites_requested: boolean;
            public party_id: number[];
            public party_seed: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetPartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPartyProto;
            public static toObject(message: POGOProtos.Rpc.GetPartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPhotobombOutProto {
            status?: (POGOProtos.Rpc.GetPhotobombOutProto.Status|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            lat?: (number|null);
            lng?: (number|null);
            encounter_location?: (string|null);
            encounter_id?: (number|Long|null);
            disappear_time_ms?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class GetPhotobombOutProto implements IGetPhotobombOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPhotobombOutProto);
            public status: POGOProtos.Rpc.GetPhotobombOutProto.Status;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public lat: number;
            public lng: number;
            public encounter_location: string;
            public encounter_id: (number|Long);
            public disappear_time_ms: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IGetPhotobombOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPhotobombOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPhotobombOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPhotobombOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPhotobombOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                PHOTOBOMB_NOT_AVAILABLE = 2,
                ENCOUNTER_ALREADY_COMPLETED = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface IGetPhotobombProto {
        }

        class GetPhotobombProto implements IGetPhotobombProto {
            constructor(properties?: POGOProtos.Rpc.IGetPhotobombProto);
            public static encode(message: POGOProtos.Rpc.IGetPhotobombProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPhotobombProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPhotobombProto;
            public static toObject(message: POGOProtos.Rpc.GetPhotobombProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPlayerDayOutProto {
            result?: (POGOProtos.Rpc.GetPlayerDayOutProto.Result|null);
            day?: (number|Long|null);
        }

        class GetPlayerDayOutProto implements IGetPlayerDayOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerDayOutProto);
            public result: POGOProtos.Rpc.GetPlayerDayOutProto.Result;
            public day: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetPlayerDayOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerDayOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerDayOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerDayOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPlayerDayOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IGetPlayerDayProto {
        }

        class GetPlayerDayProto implements IGetPlayerDayProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerDayProto);
            public static encode(message: POGOProtos.Rpc.IGetPlayerDayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerDayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerDayProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerDayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPlayerGpsBookmarksOutProto {
            result?: (POGOProtos.Rpc.GetPlayerGpsBookmarksOutProto.Result|null);
            gps_bookmarks?: (POGOProtos.Rpc.IGpsBookmarkProto[]|null);
        }

        class GetPlayerGpsBookmarksOutProto implements IGetPlayerGpsBookmarksOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerGpsBookmarksOutProto);
            public result: POGOProtos.Rpc.GetPlayerGpsBookmarksOutProto.Result;
            public gps_bookmarks: POGOProtos.Rpc.IGpsBookmarkProto[];
            public static encode(message: POGOProtos.Rpc.IGetPlayerGpsBookmarksOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerGpsBookmarksOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerGpsBookmarksOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerGpsBookmarksOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPlayerGpsBookmarksOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                CANNOT_GET_BOOKMARKS = 2
            }
        }

        interface IGetPlayerGpsBookmarksProto {
        }

        class GetPlayerGpsBookmarksProto implements IGetPlayerGpsBookmarksProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerGpsBookmarksProto);
            public static encode(message: POGOProtos.Rpc.IGetPlayerGpsBookmarksProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerGpsBookmarksProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerGpsBookmarksProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerGpsBookmarksProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPlayerOutProto {
            success?: (boolean|null);
            player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            banned?: (boolean|null);
            warn?: (boolean|null);
            was_created?: (boolean|null);
            warn_message_acknowledged?: (boolean|null);
            was_suspended?: (boolean|null);
            suspended_message_acknowledged?: (boolean|null);
            warn_expire_ms?: (number|Long|null);
            user_permission?: (number[]|null);
            server_calculated_player_locale?: (POGOProtos.Rpc.IPlayerLocaleProto|null);
            user_needs_age_confirmation?: (boolean|null);
            user_failed_age_confirmation?: (boolean|null);
        }

        class GetPlayerOutProto implements IGetPlayerOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerOutProto);
            public success: boolean;
            public player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public banned: boolean;
            public warn: boolean;
            public was_created: boolean;
            public warn_message_acknowledged: boolean;
            public was_suspended: boolean;
            public suspended_message_acknowledged: boolean;
            public warn_expire_ms: (number|Long);
            public user_permission: number[];
            public server_calculated_player_locale?: (POGOProtos.Rpc.IPlayerLocaleProto|null);
            public user_needs_age_confirmation: boolean;
            public user_failed_age_confirmation: boolean;
            public static encode(message: POGOProtos.Rpc.IGetPlayerOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPlayerProto {
            player_locale?: (POGOProtos.Rpc.IPlayerLocaleProto|null);
            prevent_creation?: (boolean|null);
            is_boot_process?: (boolean|null);
        }

        class GetPlayerProto implements IGetPlayerProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerProto);
            public player_locale?: (POGOProtos.Rpc.IPlayerLocaleProto|null);
            public prevent_creation: boolean;
            public is_boot_process: boolean;
            public static encode(message: POGOProtos.Rpc.IGetPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPlayerStampCollectionsOutProto {
            collections?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto[]|null);
        }

        class GetPlayerStampCollectionsOutProto implements IGetPlayerStampCollectionsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerStampCollectionsOutProto);
            public collections: POGOProtos.Rpc.IPlayerRpcStampCollectionProto[];
            public static encode(message: POGOProtos.Rpc.IGetPlayerStampCollectionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerStampCollectionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerStampCollectionsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerStampCollectionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPlayerStampCollectionsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IGetPlayerStampCollectionsProto {
        }

        class GetPlayerStampCollectionsProto implements IGetPlayerStampCollectionsProto {
            constructor(properties?: POGOProtos.Rpc.IGetPlayerStampCollectionsProto);
            public static encode(message: POGOProtos.Rpc.IGetPlayerStampCollectionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPlayerStampCollectionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPlayerStampCollectionsProto;
            public static toObject(message: POGOProtos.Rpc.GetPlayerStampCollectionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPokemonSizeLeaderboardEntryOutProto {
            status?: (POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryOutProto.Status|null);
            total_entries?: (number|null);
            contest_entries?: (POGOProtos.Rpc.IContestEntryProto[]|null);
        }

        class GetPokemonSizeLeaderboardEntryOutProto implements IGetPokemonSizeLeaderboardEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryOutProto);
            public status: POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryOutProto.Status;
            public total_entries: number;
            public contest_entries: POGOProtos.Rpc.IContestEntryProto[];
            public static encode(message: POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPokemonSizeLeaderboardEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                INVALID_INDEX = 3,
                ENTRY_NOT_FOUND = 4
            }
        }

        interface IGetPokemonSizeLeaderboardEntryProto {
            contest_id?: (string|null);
            start_index?: (number|null);
            end_index?: (number|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            is_relative_to_player?: (boolean|null);
        }

        class GetPokemonSizeLeaderboardEntryProto implements IGetPokemonSizeLeaderboardEntryProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryProto);
            public contest_id: string;
            public start_index: number;
            public end_index: number;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public is_relative_to_player: boolean;
            public static encode(message: POGOProtos.Rpc.IGetPokemonSizeLeaderboardEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryProto;
            public static toObject(message: POGOProtos.Rpc.GetPokemonSizeLeaderboardEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPokemonSizeLeaderboardFriendEntryOutProto {
            status?: (POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryOutProto.Status|null);
            total_friend_entries?: (number|null);
            contest_friend_entries?: (POGOProtos.Rpc.IContestFriendEntryProto[]|null);
        }

        class GetPokemonSizeLeaderboardFriendEntryOutProto implements IGetPokemonSizeLeaderboardFriendEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryOutProto);
            public status: POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryOutProto.Status;
            public total_friend_entries: number;
            public contest_friend_entries: POGOProtos.Rpc.IContestFriendEntryProto[];
            public static encode(message: POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPokemonSizeLeaderboardFriendEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ACCESS_DENIED = 3
            }
        }

        interface IGetPokemonSizeLeaderboardFriendEntryProto {
            contest_id?: (string|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
        }

        class GetPokemonSizeLeaderboardFriendEntryProto implements IGetPokemonSizeLeaderboardFriendEntryProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryProto);
            public contest_id: string;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public static encode(message: POGOProtos.Rpc.IGetPokemonSizeLeaderboardFriendEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryProto;
            public static toObject(message: POGOProtos.Rpc.GetPokemonSizeLeaderboardFriendEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPokemonTagsOutProto {
            result?: (POGOProtos.Rpc.GetPokemonTagsOutProto.Result|null);
            tag?: (POGOProtos.Rpc.IPokemonTagProto[]|null);
            should_show_tags_tutorial?: (boolean|null);
        }

        class GetPokemonTagsOutProto implements IGetPokemonTagsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokemonTagsOutProto);
            public result: POGOProtos.Rpc.GetPokemonTagsOutProto.Result;
            public tag: POGOProtos.Rpc.IPokemonTagProto[];
            public should_show_tags_tutorial: boolean;
            public static encode(message: POGOProtos.Rpc.IGetPokemonTagsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokemonTagsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokemonTagsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPokemonTagsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPokemonTagsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2
            }
        }

        interface IGetPokemonTagsProto {
        }

        class GetPokemonTagsProto implements IGetPokemonTagsProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokemonTagsProto);
            public static encode(message: POGOProtos.Rpc.IGetPokemonTagsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokemonTagsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokemonTagsProto;
            public static toObject(message: POGOProtos.Rpc.GetPokemonTagsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPokestopEncounterOutProto {
            status?: (POGOProtos.Rpc.GetPokestopEncounterOutProto.Status|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            lat?: (number|null);
            lng?: (number|null);
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
            disappear_time_ms?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            pokemon_size?: (POGOProtos.Rpc.HoloPokemonSize|null);
        }

        class GetPokestopEncounterOutProto implements IGetPokestopEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokestopEncounterOutProto);
            public status: POGOProtos.Rpc.GetPokestopEncounterOutProto.Status;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public lat: number;
            public lng: number;
            public encounter_id: (number|Long);
            public encounter_location: string;
            public disappear_time_ms: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public pokemon_size: POGOProtos.Rpc.HoloPokemonSize;
            public static encode(message: POGOProtos.Rpc.IGetPokestopEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokestopEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokestopEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPokestopEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPokestopEncounterOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                POKESTOP_ENCOUNTER_NOT_AVAILABLE = 2,
                ENCOUNTER_ALREADY_COMPLETED = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface IGetPokestopEncounterProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            encounter_location?: (string|null);
            fort_id?: (string|null);
        }

        class GetPokestopEncounterProto implements IGetPokestopEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IGetPokestopEncounterProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public encounter_location: string;
            public fort_id: string;
            public static encode(message: POGOProtos.Rpc.IGetPokestopEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPokestopEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPokestopEncounterProto;
            public static toObject(message: POGOProtos.Rpc.GetPokestopEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetPublishedRoutesOutProto {
            result?: (POGOProtos.Rpc.GetPublishedRoutesOutProto.Result|null);
            routes?: (POGOProtos.Rpc.ISharedRouteProto[]|null);
            unseen_updates?: (string[]|null);
        }

        class GetPublishedRoutesOutProto implements IGetPublishedRoutesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetPublishedRoutesOutProto);
            public result: POGOProtos.Rpc.GetPublishedRoutesOutProto.Result;
            public routes: POGOProtos.Rpc.ISharedRouteProto[];
            public unseen_updates: string[];
            public static encode(message: POGOProtos.Rpc.IGetPublishedRoutesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPublishedRoutesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPublishedRoutesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetPublishedRoutesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetPublishedRoutesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IGetPublishedRoutesProto {
        }

        class GetPublishedRoutesProto implements IGetPublishedRoutesProto {
            constructor(properties?: POGOProtos.Rpc.IGetPublishedRoutesProto);
            public static encode(message: POGOProtos.Rpc.IGetPublishedRoutesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetPublishedRoutesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetPublishedRoutesProto;
            public static toObject(message: POGOProtos.Rpc.GetPublishedRoutesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetQuestDetailsOutProto {
            status?: (POGOProtos.Rpc.GetQuestDetailsOutProto.Status|null);
            quests?: (POGOProtos.Rpc.IClientQuestProto[]|null);
        }

        class GetQuestDetailsOutProto implements IGetQuestDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetQuestDetailsOutProto);
            public status: POGOProtos.Rpc.GetQuestDetailsOutProto.Status;
            public quests: POGOProtos.Rpc.IClientQuestProto[];
            public static encode(message: POGOProtos.Rpc.IGetQuestDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetQuestDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetQuestDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetQuestDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetQuestDetailsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_QUEST_NOT_FOUND = 2,
                ERROR_INVALID_DISPLAY = 3
            }
        }

        interface IGetQuestDetailsProto {
            quest_id?: (string[]|null);
        }

        class GetQuestDetailsProto implements IGetQuestDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetQuestDetailsProto);
            public quest_id: string[];
            public static encode(message: POGOProtos.Rpc.IGetQuestDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetQuestDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetQuestDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetQuestDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetQuestUiOutProto {
            status?: (POGOProtos.Rpc.GetQuestUiOutProto.Status|null);
            season_view?: (POGOProtos.Rpc.ICustomizeQuestTabProto|null);
            today_view?: (POGOProtos.Rpc.ICustomizeQuestTabProto|null);
            special_view?: (POGOProtos.Rpc.ICustomizeQuestTabProto|null);
            has_notification?: (boolean|null);
            is_notification_new?: (boolean|null);
        }

        class GetQuestUiOutProto implements IGetQuestUiOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetQuestUiOutProto);
            public status: POGOProtos.Rpc.GetQuestUiOutProto.Status;
            public season_view?: (POGOProtos.Rpc.ICustomizeQuestTabProto|null);
            public today_view?: (POGOProtos.Rpc.ICustomizeQuestTabProto|null);
            public special_view?: (POGOProtos.Rpc.ICustomizeQuestTabProto|null);
            public has_notification: boolean;
            public is_notification_new: boolean;
            public static encode(message: POGOProtos.Rpc.IGetQuestUiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetQuestUiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetQuestUiOutProto;
            public static toObject(message: POGOProtos.Rpc.GetQuestUiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetQuestUiOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IGetQuestUiProto {
            last_opened_today_view_ms?: (number|Long|null);
        }

        class GetQuestUiProto implements IGetQuestUiProto {
            constructor(properties?: POGOProtos.Rpc.IGetQuestUiProto);
            public last_opened_today_view_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetQuestUiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetQuestUiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetQuestUiProto;
            public static toObject(message: POGOProtos.Rpc.GetQuestUiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRaidDetailsData {
            rpc_id?: (number|null);
        }

        class GetRaidDetailsData implements IGetRaidDetailsData {
            constructor(properties?: POGOProtos.Rpc.IGetRaidDetailsData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IGetRaidDetailsData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRaidDetailsData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRaidDetailsData;
            public static toObject(message: POGOProtos.Rpc.GetRaidDetailsData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRaidDetailsOutProto {
            lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            raid_battle?: (POGOProtos.Rpc.IBattleProto|null);
            player_can_join_lobby?: (boolean|null);
            result?: (POGOProtos.Rpc.GetRaidDetailsOutProto.Result|null);
            raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            ticket_used?: (boolean|null);
            free_ticket_available?: (boolean|null);
            throws_remaining?: (number|null);
            received_rewards?: (boolean|null);
            num_players_in_lobby?: (number|null);
            server_ms?: (number|Long|null);
            server_instance?: (number|null);
            display_high_user_warning?: (boolean|null);
            num_friend_invites_remaining?: (number|null);
            remote_ticket_used?: (boolean|null);
            is_within_plfe_range?: (boolean|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            lobby_creation_ms?: (number|Long|null);
            lobby_join_end_ms?: (number|Long|null);
            rvn_battle_completed?: (boolean|null);
            rvn_battle_flushed?: (boolean|null);
            rvn_battle_is_victory?: (boolean|null);
            raid_ball?: (POGOProtos.Rpc.Item|null);
            capture_probabilities?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto|null);
        }

        class GetRaidDetailsOutProto implements IGetRaidDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRaidDetailsOutProto);
            public lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            public raid_battle?: (POGOProtos.Rpc.IBattleProto|null);
            public player_can_join_lobby: boolean;
            public result: POGOProtos.Rpc.GetRaidDetailsOutProto.Result;
            public raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            public ticket_used: boolean;
            public free_ticket_available: boolean;
            public throws_remaining: number;
            public received_rewards: boolean;
            public num_players_in_lobby: number;
            public server_ms: (number|Long);
            public server_instance: number;
            public display_high_user_warning: boolean;
            public num_friend_invites_remaining: number;
            public remote_ticket_used: boolean;
            public is_within_plfe_range: boolean;
            public active_item: POGOProtos.Rpc.Item;
            public lobby_creation_ms: (number|Long);
            public lobby_join_end_ms: (number|Long);
            public rvn_battle_completed: boolean;
            public rvn_battle_flushed: boolean;
            public rvn_battle_is_victory: boolean;
            public raid_ball: POGOProtos.Rpc.Item;
            public capture_probabilities?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto|null);
            public static encode(message: POGOProtos.Rpc.IGetRaidDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRaidDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRaidDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRaidDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRaidDetailsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_RAID_COMPLETED = 3,
                ERROR_RAID_UNAVAILABLE = 4,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 5,
                ERROR_POI_INACCESSIBLE = 6
            }
        }

        interface IGetRaidDetailsProto {
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
            inviter_id?: (string|null);
            is_self_invite?: (boolean|null);
        }

        class GetRaidDetailsProto implements IGetRaidDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetRaidDetailsProto);
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public inviter_id: string;
            public is_self_invite: boolean;
            public static encode(message: POGOProtos.Rpc.IGetRaidDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRaidDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRaidDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetRaidDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRaidDetailsResponseData {
            result?: (POGOProtos.Rpc.GetRaidDetailsOutProto.Result|null);
            ticket_used?: (boolean|null);
            free_ticket_available?: (boolean|null);
            throws_remaining?: (number|null);
            received_rewards?: (boolean|null);
            num_players_in_lobby?: (number|null);
            server_offset_ms?: (number|null);
            server_instance?: (number|null);
            remote_ticket_used?: (boolean|null);
            is_within_plfe_range?: (boolean|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class GetRaidDetailsResponseData implements IGetRaidDetailsResponseData {
            constructor(properties?: POGOProtos.Rpc.IGetRaidDetailsResponseData);
            public result: POGOProtos.Rpc.GetRaidDetailsOutProto.Result;
            public ticket_used: boolean;
            public free_ticket_available: boolean;
            public throws_remaining: number;
            public received_rewards: boolean;
            public num_players_in_lobby: number;
            public server_offset_ms: number;
            public server_instance: number;
            public remote_ticket_used: boolean;
            public is_within_plfe_range: boolean;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.IGetRaidDetailsResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRaidDetailsResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRaidDetailsResponseData;
            public static toObject(message: POGOProtos.Rpc.GetRaidDetailsResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRaidLobbyCounterOutProto {
            result?: (POGOProtos.Rpc.GetRaidLobbyCounterOutProto.Result|null);
            counter_responses?: (POGOProtos.Rpc.IRaidLobbyCounterData[]|null);
        }

        class GetRaidLobbyCounterOutProto implements IGetRaidLobbyCounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRaidLobbyCounterOutProto);
            public result: POGOProtos.Rpc.GetRaidLobbyCounterOutProto.Result;
            public counter_responses: POGOProtos.Rpc.IRaidLobbyCounterData[];
            public static encode(message: POGOProtos.Rpc.IGetRaidLobbyCounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRaidLobbyCounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRaidLobbyCounterOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRaidLobbyCounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRaidLobbyCounterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 2,
                ERROR_FEATURE_DISABLED = 3
            }
        }

        interface IGetRaidLobbyCounterProto {
            counter_requests?: (POGOProtos.Rpc.IRaidLobbyCounterRequest[]|null);
        }

        class GetRaidLobbyCounterProto implements IGetRaidLobbyCounterProto {
            constructor(properties?: POGOProtos.Rpc.IGetRaidLobbyCounterProto);
            public counter_requests: POGOProtos.Rpc.IRaidLobbyCounterRequest[];
            public static encode(message: POGOProtos.Rpc.IGetRaidLobbyCounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRaidLobbyCounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRaidLobbyCounterProto;
            public static toObject(message: POGOProtos.Rpc.GetRaidLobbyCounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetReferralCodeOutProto {
            status?: (POGOProtos.Rpc.GetReferralCodeOutProto.Status|null);
            referral_code?: (string|null);
        }

        class GetReferralCodeOutProto implements IGetReferralCodeOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetReferralCodeOutProto);
            public status: POGOProtos.Rpc.GetReferralCodeOutProto.Status;
            public referral_code: string;
            public static encode(message: POGOProtos.Rpc.IGetReferralCodeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetReferralCodeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetReferralCodeOutProto;
            public static toObject(message: POGOProtos.Rpc.GetReferralCodeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetReferralCodeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2,
                ERROR_UNAVAILABLE = 3,
                ERROR_GENERATING_IN_COOL_DOWN = 4
            }
        }

        interface IGetReferralCodeProto {
            regenerate?: (boolean|null);
        }

        class GetReferralCodeProto implements IGetReferralCodeProto {
            constructor(properties?: POGOProtos.Rpc.IGetReferralCodeProto);
            public regenerate: boolean;
            public static encode(message: POGOProtos.Rpc.IGetReferralCodeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetReferralCodeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetReferralCodeProto;
            public static toObject(message: POGOProtos.Rpc.GetReferralCodeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRemoteConfigVersionsOutProto {
            result?: (POGOProtos.Rpc.GetRemoteConfigVersionsOutProto.Result|null);
            game_master_timestamp?: (number|Long|null);
            asset_digest_timestamp?: (number|Long|null);
            experiment_id?: (number[]|null);
            should_call_set_player_status_rpc?: (boolean|null);
        }

        class GetRemoteConfigVersionsOutProto implements IGetRemoteConfigVersionsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRemoteConfigVersionsOutProto);
            public result: POGOProtos.Rpc.GetRemoteConfigVersionsOutProto.Result;
            public game_master_timestamp: (number|Long);
            public asset_digest_timestamp: (number|Long);
            public experiment_id: number[];
            public should_call_set_player_status_rpc: boolean;
            public static encode(message: POGOProtos.Rpc.IGetRemoteConfigVersionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRemoteConfigVersionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRemoteConfigVersionsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRemoteConfigVersionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRemoteConfigVersionsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IGetRemoteConfigVersionsProto {
            platform?: (POGOProtos.Rpc.Platform|null);
            device_manufacturer?: (string|null);
            device_model?: (string|null);
            locale?: (string|null);
            app_version?: (number|null);
            store?: (POGOProtos.Rpc.Store|null);
            carrier?: (string|null);
            user_date_of_birth?: (string|null);
            sentry_id?: (string|null);
        }

        class GetRemoteConfigVersionsProto implements IGetRemoteConfigVersionsProto {
            constructor(properties?: POGOProtos.Rpc.IGetRemoteConfigVersionsProto);
            public platform: POGOProtos.Rpc.Platform;
            public device_manufacturer: string;
            public device_model: string;
            public locale: string;
            public app_version: number;
            public store: POGOProtos.Rpc.Store;
            public carrier: string;
            public user_date_of_birth: string;
            public sentry_id: string;
            public static encode(message: POGOProtos.Rpc.IGetRemoteConfigVersionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRemoteConfigVersionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRemoteConfigVersionsProto;
            public static toObject(message: POGOProtos.Rpc.GetRemoteConfigVersionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRewardTiersRequestProto {
        }

        class GetRewardTiersRequestProto implements IGetRewardTiersRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetRewardTiersRequestProto);
            public static encode(message: POGOProtos.Rpc.IGetRewardTiersRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRewardTiersRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRewardTiersRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetRewardTiersRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRewardTiersResponseProto {
            status?: (POGOProtos.Rpc.GetRewardTiersResponseProto.Status|null);
            reward_tier_list?: (POGOProtos.Rpc.IRewardedSpendTierListProto|null);
        }

        class GetRewardTiersResponseProto implements IGetRewardTiersResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetRewardTiersResponseProto);
            public status: POGOProtos.Rpc.GetRewardTiersResponseProto.Status;
            public reward_tier_list?: (POGOProtos.Rpc.IRewardedSpendTierListProto|null);
            public static encode(message: POGOProtos.Rpc.IGetRewardTiersResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRewardTiersResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRewardTiersResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetRewardTiersResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRewardTiersResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IGetRocketBalloonOutProto {
            status?: (POGOProtos.Rpc.GetRocketBalloonOutProto.Status|null);
            display?: (POGOProtos.Rpc.IRocketBalloonDisplayProto|null);
        }

        class GetRocketBalloonOutProto implements IGetRocketBalloonOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRocketBalloonOutProto);
            public status: POGOProtos.Rpc.GetRocketBalloonOutProto.Status;
            public display?: (POGOProtos.Rpc.IRocketBalloonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IGetRocketBalloonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRocketBalloonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRocketBalloonOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRocketBalloonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRocketBalloonOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                IN_COOL_DOWN = 2,
                NO_BALLOON_AVAILABLE = 3,
                DISABLED = 4,
                EQUIPPED_ITEM_INVALID = 5,
                SUCCESS_BALLOON_ALREADY_EXISTS = 6
            }
        }

        interface IGetRocketBalloonProto {
            equipped_item?: (POGOProtos.Rpc.Item|null);
        }

        class GetRocketBalloonProto implements IGetRocketBalloonProto {
            constructor(properties?: POGOProtos.Rpc.IGetRocketBalloonProto);
            public equipped_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IGetRocketBalloonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRocketBalloonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRocketBalloonProto;
            public static toObject(message: POGOProtos.Rpc.GetRocketBalloonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRoomRequest {
            room_id?: (string|null);
        }

        class GetRoomRequest implements IGetRoomRequest {
            constructor(properties?: POGOProtos.Rpc.IGetRoomRequest);
            public room_id: string;
            public static encode(message: POGOProtos.Rpc.IGetRoomRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoomRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoomRequest;
            public static toObject(message: POGOProtos.Rpc.GetRoomRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRoomResponse {
            room?: (POGOProtos.Rpc.IRoom|null);
        }

        class GetRoomResponse implements IGetRoomResponse {
            constructor(properties?: POGOProtos.Rpc.IGetRoomResponse);
            public room?: (POGOProtos.Rpc.IRoom|null);
            public static encode(message: POGOProtos.Rpc.IGetRoomResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoomResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoomResponse;
            public static toObject(message: POGOProtos.Rpc.GetRoomResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRoomsForExperienceRequest {
            experience_ids?: (string[]|null);
        }

        class GetRoomsForExperienceRequest implements IGetRoomsForExperienceRequest {
            constructor(properties?: POGOProtos.Rpc.IGetRoomsForExperienceRequest);
            public experience_ids: string[];
            public static encode(message: POGOProtos.Rpc.IGetRoomsForExperienceRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoomsForExperienceRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoomsForExperienceRequest;
            public static toObject(message: POGOProtos.Rpc.GetRoomsForExperienceRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRoomsForExperienceResponse {
            rooms?: (POGOProtos.Rpc.IRoom[]|null);
        }

        class GetRoomsForExperienceResponse implements IGetRoomsForExperienceResponse {
            constructor(properties?: POGOProtos.Rpc.IGetRoomsForExperienceResponse);
            public rooms: POGOProtos.Rpc.IRoom[];
            public static encode(message: POGOProtos.Rpc.IGetRoomsForExperienceResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoomsForExperienceResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoomsForExperienceResponse;
            public static toObject(message: POGOProtos.Rpc.GetRoomsForExperienceResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRouteByShortCodeOutProto {
            status?: (POGOProtos.Rpc.GetRouteByShortCodeOutProto.Status|null);
            route?: (POGOProtos.Rpc.ISharedRouteProto|null);
        }

        class GetRouteByShortCodeOutProto implements IGetRouteByShortCodeOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRouteByShortCodeOutProto);
            public status: POGOProtos.Rpc.GetRouteByShortCodeOutProto.Status;
            public route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public static encode(message: POGOProtos.Rpc.IGetRouteByShortCodeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRouteByShortCodeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRouteByShortCodeOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRouteByShortCodeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRouteByShortCodeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ROUTE_NOT_FOUND = 3
            }
        }

        interface IGetRouteByShortCodeProto {
            short_code?: (string|null);
        }

        class GetRouteByShortCodeProto implements IGetRouteByShortCodeProto {
            constructor(properties?: POGOProtos.Rpc.IGetRouteByShortCodeProto);
            public short_code: string;
            public static encode(message: POGOProtos.Rpc.IGetRouteByShortCodeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRouteByShortCodeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRouteByShortCodeProto;
            public static toObject(message: POGOProtos.Rpc.GetRouteByShortCodeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRouteCreationsOutProto {
            result?: (POGOProtos.Rpc.GetRouteCreationsOutProto.Result|null);
            routes?: (POGOProtos.Rpc.IRouteCreationProto[]|null);
            unseen_updates?: (string[]|null);
        }

        class GetRouteCreationsOutProto implements IGetRouteCreationsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRouteCreationsOutProto);
            public result: POGOProtos.Rpc.GetRouteCreationsOutProto.Result;
            public routes: POGOProtos.Rpc.IRouteCreationProto[];
            public unseen_updates: string[];
            public static encode(message: POGOProtos.Rpc.IGetRouteCreationsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRouteCreationsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRouteCreationsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRouteCreationsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRouteCreationsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IGetRouteCreationsProto {
        }

        class GetRouteCreationsProto implements IGetRouteCreationsProto {
            constructor(properties?: POGOProtos.Rpc.IGetRouteCreationsProto);
            public static encode(message: POGOProtos.Rpc.IGetRouteCreationsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRouteCreationsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRouteCreationsProto;
            public static toObject(message: POGOProtos.Rpc.GetRouteCreationsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRouteDraftOutProto {
            result?: (POGOProtos.Rpc.GetRouteDraftOutProto.Result|null);
            route?: (POGOProtos.Rpc.IRouteCreationProto|null);
        }

        class GetRouteDraftOutProto implements IGetRouteDraftOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRouteDraftOutProto);
            public result: POGOProtos.Rpc.GetRouteDraftOutProto.Result;
            public route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            public static encode(message: POGOProtos.Rpc.IGetRouteDraftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRouteDraftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRouteDraftOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRouteDraftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRouteDraftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_ROUTE = 3
            }
        }

        interface IGetRouteDraftProto {
            id?: (string|null);
        }

        class GetRouteDraftProto implements IGetRouteDraftProto {
            constructor(properties?: POGOProtos.Rpc.IGetRouteDraftProto);
            public id: string;
            public static encode(message: POGOProtos.Rpc.IGetRouteDraftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRouteDraftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRouteDraftProto;
            public static toObject(message: POGOProtos.Rpc.GetRouteDraftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetRoutesOutProto {
            route_map_cell?: (POGOProtos.Rpc.IClientRouteMapCellProto[]|null);
            status?: (POGOProtos.Rpc.GetRoutesOutProto.Status|null);
            route_tabs?: (POGOProtos.Rpc.GetRoutesOutProto.IRouteTab[]|null);
            route_list?: (POGOProtos.Rpc.IClientRouteGetProto[]|null);
        }

        class GetRoutesOutProto implements IGetRoutesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetRoutesOutProto);
            public route_map_cell: POGOProtos.Rpc.IClientRouteMapCellProto[];
            public status: POGOProtos.Rpc.GetRoutesOutProto.Status;
            public route_tabs: POGOProtos.Rpc.GetRoutesOutProto.IRouteTab[];
            public route_list: POGOProtos.Rpc.IClientRouteGetProto[];
            public static encode(message: POGOProtos.Rpc.IGetRoutesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoutesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoutesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetRoutesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetRoutesOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }

            interface IRouteTab {
                title_string_id?: (string|null);
                route_ids?: (string[]|null);
            }

            class RouteTab implements IRouteTab {
                constructor(properties?: POGOProtos.Rpc.GetRoutesOutProto.IRouteTab);
                public title_string_id: string;
                public route_ids: string[];
                public static encode(message: POGOProtos.Rpc.GetRoutesOutProto.IRouteTab, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoutesOutProto.RouteTab;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoutesOutProto.RouteTab;
                public static toObject(message: POGOProtos.Rpc.GetRoutesOutProto.RouteTab, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetRoutesProto {
            cell_id?: ((number|Long)[]|null);
            request_version?: (number|null);
        }

        class GetRoutesProto implements IGetRoutesProto {
            constructor(properties?: POGOProtos.Rpc.IGetRoutesProto);
            public cell_id: (number|Long)[];
            public request_version: number;
            public static encode(message: POGOProtos.Rpc.IGetRoutesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetRoutesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetRoutesProto;
            public static toObject(message: POGOProtos.Rpc.GetRoutesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetSaveForLaterEntriesOutProto {
            result?: (POGOProtos.Rpc.GetSaveForLaterEntriesOutProto.Result|null);
            save_for_later_pokemon?: (POGOProtos.Rpc.ISaveForLaterBreadPokemonProto[]|null);
        }

        class GetSaveForLaterEntriesOutProto implements IGetSaveForLaterEntriesOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetSaveForLaterEntriesOutProto);
            public result: POGOProtos.Rpc.GetSaveForLaterEntriesOutProto.Result;
            public save_for_later_pokemon: POGOProtos.Rpc.ISaveForLaterBreadPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IGetSaveForLaterEntriesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetSaveForLaterEntriesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetSaveForLaterEntriesOutProto;
            public static toObject(message: POGOProtos.Rpc.GetSaveForLaterEntriesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetSaveForLaterEntriesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_SAVE_FOR_LATER_NOT_ENABLED = 2
            }
        }

        interface IGetSaveForLaterEntriesProto {
        }

        class GetSaveForLaterEntriesProto implements IGetSaveForLaterEntriesProto {
            constructor(properties?: POGOProtos.Rpc.IGetSaveForLaterEntriesProto);
            public static encode(message: POGOProtos.Rpc.IGetSaveForLaterEntriesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetSaveForLaterEntriesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetSaveForLaterEntriesProto;
            public static toObject(message: POGOProtos.Rpc.GetSaveForLaterEntriesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetServerTimeOutProto {
            status?: (POGOProtos.Rpc.GetServerTimeOutProto.Status|null);
            server_time_ms?: (number|Long|null);
        }

        class GetServerTimeOutProto implements IGetServerTimeOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetServerTimeOutProto);
            public status: POGOProtos.Rpc.GetServerTimeOutProto.Status;
            public server_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetServerTimeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetServerTimeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetServerTimeOutProto;
            public static toObject(message: POGOProtos.Rpc.GetServerTimeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetServerTimeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IGetServerTimeProto {
        }

        class GetServerTimeProto implements IGetServerTimeProto {
            constructor(properties?: POGOProtos.Rpc.IGetServerTimeProto);
            public static encode(message: POGOProtos.Rpc.IGetServerTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetServerTimeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetServerTimeProto;
            public static toObject(message: POGOProtos.Rpc.GetServerTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetStardustQuestProto {
            stardust?: (number|null);
        }

        class GetStardustQuestProto implements IGetStardustQuestProto {
            constructor(properties?: POGOProtos.Rpc.IGetStardustQuestProto);
            public stardust: number;
            public static encode(message: POGOProtos.Rpc.IGetStardustQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetStardustQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetStardustQuestProto;
            public static toObject(message: POGOProtos.Rpc.GetStardustQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetStationInfoOutProto {
            station_proto?: (POGOProtos.Rpc.IStationProto|null);
            result?: (POGOProtos.Rpc.GetStationInfoOutProto.Result|null);
        }

        class GetStationInfoOutProto implements IGetStationInfoOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetStationInfoOutProto);
            public station_proto?: (POGOProtos.Rpc.IStationProto|null);
            public result: POGOProtos.Rpc.GetStationInfoOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IGetStationInfoOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetStationInfoOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetStationInfoOutProto;
            public static toObject(message: POGOProtos.Rpc.GetStationInfoOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetStationInfoOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_STATION_DISABLED = 2,
                ERROR_STATION_NOT_FOUND = 3
            }
        }

        interface IGetStationInfoProto {
            station_id?: (string|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
        }

        class GetStationInfoProto implements IGetStationInfoProto {
            constructor(properties?: POGOProtos.Rpc.IGetStationInfoProto);
            public station_id: string;
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IGetStationInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetStationInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetStationInfoProto;
            public static toObject(message: POGOProtos.Rpc.GetStationInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetStationedPokemonDetailsOutProto {
            result?: (POGOProtos.Rpc.GetStationedPokemonDetailsOutProto.Result|null);
            stationed_pokemons?: (POGOProtos.Rpc.IPlayerClientStationedPokemonProto[]|null);
            total_num_stationed_pokemon?: (number|null);
        }

        class GetStationedPokemonDetailsOutProto implements IGetStationedPokemonDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetStationedPokemonDetailsOutProto);
            public result: POGOProtos.Rpc.GetStationedPokemonDetailsOutProto.Result;
            public stationed_pokemons: POGOProtos.Rpc.IPlayerClientStationedPokemonProto[];
            public total_num_stationed_pokemon: number;
            public static encode(message: POGOProtos.Rpc.IGetStationedPokemonDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetStationedPokemonDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetStationedPokemonDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.GetStationedPokemonDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetStationedPokemonDetailsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                STATION_NOT_FOUND = 2,
                OUT_OF_RANGE = 3
            }
        }

        interface IGetStationedPokemonDetailsProto {
            station_id?: (string|null);
            get_full_details?: (boolean|null);
        }

        class GetStationedPokemonDetailsProto implements IGetStationedPokemonDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGetStationedPokemonDetailsProto);
            public station_id: string;
            public get_full_details: boolean;
            public static encode(message: POGOProtos.Rpc.IGetStationedPokemonDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetStationedPokemonDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetStationedPokemonDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GetStationedPokemonDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetSurveyEligibilityOutProto {
            status?: (POGOProtos.Rpc.GetSurveyEligibilityOutProto.Status|null);
            is_eligible?: (boolean|null);
        }

        class GetSurveyEligibilityOutProto implements IGetSurveyEligibilityOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetSurveyEligibilityOutProto);
            public status: POGOProtos.Rpc.GetSurveyEligibilityOutProto.Status;
            public is_eligible: boolean;
            public static encode(message: POGOProtos.Rpc.IGetSurveyEligibilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetSurveyEligibilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetSurveyEligibilityOutProto;
            public static toObject(message: POGOProtos.Rpc.GetSurveyEligibilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetSurveyEligibilityOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_NOT_ENABLED = 3
            }
        }

        interface IGetSurveyEligibilityProto {
        }

        class GetSurveyEligibilityProto implements IGetSurveyEligibilityProto {
            constructor(properties?: POGOProtos.Rpc.IGetSurveyEligibilityProto);
            public static encode(message: POGOProtos.Rpc.IGetSurveyEligibilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetSurveyEligibilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetSurveyEligibilityProto;
            public static toObject(message: POGOProtos.Rpc.GetSurveyEligibilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetTimedGroupChallengeOutProto {
            status?: (POGOProtos.Rpc.GetTimedGroupChallengeOutProto.Status|null);
            challenge_definition?: (POGOProtos.Rpc.ITimedGroupChallengeDefinitionProto|null);
            current_score?: (number|null);
            player_score?: (number|null);
            active_city_hash?: (string|null);
            active_city_localization_key_changes?: (string[]|null);
        }

        class GetTimedGroupChallengeOutProto implements IGetTimedGroupChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetTimedGroupChallengeOutProto);
            public status: POGOProtos.Rpc.GetTimedGroupChallengeOutProto.Status;
            public challenge_definition?: (POGOProtos.Rpc.ITimedGroupChallengeDefinitionProto|null);
            public current_score: number;
            public player_score: number;
            public active_city_hash: string;
            public active_city_localization_key_changes: string[];
            public static encode(message: POGOProtos.Rpc.IGetTimedGroupChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetTimedGroupChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetTimedGroupChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.GetTimedGroupChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetTimedGroupChallengeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_CHALLENGE_NOT_FOUND = 3
            }
        }

        interface IGetTimedGroupChallengeProto {
            challenge_id?: (string|null);
            active_city_hash?: (string|null);
        }

        class GetTimedGroupChallengeProto implements IGetTimedGroupChallengeProto {
            constructor(properties?: POGOProtos.Rpc.IGetTimedGroupChallengeProto);
            public challenge_id: string;
            public active_city_hash: string;
            public static encode(message: POGOProtos.Rpc.IGetTimedGroupChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetTimedGroupChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetTimedGroupChallengeProto;
            public static toObject(message: POGOProtos.Rpc.GetTimedGroupChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetTradingOutProto {
            result?: (POGOProtos.Rpc.GetTradingOutProto.Result|null);
            trading?: (POGOProtos.Rpc.ITradingProto|null);
        }

        class GetTradingOutProto implements IGetTradingOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetTradingOutProto);
            public result: POGOProtos.Rpc.GetTradingOutProto.Result;
            public trading?: (POGOProtos.Rpc.ITradingProto|null);
            public static encode(message: POGOProtos.Rpc.IGetTradingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetTradingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetTradingOutProto;
            public static toObject(message: POGOProtos.Rpc.GetTradingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetTradingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FRIEND_NOT_FOUND = 3,
                ERROR_INVALID_PLAYER_ID = 4,
                ERROR_INVALID_STATE = 5,
                ERROR_STATE_HANDLER = 6
            }
        }

        interface IGetTradingProto {
            player_id?: (string|null);
        }

        class GetTradingProto implements IGetTradingProto {
            constructor(properties?: POGOProtos.Rpc.IGetTradingProto);
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.IGetTradingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetTradingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetTradingProto;
            public static toObject(message: POGOProtos.Rpc.GetTradingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetUnfusePokemonPreviewRequestProto {
            pokemon_id?: (number|Long|null);
            target_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class GetUnfusePokemonPreviewRequestProto implements IGetUnfusePokemonPreviewRequestProto {
            constructor(properties?: POGOProtos.Rpc.IGetUnfusePokemonPreviewRequestProto);
            public pokemon_id: (number|Long);
            public target_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IGetUnfusePokemonPreviewRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetUnfusePokemonPreviewRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetUnfusePokemonPreviewRequestProto;
            public static toObject(message: POGOProtos.Rpc.GetUnfusePokemonPreviewRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetUnfusePokemonPreviewResponseProto {
            result?: (POGOProtos.Rpc.UnfusePokemonResponseProto.Result|null);
            unfused_base_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            unfused_component_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class GetUnfusePokemonPreviewResponseProto implements IGetUnfusePokemonPreviewResponseProto {
            constructor(properties?: POGOProtos.Rpc.IGetUnfusePokemonPreviewResponseProto);
            public result: POGOProtos.Rpc.UnfusePokemonResponseProto.Result;
            public unfused_base_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public unfused_component_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IGetUnfusePokemonPreviewResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetUnfusePokemonPreviewResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetUnfusePokemonPreviewResponseProto;
            public static toObject(message: POGOProtos.Rpc.GetUnfusePokemonPreviewResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetUploadUrlOutProto {
            status?: (POGOProtos.Rpc.GetUploadUrlOutProto.Status|null);
            signed_url?: (string|null);
            supporting_image_signed_url?: (string|null);
        }

        class GetUploadUrlOutProto implements IGetUploadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetUploadUrlOutProto);
            public status: POGOProtos.Rpc.GetUploadUrlOutProto.Status;
            public signed_url: string;
            public supporting_image_signed_url: string;
            public static encode(message: POGOProtos.Rpc.IGetUploadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetUploadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetUploadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.GetUploadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetUploadUrlOutProto {

            enum Status {
                UNSET = 0,
                FAILURES = 1,
                SUCCESS = 2
            }
        }

        interface IGetUploadUrlProto {
            user_id?: (string|null);
            game_unique_id?: (string|null);
        }

        class GetUploadUrlProto implements IGetUploadUrlProto {
            constructor(properties?: POGOProtos.Rpc.IGetUploadUrlProto);
            public user_id: string;
            public game_unique_id: string;
            public static encode(message: POGOProtos.Rpc.IGetUploadUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetUploadUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetUploadUrlProto;
            public static toObject(message: POGOProtos.Rpc.GetUploadUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetValueRequest {
            key?: (POGOProtos.Rpc.IKey|null);
        }

        class GetValueRequest implements IGetValueRequest {
            constructor(properties?: POGOProtos.Rpc.IGetValueRequest);
            public key?: (POGOProtos.Rpc.IKey|null);
            public static encode(message: POGOProtos.Rpc.IGetValueRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetValueRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetValueRequest;
            public static toObject(message: POGOProtos.Rpc.GetValueRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetValueResponse {
            value?: (POGOProtos.Rpc.IVersionedValue|null);
        }

        class GetValueResponse implements IGetValueResponse {
            constructor(properties?: POGOProtos.Rpc.IGetValueResponse);
            public value?: (POGOProtos.Rpc.IVersionedValue|null);
            public static encode(message: POGOProtos.Rpc.IGetValueResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetValueResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetValueResponse;
            public static toObject(message: POGOProtos.Rpc.GetValueResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetVpsEventOutProto {
            status?: (POGOProtos.Rpc.GetVpsEventOutProto.Status|null);
            vps_event_wrapper?: (POGOProtos.Rpc.IVpsEventWrapperProto[]|null);
        }

        class GetVpsEventOutProto implements IGetVpsEventOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetVpsEventOutProto);
            public status: POGOProtos.Rpc.GetVpsEventOutProto.Status;
            public vps_event_wrapper: POGOProtos.Rpc.IVpsEventWrapperProto[];
            public static encode(message: POGOProtos.Rpc.IGetVpsEventOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetVpsEventOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetVpsEventOutProto;
            public static toObject(message: POGOProtos.Rpc.GetVpsEventOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetVpsEventOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FORT_ID_NOT_FOUND = 3,
                ERROR_VPS_NOT_ENABLED_AT_FORT = 4,
                ERROR_NO_EVENTS_AT_FORT_FOUND = 5
            }
        }

        interface IGetVpsEventProto {
            fort_id?: (string|null);
            event_type?: (POGOProtos.Rpc.VpsEventType|null);
            event_id?: (number|null);
        }

        class GetVpsEventProto implements IGetVpsEventProto {
            constructor(properties?: POGOProtos.Rpc.IGetVpsEventProto);
            public fort_id: string;
            public event_type: POGOProtos.Rpc.VpsEventType;
            public event_id: number;
            public static encode(message: POGOProtos.Rpc.IGetVpsEventProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetVpsEventProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetVpsEventProto;
            public static toObject(message: POGOProtos.Rpc.GetVpsEventProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetVsSeekerStatusOutProto {
            result?: (POGOProtos.Rpc.GetVsSeekerStatusOutProto.Result|null);
            vs_seeker?: (POGOProtos.Rpc.IVsSeekerAttributesProto|null);
            season_ended?: (boolean|null);
            combat_log?: (POGOProtos.Rpc.ICombatLogProto|null);
        }

        class GetVsSeekerStatusOutProto implements IGetVsSeekerStatusOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetVsSeekerStatusOutProto);
            public result: POGOProtos.Rpc.GetVsSeekerStatusOutProto.Result;
            public vs_seeker?: (POGOProtos.Rpc.IVsSeekerAttributesProto|null);
            public season_ended: boolean;
            public combat_log?: (POGOProtos.Rpc.ICombatLogProto|null);
            public static encode(message: POGOProtos.Rpc.IGetVsSeekerStatusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetVsSeekerStatusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetVsSeekerStatusOutProto;
            public static toObject(message: POGOProtos.Rpc.GetVsSeekerStatusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetVsSeekerStatusOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS_FULLY_CHARGED = 1,
                SUCCESS_NOT_FULLY_CHARGED_YET = 2,
                ERROR_VS_SEEKER_NOT_FOUND = 3,
                ERROR_VS_SEEKER_NEVER_STARTED_CHARGING = 4
            }
        }

        interface IGetVsSeekerStatusProto {
        }

        class GetVsSeekerStatusProto implements IGetVsSeekerStatusProto {
            constructor(properties?: POGOProtos.Rpc.IGetVsSeekerStatusProto);
            public static encode(message: POGOProtos.Rpc.IGetVsSeekerStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetVsSeekerStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetVsSeekerStatusProto;
            public static toObject(message: POGOProtos.Rpc.GetVsSeekerStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetWebTokenActionOutProto {
            status?: (POGOProtos.Rpc.GetWebTokenActionOutProto.Status|null);
            access_token?: (string|null);
        }

        class GetWebTokenActionOutProto implements IGetWebTokenActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetWebTokenActionOutProto);
            public status: POGOProtos.Rpc.GetWebTokenActionOutProto.Status;
            public access_token: string;
            public static encode(message: POGOProtos.Rpc.IGetWebTokenActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetWebTokenActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetWebTokenActionOutProto;
            public static toObject(message: POGOProtos.Rpc.GetWebTokenActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetWebTokenActionOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IGetWebTokenActionProto {
            client_id?: (string|null);
        }

        class GetWebTokenActionProto implements IGetWebTokenActionProto {
            constructor(properties?: POGOProtos.Rpc.IGetWebTokenActionProto);
            public client_id: string;
            public static encode(message: POGOProtos.Rpc.IGetWebTokenActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetWebTokenActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetWebTokenActionProto;
            public static toObject(message: POGOProtos.Rpc.GetWebTokenActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetWebTokenOutProto {
            status?: (POGOProtos.Rpc.GetWebTokenOutProto.Status|null);
            access_token?: (string|null);
        }

        class GetWebTokenOutProto implements IGetWebTokenOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetWebTokenOutProto);
            public status: POGOProtos.Rpc.GetWebTokenOutProto.Status;
            public access_token: string;
            public static encode(message: POGOProtos.Rpc.IGetWebTokenOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetWebTokenOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetWebTokenOutProto;
            public static toObject(message: POGOProtos.Rpc.GetWebTokenOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetWebTokenOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IGetWebTokenProto {
            client_id?: (string|null);
        }

        class GetWebTokenProto implements IGetWebTokenProto {
            constructor(properties?: POGOProtos.Rpc.IGetWebTokenProto);
            public client_id: string;
            public static encode(message: POGOProtos.Rpc.IGetWebTokenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetWebTokenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetWebTokenProto;
            public static toObject(message: POGOProtos.Rpc.GetWebTokenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGetWeeklyChallengeInfoOutProto {
            status?: (POGOProtos.Rpc.GetWeeklyChallengeInfoOutProto.Status|null);
            start_timestamp_ms?: (number|Long|null);
            end_timestamp_ms?: (number|Long|null);
        }

        class GetWeeklyChallengeInfoOutProto implements IGetWeeklyChallengeInfoOutProto {
            constructor(properties?: POGOProtos.Rpc.IGetWeeklyChallengeInfoOutProto);
            public status: POGOProtos.Rpc.GetWeeklyChallengeInfoOutProto.Status;
            public start_timestamp_ms: (number|Long);
            public end_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGetWeeklyChallengeInfoOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetWeeklyChallengeInfoOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetWeeklyChallengeInfoOutProto;
            public static toObject(message: POGOProtos.Rpc.GetWeeklyChallengeInfoOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GetWeeklyChallengeInfoOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IGetWeeklyChallengeInfoProto {
        }

        class GetWeeklyChallengeInfoProto implements IGetWeeklyChallengeInfoProto {
            constructor(properties?: POGOProtos.Rpc.IGetWeeklyChallengeInfoProto);
            public static encode(message: POGOProtos.Rpc.IGetWeeklyChallengeInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GetWeeklyChallengeInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GetWeeklyChallengeInfoProto;
            public static toObject(message: POGOProtos.Rpc.GetWeeklyChallengeInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGhostWayspotSettings {
            ghost_wayspot_enabled?: (boolean|null);
        }

        class GhostWayspotSettings implements IGhostWayspotSettings {
            constructor(properties?: POGOProtos.Rpc.IGhostWayspotSettings);
            public ghost_wayspot_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IGhostWayspotSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GhostWayspotSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GhostWayspotSettings;
            public static toObject(message: POGOProtos.Rpc.GhostWayspotSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGiftBoxDetailsProto {
            giftbox_id?: (number|Long|null);
            sender_id?: (string|null);
            sender_codename?: (string|null);
            receiver_id?: (string|null);
            receiver_codename?: (string|null);
            fort_id?: (string|null);
            fort_name?: (string|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
            fort_image_url?: (string|null);
            creation_timestamp?: (number|Long|null);
            sent_timestamp?: (number|Long|null);
            delivery_pokemon_id?: (number|Long|null);
            is_sponsored?: (boolean|null);
            stickers_sent?: (POGOProtos.Rpc.IStickerSentProto[]|null);
            share_trainer_info_with_postcard?: (POGOProtos.Rpc.PlayerPreferencesProto.PostcardTrainerInfoSharingPreference|null);
            pinned_postcard_id?: (string|null);
            pin_update_timestamp_ms?: (number|Long|null);
            saturday_claimed?: (boolean|null);
            sender_nia_account_id?: (string|null);
            stamp_collection_id?: (string|null);
            stamp_collection_details?: (POGOProtos.Rpc.IStampCollectionGiftboxDetailsProto|null);
        }

        class GiftBoxDetailsProto implements IGiftBoxDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IGiftBoxDetailsProto);
            public giftbox_id: (number|Long);
            public sender_id: string;
            public sender_codename: string;
            public receiver_id: string;
            public receiver_codename: string;
            public fort_id: string;
            public fort_name: string;
            public fort_lat: number;
            public fort_lng: number;
            public fort_image_url: string;
            public creation_timestamp: (number|Long);
            public sent_timestamp: (number|Long);
            public delivery_pokemon_id: (number|Long);
            public is_sponsored: boolean;
            public stickers_sent: POGOProtos.Rpc.IStickerSentProto[];
            public share_trainer_info_with_postcard: POGOProtos.Rpc.PlayerPreferencesProto.PostcardTrainerInfoSharingPreference;
            public pinned_postcard_id: string;
            public pin_update_timestamp_ms: (number|Long);
            public saturday_claimed: boolean;
            public sender_nia_account_id: string;
            public stamp_collection_id: string;
            public stamp_collection_details?: (POGOProtos.Rpc.IStampCollectionGiftboxDetailsProto|null);
            public static encode(message: POGOProtos.Rpc.IGiftBoxDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftBoxDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftBoxDetailsProto;
            public static toObject(message: POGOProtos.Rpc.GiftBoxDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGiftBoxProto {
            giftbox_id?: (number|Long|null);
            sender_id?: (string|null);
            receiver_id?: (string|null);
            fort_id?: (string|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
            creation_timestamp?: (number|Long|null);
            sent_timestamp?: (number|Long|null);
            sent_bucket?: (number|Long|null);
            saturday_claimed?: (boolean|null);
            sender_nia_id?: (string|null);
            sender_codename?: (string|null);
            receiver_codename?: (string|null);
            fort_name?: (string|null);
            fort_image_url?: (string|null);
            stickers_sent?: (string[]|null);
            share_trainer_info_with_postcard?: (boolean|null);
            pinned_postcard_id?: (string|null);
            stamp_collection_id?: (string|null);
            stamp_collection_details?: (POGOProtos.Rpc.IStampCollectionGiftboxDetailsProto|null);
        }

        class GiftBoxProto implements IGiftBoxProto {
            constructor(properties?: POGOProtos.Rpc.IGiftBoxProto);
            public giftbox_id: (number|Long);
            public sender_id: string;
            public receiver_id: string;
            public fort_id: string;
            public fort_lat: number;
            public fort_lng: number;
            public creation_timestamp: (number|Long);
            public sent_timestamp: (number|Long);
            public sent_bucket: (number|Long);
            public saturday_claimed: boolean;
            public sender_nia_id: string;
            public sender_codename: string;
            public receiver_codename: string;
            public fort_name: string;
            public fort_image_url: string;
            public stickers_sent: string[];
            public share_trainer_info_with_postcard: boolean;
            public pinned_postcard_id: string;
            public stamp_collection_id: string;
            public stamp_collection_details?: (POGOProtos.Rpc.IStampCollectionGiftboxDetailsProto|null);
            public static encode(message: POGOProtos.Rpc.IGiftBoxProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftBoxProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftBoxProto;
            public static toObject(message: POGOProtos.Rpc.GiftBoxProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGiftBoxesProto {
            gifts?: (POGOProtos.Rpc.IGiftBoxProto[]|null);
        }

        class GiftBoxesProto implements IGiftBoxesProto {
            constructor(properties?: POGOProtos.Rpc.IGiftBoxesProto);
            public gifts: POGOProtos.Rpc.IGiftBoxProto[];
            public static encode(message: POGOProtos.Rpc.IGiftBoxesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftBoxesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftBoxesProto;
            public static toObject(message: POGOProtos.Rpc.GiftBoxesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGiftExchangeEntryProto {
            gift_box?: (POGOProtos.Rpc.IGiftBoxProto|null);
            sender_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            source_route_id?: (string|null);
            route_name?: (string|null);
        }

        class GiftExchangeEntryProto implements IGiftExchangeEntryProto {
            constructor(properties?: POGOProtos.Rpc.IGiftExchangeEntryProto);
            public gift_box?: (POGOProtos.Rpc.IGiftBoxProto|null);
            public sender_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public source_route_id: string;
            public route_name: string;
            public static encode(message: POGOProtos.Rpc.IGiftExchangeEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftExchangeEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftExchangeEntryProto;
            public static toObject(message: POGOProtos.Rpc.GiftExchangeEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGiftingEligibilityStatusProto {
            sender_check_status?: (POGOProtos.Rpc.GiftingEligibilityStatusProto.Status[]|null);
            item_check_status?: (POGOProtos.Rpc.GiftingEligibilityStatusProto.Status[]|null);
            recipient_check_status?: (POGOProtos.Rpc.GiftingEligibilityStatusProto.Status[]|null);
        }

        class GiftingEligibilityStatusProto implements IGiftingEligibilityStatusProto {
            constructor(properties?: POGOProtos.Rpc.IGiftingEligibilityStatusProto);
            public sender_check_status: POGOProtos.Rpc.GiftingEligibilityStatusProto.Status[];
            public item_check_status: POGOProtos.Rpc.GiftingEligibilityStatusProto.Status[];
            public recipient_check_status: POGOProtos.Rpc.GiftingEligibilityStatusProto.Status[];
            public static encode(message: POGOProtos.Rpc.IGiftingEligibilityStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftingEligibilityStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftingEligibilityStatusProto;
            public static toObject(message: POGOProtos.Rpc.GiftingEligibilityStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GiftingEligibilityStatusProto {

            enum Status {
                UNSET = 0,
                SUCCESS_ELIGIBLE = 1,
                ERROR_UNKNOWN = 2,
                FAILURE_SKU_NOT_GIFTABLE = 3,
                FAILURE_SENDER_LEVEL = 4,
                FAILURE_SENDER_LIMIT_REACHED = 5,
                FAILURE_SENDER_CHILD_ACCOUNT = 6,
                FAILURE_FRIEND_DOES_NOT_EXIST = 7,
                FAILURE_FRIEND_LEVEL = 8,
                FAILURE_FRIEND_HAS_TICKET = 9,
                FAILURE_FRIEND_OPT_OUT_RECEIVE_TICKET_GIFTS = 10
            }
        }

        interface IGiftingIapItemProto {
            sku_id?: (string|null);
            item?: (POGOProtos.Rpc.Item|null);
        }

        class GiftingIapItemProto implements IGiftingIapItemProto {
            constructor(properties?: POGOProtos.Rpc.IGiftingIapItemProto);
            public sku_id: string;
            public item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IGiftingIapItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftingIapItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftingIapItemProto;
            public static toObject(message: POGOProtos.Rpc.GiftingIapItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGiftingSettingsProto {
            enable_gift_to_stardust?: (boolean|null);
            stardust_per_gift?: (number|null);
            stardust_multiplier?: (POGOProtos.Rpc.GiftingSettingsProto.IStardustMultiplier[]|null);
        }

        class GiftingSettingsProto implements IGiftingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGiftingSettingsProto);
            public enable_gift_to_stardust: boolean;
            public stardust_per_gift: number;
            public stardust_multiplier: POGOProtos.Rpc.GiftingSettingsProto.IStardustMultiplier[];
            public static encode(message: POGOProtos.Rpc.IGiftingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GiftingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GiftingSettingsProto {

            interface IStardustMultiplier {
                multiplier?: (number|null);
                random_weight?: (number|null);
            }

            class StardustMultiplier implements IStardustMultiplier {
                constructor(properties?: POGOProtos.Rpc.GiftingSettingsProto.IStardustMultiplier);
                public multiplier: number;
                public random_weight: number;
                public static encode(message: POGOProtos.Rpc.GiftingSettingsProto.IStardustMultiplier, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GiftingSettingsProto.StardustMultiplier;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GiftingSettingsProto.StardustMultiplier;
                public static toObject(message: POGOProtos.Rpc.GiftingSettingsProto.StardustMultiplier, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGlobalEventTicketAttributesProto {
            event_badge?: (POGOProtos.Rpc.HoloBadgeType|null);
            grant_badge_before_event_start_ms?: (number|Long|null);
            event_start_time?: (string|null);
            event_end_time?: (string|null);
            item_bag_description_key?: (string|null);
            event_variant_badges?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            event_variant_title_string_keys?: (string[]|null);
            event_variant_description_string_keys?: (string[]|null);
            item_bag_description_variant_selected?: (string|null);
            event_variant_button_string_keys?: (string[]|null);
            giftable?: (boolean|null);
            ticket_item?: (POGOProtos.Rpc.Item|null);
            gift_item?: (POGOProtos.Rpc.Item|null);
            event_title_string_key?: (string|null);
            event_banner_url?: (string|null);
            require_original_ticket_for_gift?: (boolean|null);
            gift_purchase_limit?: (number|null);
            conflict_story_quest_ids?: (string[]|null);
            display_v2_enabled?: (boolean|null);
            background_image_url?: (string|null);
            title_image_url?: (string|null);
            event_datetime_range_key?: (string|null);
            text_rewards_key?: (string|null);
            icon_rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
            details_link_key?: (string|null);
            sprite_id_override?: (string|null);
            client_event_start_time_utc_ms?: (number|Long|null);
            client_event_end_time_utc_ms?: (number|Long|null);
        }

        class GlobalEventTicketAttributesProto implements IGlobalEventTicketAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IGlobalEventTicketAttributesProto);
            public event_badge: POGOProtos.Rpc.HoloBadgeType;
            public grant_badge_before_event_start_ms: (number|Long);
            public event_start_time: string;
            public event_end_time: string;
            public item_bag_description_key: string;
            public event_variant_badges: POGOProtos.Rpc.HoloBadgeType[];
            public event_variant_title_string_keys: string[];
            public event_variant_description_string_keys: string[];
            public item_bag_description_variant_selected: string;
            public event_variant_button_string_keys: string[];
            public giftable: boolean;
            public ticket_item: POGOProtos.Rpc.Item;
            public gift_item: POGOProtos.Rpc.Item;
            public event_title_string_key: string;
            public event_banner_url: string;
            public require_original_ticket_for_gift: boolean;
            public gift_purchase_limit: number;
            public conflict_story_quest_ids: string[];
            public display_v2_enabled: boolean;
            public background_image_url: string;
            public title_image_url: string;
            public event_datetime_range_key: string;
            public text_rewards_key: string;
            public icon_rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public details_link_key: string;
            public sprite_id_override: string;
            public client_event_start_time_utc_ms: (number|Long);
            public client_event_end_time_utc_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGlobalEventTicketAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GlobalEventTicketAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GlobalEventTicketAttributesProto;
            public static toObject(message: POGOProtos.Rpc.GlobalEventTicketAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGlobalMetrics {
            storage_metrics?: (POGOProtos.Rpc.IStorageMetrics|null);
        }

        class GlobalMetrics implements IGlobalMetrics {
            constructor(properties?: POGOProtos.Rpc.IGlobalMetrics);
            public storage_metrics?: (POGOProtos.Rpc.IStorageMetrics|null);
            public static encode(message: POGOProtos.Rpc.IGlobalMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GlobalMetrics;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GlobalMetrics;
            public static toObject(message: POGOProtos.Rpc.GlobalMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGlobalSettingsProto {
            fort_settings?: (POGOProtos.Rpc.IFortSettingsProto|null);
            map_settings?: (POGOProtos.Rpc.IMapSettingsProto|null);
            level_settings?: (POGOProtos.Rpc.ILevelSettingsProto|null);
            inventory_settings?: (POGOProtos.Rpc.IInventorySettingsProto|null);
            minimum_client_version?: (string|null);
            gps_settings?: (POGOProtos.Rpc.IGpsSettingsProto|null);
            festival_settings?: (POGOProtos.Rpc.IFestivalSettingsProto|null);
            event_settings?: (POGOProtos.Rpc.IEventSettingsProto|null);
            max_pokemon_types?: (number|null);
            sfida_settings?: (POGOProtos.Rpc.ISfidaGlobalSettingsProto|null);
            news_settings?: (POGOProtos.Rpc.INewsSettingProto|null);
            translation_settings?: (POGOProtos.Rpc.ITranslationSettingsProto|null);
            passcode_settings?: (POGOProtos.Rpc.IPasscodeSettingsProto|null);
            notification_settings?: (POGOProtos.Rpc.INotificationSettingsProto|null);
            client_app_blacklist?: (string[]|null);
            client_perf_settings?: (POGOProtos.Rpc.IClientPerformanceSettingsProto|null);
            news_global_settings?: (POGOProtos.Rpc.INewsGlobalSettingsProto|null);
            quest_global_settings?: (POGOProtos.Rpc.IQuestGlobalSettingsProto|null);
            beluga_global_settings?: (POGOProtos.Rpc.IBelugaGlobalSettingsProto|null);
            telemetry_global_settings?: (POGOProtos.Rpc.ITelemetryGlobalSettingsProto|null);
            login_settings?: (POGOProtos.Rpc.ILoginSettingsProto|null);
            social_settings?: (POGOProtos.Rpc.ISocialClientSettingsProto|null);
            trading_global_settings?: (POGOProtos.Rpc.ITradingGlobalSettingsProto|null);
            additional_allowed_pokemon_ids?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            upsight_logging_settings?: (POGOProtos.Rpc.IUpsightLoggingSettingsProto|null);
            combat_global_settings?: (POGOProtos.Rpc.ICombatGlobalSettingsProto|null);
            combat_challenge_global_settings?: (POGOProtos.Rpc.ICombatChallengeGlobalSettingsProto|null);
            bgmode_global_settings?: (POGOProtos.Rpc.IBackgroundModeGlobalSettingsProto|null);
            probe_settings?: (POGOProtos.Rpc.IProbeSettingsProto|null);
            purchased_settings?: (POGOProtos.Rpc.IPokecoinPurchaseDisplaySettingsProto|null);
            helpshift_settings?: (POGOProtos.Rpc.IHelpshiftSettingsProto|null);
            ar_photo_settings?: (POGOProtos.Rpc.IArPhotoGlobalSettings|null);
            poi_settings?: (POGOProtos.Rpc.IPoiGlobalSettingsProto|null);
            pokemon_settings?: (POGOProtos.Rpc.IPokemonGlobalSettingsProto|null);
            evolution_v2_settings?: (POGOProtos.Rpc.IEvolutionV2SettingsProto|null);
            incident_settings?: (POGOProtos.Rpc.IIncidentGlobalSettingsProto|null);
            koala_settings?: (POGOProtos.Rpc.IKoalaSettingsProto|null);
            kangaroo_settings?: (POGOProtos.Rpc.IKangarooSettingsProto|null);
            route_settings?: (POGOProtos.Rpc.IRouteGlobalSettingsProto|null);
            buddy_settings?: (POGOProtos.Rpc.IBuddyGlobalSettingsProto|null);
            input_settings?: (POGOProtos.Rpc.IInputSettingsProto|null);
            gmt_settings?: (POGOProtos.Rpc.IGmtSettingsProto|null);
            use_local_time_action?: (boolean|null);
            ardk_config_settings?: (POGOProtos.Rpc.IArdkConfigSettingsProto|null);
            enabled_pokemon?: (POGOProtos.Rpc.IEnabledPokemonSettingsProto|null);
            planned_downtime_settings?: (POGOProtos.Rpc.IPlannedDowntimeSettingsProto|null);
            ar_mapping_settings?: (POGOProtos.Rpc.IArMappingSettingsProto|null);
            raid_invite_friends_settings?: (POGOProtos.Rpc.IRaidInviteFriendsSettingsProto|null);
            daily_encounter_settings?: (POGOProtos.Rpc.IDailyEncounterGlobalSettingsProto|null);
            rocket_balloon_settings?: (POGOProtos.Rpc.IRocketBalloonGlobalSettingsProto|null);
            timed_group_challenge_settings?: (POGOProtos.Rpc.ITimedGroupChallengeSettingsProto|null);
            mega_evo_settings?: (POGOProtos.Rpc.IMegaEvoGlobalSettingsProto|null);
            lobby_client_settings?: (POGOProtos.Rpc.ILobbyClientSettingsProto|null);
            quest_evolution_settings?: (POGOProtos.Rpc.IQuestEvolutionGlobalSettingsProto|null);
            sponsored_poi_feedback_settings?: (POGOProtos.Rpc.ISponsoredPoiFeedbackSettingsProto|null);
            crashlytics_settings?: (POGOProtos.Rpc.ICrashlyticsSettingsProto|null);
            catch_pokemon_settings?: (POGOProtos.Rpc.ICatchPokemonGlobalSettingsProto|null);
            idfa_settings?: (POGOProtos.Rpc.IIdfaSettingsProto|null);
            form_change_settings?: (POGOProtos.Rpc.IFormChangeSettingsProto|null);
            iap_settings?: (POGOProtos.Rpc.IStoreIapSettingsProto[]|null);
            power_up_pokestops_global_settings?: (POGOProtos.Rpc.IPowerUpPokestopsGlobalSettingsProto|null);
            upload_management_settings?: (POGOProtos.Rpc.IUploadManagementSettings|null);
            raid_player_stats_settings?: (POGOProtos.Rpc.IRaidPlayerStatsGlobalSettingsProto|null);
            postcard_collection_settings?: (POGOProtos.Rpc.IPostcardCollectionSettingsProto|null);
            push_gateway_global_settings?: (POGOProtos.Rpc.IPushGatewayGlobalSettingsProto|null);
            submission_counter_settings?: (POGOProtos.Rpc.ISubmissionCounterSettings|null);
            ghost_wayspot_settings?: (POGOProtos.Rpc.IGhostWayspotSettings|null);
            iap_disclosure_display_settings?: (POGOProtos.Rpc.IIapDisclosureDisplaySettingsProto|null);
            download_all_assets_settings?: (POGOProtos.Rpc.IDownloadAllAssetsSettingsProto|null);
            ticket_gifting_feature_settings?: (POGOProtos.Rpc.ITicketGiftingFeatureSettingsProto|null);
            map_icons_settings?: (POGOProtos.Rpc.IMapIconsSettingsProto|null);
            settings_version_controller?: (POGOProtos.Rpc.ISettingsVersionControllerProto|null);
            guest_account_settings?: (POGOProtos.Rpc.IGuestAccountSettingsProto|null);
            temp_evo_settings?: (POGOProtos.Rpc.ITempEvoGlobalSettingsProto|null);
            saturday_settings?: (POGOProtos.Rpc.ISaturdaySettingsProto|null);
            party_play_settings?: (POGOProtos.Rpc.IPartyPlayGlobalSettingsProto|null);
            iris_social_settings?: (POGOProtos.Rpc.IIrisSocialGlobalSettingsProto|null);
            aegis_enforcement_settings?: (POGOProtos.Rpc.IAegisEnforcementSettingsProto|null);
            pokedex_v2_settings?: (POGOProtos.Rpc.IPokedexV2GlobalSettingsProto|null);
            weekly_challenge_settings?: (POGOProtos.Rpc.IWeeklyChallengeGlobalSettingsProto|null);
        }

        class GlobalSettingsProto implements IGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGlobalSettingsProto);
            public fort_settings?: (POGOProtos.Rpc.IFortSettingsProto|null);
            public map_settings?: (POGOProtos.Rpc.IMapSettingsProto|null);
            public level_settings?: (POGOProtos.Rpc.ILevelSettingsProto|null);
            public inventory_settings?: (POGOProtos.Rpc.IInventorySettingsProto|null);
            public minimum_client_version: string;
            public gps_settings?: (POGOProtos.Rpc.IGpsSettingsProto|null);
            public festival_settings?: (POGOProtos.Rpc.IFestivalSettingsProto|null);
            public event_settings?: (POGOProtos.Rpc.IEventSettingsProto|null);
            public max_pokemon_types: number;
            public sfida_settings?: (POGOProtos.Rpc.ISfidaGlobalSettingsProto|null);
            public news_settings?: (POGOProtos.Rpc.INewsSettingProto|null);
            public translation_settings?: (POGOProtos.Rpc.ITranslationSettingsProto|null);
            public passcode_settings?: (POGOProtos.Rpc.IPasscodeSettingsProto|null);
            public notification_settings?: (POGOProtos.Rpc.INotificationSettingsProto|null);
            public client_app_blacklist: string[];
            public client_perf_settings?: (POGOProtos.Rpc.IClientPerformanceSettingsProto|null);
            public news_global_settings?: (POGOProtos.Rpc.INewsGlobalSettingsProto|null);
            public quest_global_settings?: (POGOProtos.Rpc.IQuestGlobalSettingsProto|null);
            public beluga_global_settings?: (POGOProtos.Rpc.IBelugaGlobalSettingsProto|null);
            public telemetry_global_settings?: (POGOProtos.Rpc.ITelemetryGlobalSettingsProto|null);
            public login_settings?: (POGOProtos.Rpc.ILoginSettingsProto|null);
            public social_settings?: (POGOProtos.Rpc.ISocialClientSettingsProto|null);
            public trading_global_settings?: (POGOProtos.Rpc.ITradingGlobalSettingsProto|null);
            public additional_allowed_pokemon_ids: POGOProtos.Rpc.HoloPokemonId[];
            public upsight_logging_settings?: (POGOProtos.Rpc.IUpsightLoggingSettingsProto|null);
            public combat_global_settings?: (POGOProtos.Rpc.ICombatGlobalSettingsProto|null);
            public combat_challenge_global_settings?: (POGOProtos.Rpc.ICombatChallengeGlobalSettingsProto|null);
            public bgmode_global_settings?: (POGOProtos.Rpc.IBackgroundModeGlobalSettingsProto|null);
            public probe_settings?: (POGOProtos.Rpc.IProbeSettingsProto|null);
            public purchased_settings?: (POGOProtos.Rpc.IPokecoinPurchaseDisplaySettingsProto|null);
            public helpshift_settings?: (POGOProtos.Rpc.IHelpshiftSettingsProto|null);
            public ar_photo_settings?: (POGOProtos.Rpc.IArPhotoGlobalSettings|null);
            public poi_settings?: (POGOProtos.Rpc.IPoiGlobalSettingsProto|null);
            public pokemon_settings?: (POGOProtos.Rpc.IPokemonGlobalSettingsProto|null);
            public evolution_v2_settings?: (POGOProtos.Rpc.IEvolutionV2SettingsProto|null);
            public incident_settings?: (POGOProtos.Rpc.IIncidentGlobalSettingsProto|null);
            public koala_settings?: (POGOProtos.Rpc.IKoalaSettingsProto|null);
            public kangaroo_settings?: (POGOProtos.Rpc.IKangarooSettingsProto|null);
            public route_settings?: (POGOProtos.Rpc.IRouteGlobalSettingsProto|null);
            public buddy_settings?: (POGOProtos.Rpc.IBuddyGlobalSettingsProto|null);
            public input_settings?: (POGOProtos.Rpc.IInputSettingsProto|null);
            public gmt_settings?: (POGOProtos.Rpc.IGmtSettingsProto|null);
            public use_local_time_action: boolean;
            public ardk_config_settings?: (POGOProtos.Rpc.IArdkConfigSettingsProto|null);
            public enabled_pokemon?: (POGOProtos.Rpc.IEnabledPokemonSettingsProto|null);
            public planned_downtime_settings?: (POGOProtos.Rpc.IPlannedDowntimeSettingsProto|null);
            public ar_mapping_settings?: (POGOProtos.Rpc.IArMappingSettingsProto|null);
            public raid_invite_friends_settings?: (POGOProtos.Rpc.IRaidInviteFriendsSettingsProto|null);
            public daily_encounter_settings?: (POGOProtos.Rpc.IDailyEncounterGlobalSettingsProto|null);
            public rocket_balloon_settings?: (POGOProtos.Rpc.IRocketBalloonGlobalSettingsProto|null);
            public timed_group_challenge_settings?: (POGOProtos.Rpc.ITimedGroupChallengeSettingsProto|null);
            public mega_evo_settings?: (POGOProtos.Rpc.IMegaEvoGlobalSettingsProto|null);
            public lobby_client_settings?: (POGOProtos.Rpc.ILobbyClientSettingsProto|null);
            public quest_evolution_settings?: (POGOProtos.Rpc.IQuestEvolutionGlobalSettingsProto|null);
            public sponsored_poi_feedback_settings?: (POGOProtos.Rpc.ISponsoredPoiFeedbackSettingsProto|null);
            public crashlytics_settings?: (POGOProtos.Rpc.ICrashlyticsSettingsProto|null);
            public catch_pokemon_settings?: (POGOProtos.Rpc.ICatchPokemonGlobalSettingsProto|null);
            public idfa_settings?: (POGOProtos.Rpc.IIdfaSettingsProto|null);
            public form_change_settings?: (POGOProtos.Rpc.IFormChangeSettingsProto|null);
            public iap_settings: POGOProtos.Rpc.IStoreIapSettingsProto[];
            public power_up_pokestops_global_settings?: (POGOProtos.Rpc.IPowerUpPokestopsGlobalSettingsProto|null);
            public upload_management_settings?: (POGOProtos.Rpc.IUploadManagementSettings|null);
            public raid_player_stats_settings?: (POGOProtos.Rpc.IRaidPlayerStatsGlobalSettingsProto|null);
            public postcard_collection_settings?: (POGOProtos.Rpc.IPostcardCollectionSettingsProto|null);
            public push_gateway_global_settings?: (POGOProtos.Rpc.IPushGatewayGlobalSettingsProto|null);
            public submission_counter_settings?: (POGOProtos.Rpc.ISubmissionCounterSettings|null);
            public ghost_wayspot_settings?: (POGOProtos.Rpc.IGhostWayspotSettings|null);
            public iap_disclosure_display_settings?: (POGOProtos.Rpc.IIapDisclosureDisplaySettingsProto|null);
            public download_all_assets_settings?: (POGOProtos.Rpc.IDownloadAllAssetsSettingsProto|null);
            public ticket_gifting_feature_settings?: (POGOProtos.Rpc.ITicketGiftingFeatureSettingsProto|null);
            public map_icons_settings?: (POGOProtos.Rpc.IMapIconsSettingsProto|null);
            public settings_version_controller?: (POGOProtos.Rpc.ISettingsVersionControllerProto|null);
            public guest_account_settings?: (POGOProtos.Rpc.IGuestAccountSettingsProto|null);
            public temp_evo_settings?: (POGOProtos.Rpc.ITempEvoGlobalSettingsProto|null);
            public saturday_settings?: (POGOProtos.Rpc.ISaturdaySettingsProto|null);
            public party_play_settings?: (POGOProtos.Rpc.IPartyPlayGlobalSettingsProto|null);
            public iris_social_settings?: (POGOProtos.Rpc.IIrisSocialGlobalSettingsProto|null);
            public aegis_enforcement_settings?: (POGOProtos.Rpc.IAegisEnforcementSettingsProto|null);
            public pokedex_v2_settings?: (POGOProtos.Rpc.IPokedexV2GlobalSettingsProto|null);
            public weekly_challenge_settings?: (POGOProtos.Rpc.IWeeklyChallengeGlobalSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGlowFxPokemonProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            gender?: (POGOProtos.Rpc.PokemonDisplayProto.Gender|null);
        }

        class GlowFxPokemonProto implements IGlowFxPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IGlowFxPokemonProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public gender: POGOProtos.Rpc.PokemonDisplayProto.Gender;
            public static encode(message: POGOProtos.Rpc.IGlowFxPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GlowFxPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GlowFxPokemonProto;
            public static toObject(message: POGOProtos.Rpc.GlowFxPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGmtSettingsProto {
            enable_gmtdownload_v2?: (boolean|null);
            download_poll_period_ms?: (number|null);
        }

        class GmtSettingsProto implements IGmtSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGmtSettingsProto);
            public enable_gmtdownload_v2: boolean;
            public download_poll_period_ms: number;
            public static encode(message: POGOProtos.Rpc.IGmtSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GmtSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GmtSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GmtSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGoogleToken {
            id_token?: (string|null);
        }

        class GoogleToken implements IGoogleToken {
            constructor(properties?: POGOProtos.Rpc.IGoogleToken);
            public id_token: string;
            public static encode(message: POGOProtos.Rpc.IGoogleToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GoogleToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GoogleToken;
            public static toObject(message: POGOProtos.Rpc.GoogleToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGpsBookmarkProto {
            name?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class GpsBookmarkProto implements IGpsBookmarkProto {
            constructor(properties?: POGOProtos.Rpc.IGpsBookmarkProto);
            public name: string;
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IGpsBookmarkProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GpsBookmarkProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GpsBookmarkProto;
            public static toObject(message: POGOProtos.Rpc.GpsBookmarkProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGpsSettingsProto {
            driving_warning_speed_meters_per_second?: (number|null);
            driving_warning_cooldown_minutes?: (number|null);
            driving_speed_sample_interval_seconds?: (number|null);
            driving_speed_sample_count?: (number|null);
            idle_threshold_speed_meters_per_second?: (number|null);
            idle_threshold_duration_seconds?: (number|null);
            idle_sample_interval_seconds?: (number|null);
            idle_speed_sample_count?: (number|null);
        }

        class GpsSettingsProto implements IGpsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGpsSettingsProto);
            public driving_warning_speed_meters_per_second: number;
            public driving_warning_cooldown_minutes: number;
            public driving_speed_sample_interval_seconds: number;
            public driving_speed_sample_count: number;
            public idle_threshold_speed_meters_per_second: number;
            public idle_threshold_duration_seconds: number;
            public idle_sample_interval_seconds: number;
            public idle_speed_sample_count: number;
            public static encode(message: POGOProtos.Rpc.IGpsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GpsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GpsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GpsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGraphicsCapabilitiesSettingsProto {
            graphics_capabilities_telemetry_enabled?: (boolean|null);
        }

        class GraphicsCapabilitiesSettingsProto implements IGraphicsCapabilitiesSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGraphicsCapabilitiesSettingsProto);
            public graphics_capabilities_telemetry_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IGraphicsCapabilitiesSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GraphicsCapabilitiesSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GraphicsCapabilitiesSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GraphicsCapabilitiesSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGraphicsCapabilitiesTelemetry {
            supports_compute_shaders?: (boolean|null);
        }

        class GraphicsCapabilitiesTelemetry implements IGraphicsCapabilitiesTelemetry {
            constructor(properties?: POGOProtos.Rpc.IGraphicsCapabilitiesTelemetry);
            public supports_compute_shaders: boolean;
            public static encode(message: POGOProtos.Rpc.IGraphicsCapabilitiesTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GraphicsCapabilitiesTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GraphicsCapabilitiesTelemetry;
            public static toObject(message: POGOProtos.Rpc.GraphicsCapabilitiesTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGraphs {
            graph_data_type?: (POGOProtos.Rpc.GraphDataType|null);
            graph_data_type_version?: (number|null);
            graph_data?: (Uint8Array|null);
        }

        class Graphs implements IGraphs {
            constructor(properties?: POGOProtos.Rpc.IGraphs);
            public graph_data_type: POGOProtos.Rpc.GraphDataType;
            public graph_data_type_version: number;
            public graph_data: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IGraphs, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Graphs;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Graphs;
            public static toObject(message: POGOProtos.Rpc.Graphs, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGroupChallengeCriteriaProto {
            challenge_type?: (POGOProtos.Rpc.QuestType|null);
            challenge_goal?: (POGOProtos.Rpc.IQuestGoalProto|null);
            ignore_global_goal?: (boolean|null);
        }

        class GroupChallengeCriteriaProto implements IGroupChallengeCriteriaProto {
            constructor(properties?: POGOProtos.Rpc.IGroupChallengeCriteriaProto);
            public challenge_type: POGOProtos.Rpc.QuestType;
            public challenge_goal?: (POGOProtos.Rpc.IQuestGoalProto|null);
            public ignore_global_goal: boolean;
            public static encode(message: POGOProtos.Rpc.IGroupChallengeCriteriaProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GroupChallengeCriteriaProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GroupChallengeCriteriaProto;
            public static toObject(message: POGOProtos.Rpc.GroupChallengeCriteriaProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGroupChallengeDisplayProto {
            title?: (string|null);
            boost_rewards?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            custom_challenge_type_key?: (string|null);
            custom_work_together_key?: (string|null);
            custom_bonus_modal_title_key?: (string|null);
            custom_bonus_modal_description_key?: (string|null);
            custom_player_score_key_none?: (string|null);
            custom_player_score_key_singular?: (string|null);
            custom_player_score_key_plural?: (string|null);
            boost_rewards_complete?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            boost_rewards_incomplete?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
        }

        class GroupChallengeDisplayProto implements IGroupChallengeDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IGroupChallengeDisplayProto);
            public title: string;
            public boost_rewards: POGOProtos.Rpc.IBonusBoxProto[];
            public custom_challenge_type_key: string;
            public custom_work_together_key: string;
            public custom_bonus_modal_title_key: string;
            public custom_bonus_modal_description_key: string;
            public custom_player_score_key_none: string;
            public custom_player_score_key_singular: string;
            public custom_player_score_key_plural: string;
            public boost_rewards_complete: POGOProtos.Rpc.IBonusBoxProto[];
            public boost_rewards_incomplete: POGOProtos.Rpc.IBonusBoxProto[];
            public static encode(message: POGOProtos.Rpc.IGroupChallengeDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GroupChallengeDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GroupChallengeDisplayProto;
            public static toObject(message: POGOProtos.Rpc.GroupChallengeDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGuestAccountGameSettingsProto {
            max_num_pokemon_caught_for_popup?: (number|null);
            max_player_level_gate?: (number|null);
            sign_up_rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class GuestAccountGameSettingsProto implements IGuestAccountGameSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGuestAccountGameSettingsProto);
            public max_num_pokemon_caught_for_popup: number;
            public max_player_level_gate: number;
            public sign_up_rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IGuestAccountGameSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GuestAccountGameSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GuestAccountGameSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GuestAccountGameSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGuestAccountSettingsProto {
            enabled?: (boolean|null);
        }

        class GuestAccountSettingsProto implements IGuestAccountSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGuestAccountSettingsProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IGuestAccountSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GuestAccountSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GuestAccountSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GuestAccountSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGuestLoginAuthToken {
            secret?: (Uint8Array|null);
            api_key?: (string|null);
            device_id?: (string|null);
        }

        class GuestLoginAuthToken implements IGuestLoginAuthToken {
            constructor(properties?: POGOProtos.Rpc.IGuestLoginAuthToken);
            public secret: Uint8Array;
            public api_key: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IGuestLoginAuthToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GuestLoginAuthToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GuestLoginAuthToken;
            public static toObject(message: POGOProtos.Rpc.GuestLoginAuthToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGuestLoginSecretToken {
            token_contents?: (Uint8Array|null);
            signature?: (Uint8Array|null);
            iv?: (Uint8Array|null);
        }

        class GuestLoginSecretToken implements IGuestLoginSecretToken {
            constructor(properties?: POGOProtos.Rpc.IGuestLoginSecretToken);
            public token_contents: Uint8Array;
            public signature: Uint8Array;
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IGuestLoginSecretToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GuestLoginSecretToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GuestLoginSecretToken;
            public static toObject(message: POGOProtos.Rpc.GuestLoginSecretToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGuiSearchSettingsProto {
            gui_search_enabled?: (boolean|null);
            recommended_search?: (POGOProtos.Rpc.IRecommendedSearchProto[]|null);
            max_number_recent_searches?: (number|null);
            max_number_favorite_searches?: (number|null);
            max_query_length?: (number|null);
            show_all_button_enabled?: (boolean|null);
            search_help_url?: (string|null);
            complete_start_letter_count_per_language?: (string[]|null);
            transfer100_alone_enabled?: (boolean|null);
            complex_filter_enabled?: (boolean|null);
        }

        class GuiSearchSettingsProto implements IGuiSearchSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGuiSearchSettingsProto);
            public gui_search_enabled: boolean;
            public recommended_search: POGOProtos.Rpc.IRecommendedSearchProto[];
            public max_number_recent_searches: number;
            public max_number_favorite_searches: number;
            public max_query_length: number;
            public show_all_button_enabled: boolean;
            public search_help_url: string;
            public complete_start_letter_count_per_language: string[];
            public transfer100_alone_enabled: boolean;
            public complex_filter_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IGuiSearchSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GuiSearchSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GuiSearchSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GuiSearchSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymBadgeGmtSettingsProto {
            target?: (number[]|null);
            battle_winning_score_per_defender_cp?: (number|null);
            gym_defending_score_per_minute?: (number|null);
            berry_feeding_score?: (number|null);
            pokemon_deploy_score?: (number|null);
            raid_battle_winning_score?: (number|null);
            lose_all_battles_score?: (number|null);
        }

        class GymBadgeGmtSettingsProto implements IGymBadgeGmtSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGymBadgeGmtSettingsProto);
            public target: number[];
            public battle_winning_score_per_defender_cp: number;
            public gym_defending_score_per_minute: number;
            public berry_feeding_score: number;
            public pokemon_deploy_score: number;
            public raid_battle_winning_score: number;
            public lose_all_battles_score: number;
            public static encode(message: POGOProtos.Rpc.IGymBadgeGmtSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymBadgeGmtSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymBadgeGmtSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GymBadgeGmtSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymBadgeStats {
            total_time_defended_ms?: (number|Long|null);
            num_battles_won?: (number|null);
            num_berries_fed?: (number|null);
            num_deploys?: (number|null);
            num_battles_lost?: (number|null);
            gym_battles?: (POGOProtos.Rpc.IGymBattleProto[]|null);
        }

        class GymBadgeStats implements IGymBadgeStats {
            constructor(properties?: POGOProtos.Rpc.IGymBadgeStats);
            public total_time_defended_ms: (number|Long);
            public num_battles_won: number;
            public num_berries_fed: number;
            public num_deploys: number;
            public num_battles_lost: number;
            public gym_battles: POGOProtos.Rpc.IGymBattleProto[];
            public static encode(message: POGOProtos.Rpc.IGymBadgeStats, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymBadgeStats;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymBadgeStats;
            public static toObject(message: POGOProtos.Rpc.GymBadgeStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymBattleAttackOutProto {
            result?: (POGOProtos.Rpc.GymBattleAttackOutProto.Result|null);
            battle_update?: (POGOProtos.Rpc.IBattleUpdateProto|null);
            gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
        }

        class GymBattleAttackOutProto implements IGymBattleAttackOutProto {
            constructor(properties?: POGOProtos.Rpc.IGymBattleAttackOutProto);
            public result: POGOProtos.Rpc.GymBattleAttackOutProto.Result;
            public battle_update?: (POGOProtos.Rpc.IBattleUpdateProto|null);
            public gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            public static encode(message: POGOProtos.Rpc.IGymBattleAttackOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymBattleAttackOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymBattleAttackOutProto;
            public static toObject(message: POGOProtos.Rpc.GymBattleAttackOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymBattleAttackOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_ATTACK_ACTIONS = 2,
                ERROR_NOT_IN_RANGE = 3,
                ERROR_WRONG_BATTLE_TYPE = 4,
                ERROR_RAID_ACTIVE = 5
            }
        }

        interface IGymBattleAttackProto {
            gym_id?: (string|null);
            battle_id?: (string|null);
            attacker_actions?: (POGOProtos.Rpc.IBattleActionProto[]|null);
            last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProto|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            timestamp_ms?: (number|Long|null);
        }

        class GymBattleAttackProto implements IGymBattleAttackProto {
            constructor(properties?: POGOProtos.Rpc.IGymBattleAttackProto);
            public gym_id: string;
            public battle_id: string;
            public attacker_actions: POGOProtos.Rpc.IBattleActionProto[];
            public last_retrieved_action?: (POGOProtos.Rpc.IBattleActionProto|null);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGymBattleAttackProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymBattleAttackProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymBattleAttackProto;
            public static toObject(message: POGOProtos.Rpc.GymBattleAttackProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymBattleProto {
            battle_id?: (string|null);
            completed_ms?: (number|Long|null);
            incremented_gym_battle_friends?: (boolean|null);
        }

        class GymBattleProto implements IGymBattleProto {
            constructor(properties?: POGOProtos.Rpc.IGymBattleProto);
            public battle_id: string;
            public completed_ms: (number|Long);
            public incremented_gym_battle_friends: boolean;
            public static encode(message: POGOProtos.Rpc.IGymBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymBattleProto;
            public static toObject(message: POGOProtos.Rpc.GymBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymBattleSettingsProto {
            energy_per_sec?: (number|null);
            dodge_energy_cost?: (number|null);
            retarget_seconds?: (number|null);
            enemy_attack_interval?: (number|null);
            attack_server_interval?: (number|null);
            round_duration_seconds?: (number|null);
            bonus_time_per_ally_seconds?: (number|null);
            maximum_attackers_per_battle?: (number|null);
            same_type_attack_bonus_multiplier?: (number|null);
            maximum_energy?: (number|null);
            energy_delta_per_health_lost?: (number|null);
            dodge_duration_ms?: (number|null);
            minimum_player_level?: (number|null);
            swap_duration_ms?: (number|null);
            dodge_damage_reduction_percent?: (number|null);
            minimum_raid_player_level?: (number|null);
            shadow_pokemon_attack_bonus_multiplier?: (number|null);
            shadow_pokemon_defense_bonus_multiplier?: (number|null);
            purified_pokemon_attack_multiplier_vs_shadow?: (number|null);
            boss_energy_regeneration_per_health_lost?: (number|null);
        }

        class GymBattleSettingsProto implements IGymBattleSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IGymBattleSettingsProto);
            public energy_per_sec: number;
            public dodge_energy_cost: number;
            public retarget_seconds: number;
            public enemy_attack_interval: number;
            public attack_server_interval: number;
            public round_duration_seconds: number;
            public bonus_time_per_ally_seconds: number;
            public maximum_attackers_per_battle: number;
            public same_type_attack_bonus_multiplier: number;
            public maximum_energy: number;
            public energy_delta_per_health_lost: number;
            public dodge_duration_ms: number;
            public minimum_player_level: number;
            public swap_duration_ms: number;
            public dodge_damage_reduction_percent: number;
            public minimum_raid_player_level: number;
            public shadow_pokemon_attack_bonus_multiplier: number;
            public shadow_pokemon_defense_bonus_multiplier: number;
            public purified_pokemon_attack_multiplier_vs_shadow: number;
            public boss_energy_regeneration_per_health_lost: number;
            public static encode(message: POGOProtos.Rpc.IGymBattleSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymBattleSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymBattleSettingsProto;
            public static toObject(message: POGOProtos.Rpc.GymBattleSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymDefenderProto {
            motivated_pokemon?: (POGOProtos.Rpc.IMotivatedPokemonProto|null);
            deployment_totals?: (POGOProtos.Rpc.IDeploymentTotalsProto|null);
            trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
        }

        class GymDefenderProto implements IGymDefenderProto {
            constructor(properties?: POGOProtos.Rpc.IGymDefenderProto);
            public motivated_pokemon?: (POGOProtos.Rpc.IMotivatedPokemonProto|null);
            public deployment_totals?: (POGOProtos.Rpc.IDeploymentTotalsProto|null);
            public trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public static encode(message: POGOProtos.Rpc.IGymDefenderProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymDefenderProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymDefenderProto;
            public static toObject(message: POGOProtos.Rpc.GymDefenderProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymDeployOutProto {
            result?: (POGOProtos.Rpc.GymDeployOutProto.Result|null);
            gym_status_and_defenders?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            awarded_gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            cooldown_duration_millis?: (number|Long|null);
        }

        class GymDeployOutProto implements IGymDeployOutProto {
            constructor(properties?: POGOProtos.Rpc.IGymDeployOutProto);
            public result: POGOProtos.Rpc.GymDeployOutProto.Result;
            public gym_status_and_defenders?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            public awarded_gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            public cooldown_duration_millis: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGymDeployOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymDeployOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymDeployOutProto;
            public static toObject(message: POGOProtos.Rpc.GymDeployOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymDeployOutProto {

            enum Result {
                NO_RESULT_SET = 0,
                SUCCESS = 1,
                ERROR_ALREADY_HAS_POKEMON_ON_FORT = 2,
                ERROR_OPPOSING_TEAM_OWNS_FORT = 3,
                ERROR_FORT_IS_FULL = 4,
                ERROR_NOT_IN_RANGE = 5,
                ERROR_PLAYER_HAS_NO_TEAM = 6,
                ERROR_POKEMON_NOT_FULL_HP = 7,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 8,
                ERROR_POKEMON_IS_BUDDY = 9,
                ERROR_FORT_DEPLOY_LOCKOUT = 10,
                ERROR_PLAYER_HAS_NO_NICKNAME = 11,
                ERROR_POI_INACCESSIBLE = 12,
                ERROR_NOT_A_POKEMON = 13,
                ERROR_TOO_MANY_OF_SAME_KIND = 14,
                ERROR_TOO_MANY_DEPLOYED = 15,
                ERROR_TEAM_DEPLOY_LOCKOUT = 16,
                ERROR_LEGENDARY_POKEMON = 17,
                ERROR_INVALID_POKEMON = 18,
                ERROR_RAID_ACTIVE = 19,
                ERROR_FUSION_POKEMON = 20,
                ERROR_FUSION_COMPONENT_POKEMON = 21
            }
        }

        interface IGymDeployProto {
            fort_id?: (string|null);
            pokemon_id?: (number|Long|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class GymDeployProto implements IGymDeployProto {
            constructor(properties?: POGOProtos.Rpc.IGymDeployProto);
            public fort_id: string;
            public pokemon_id: (number|Long);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IGymDeployProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymDeployProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymDeployProto;
            public static toObject(message: POGOProtos.Rpc.GymDeployProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymDisplayProto {
            gym_event?: (POGOProtos.Rpc.IGymEventProto[]|null);
            total_gym_cp?: (number|null);
            lowest_pokemon_motivation?: (number|null);
            slots_available?: (number|null);
            occupied_millis?: (number|Long|null);
        }

        class GymDisplayProto implements IGymDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IGymDisplayProto);
            public gym_event: POGOProtos.Rpc.IGymEventProto[];
            public total_gym_cp: number;
            public lowest_pokemon_motivation: number;
            public slots_available: number;
            public occupied_millis: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGymDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymDisplayProto;
            public static toObject(message: POGOProtos.Rpc.GymDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymEventProto {
            trainer?: (string|null);
            timestamp_ms?: (number|Long|null);
            event?: (POGOProtos.Rpc.GymEventProto.Event|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_id?: (number|Long|null);
        }

        class GymEventProto implements IGymEventProto {
            constructor(properties?: POGOProtos.Rpc.IGymEventProto);
            public trainer: string;
            public timestamp_ms: (number|Long);
            public event: POGOProtos.Rpc.GymEventProto.Event;
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGymEventProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymEventProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymEventProto;
            public static toObject(message: POGOProtos.Rpc.GymEventProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymEventProto {

            enum Event {
                UNKNOWN = 0,
                POKEMON_FED = 1,
                POKEMON_DEPLOYED = 2,
                POKEMON_RETURNED = 3,
                BATTLE_WON = 4,
                BATTLE_LOSS = 5,
                RAID_STARTED = 6,
                RAID_ENDED = 7,
                GYM_NEUTRALIZED = 8
            }
        }

        interface IGymFeedPokemonOutProto {
            result?: (POGOProtos.Rpc.GymFeedPokemonOutProto.Result|null);
            gym_status_and_defenders?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            stardust_awarded?: (number|null);
            xp_awarded?: (number|null);
            num_candy_awarded?: (number|null);
            candy_family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            cooldown_complete?: (number|Long|null);
            num_xl_candy_awarded?: (number|null);
        }

        class GymFeedPokemonOutProto implements IGymFeedPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IGymFeedPokemonOutProto);
            public result: POGOProtos.Rpc.GymFeedPokemonOutProto.Result;
            public gym_status_and_defenders?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            public gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            public stardust_awarded: number;
            public xp_awarded: number;
            public num_candy_awarded: number;
            public candy_family_id: POGOProtos.Rpc.HoloPokemonFamilyId;
            public cooldown_complete: (number|Long);
            public num_xl_candy_awarded: number;
            public static encode(message: POGOProtos.Rpc.IGymFeedPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymFeedPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymFeedPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.GymFeedPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymFeedPokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_CANNOT_USE = 2,
                ERROR_NOT_IN_RANGE = 3,
                ERROR_POKEMON_NOT_THERE = 4,
                ERROR_POKEMON_FULL = 5,
                ERROR_NO_BERRIES_LEFT = 6,
                ERROR_WRONG_TEAM = 7,
                ERROR_WRONG_COUNT = 8,
                ERROR_TOO_FAST = 9,
                ERROR_TOO_FREQUENT = 10,
                ERROR_GYM_BUSY = 11,
                ERROR_RAID_ACTIVE = 12,
                ERROR_GYM_CLOSED = 13
            }
        }

        interface IGymFeedPokemonProto {
            item?: (POGOProtos.Rpc.Item|null);
            starting_quantity?: (number|null);
            gym_id?: (string|null);
            pokemon_id?: (number|Long|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class GymFeedPokemonProto implements IGymFeedPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IGymFeedPokemonProto);
            public item: POGOProtos.Rpc.Item;
            public starting_quantity: number;
            public gym_id: string;
            public pokemon_id: (number|Long);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IGymFeedPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymFeedPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymFeedPokemonProto;
            public static toObject(message: POGOProtos.Rpc.GymFeedPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymGetInfoOutProto {
            gym_status_and_defenders?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            name?: (string|null);
            url?: (string|null);
            result?: (POGOProtos.Rpc.GymGetInfoOutProto.Result|null);
            description?: (string|null);
            secondary_url?: (string|null);
            awarded_gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            checkin_image_url?: (string|null);
            event_info?: (POGOProtos.Rpc.IEventInfoProto|null);
            display_weather?: (POGOProtos.Rpc.IDisplayWeatherProto|null);
            promo_image?: (string[]|null);
            promo_description?: (string[]|null);
            call_to_action_link?: (string|null);
            server_ms?: (number|Long|null);
            sponsored_details?: (POGOProtos.Rpc.ISponsoredDetailsProto|null);
            poi_images_count?: (number|null);
            geostore_tombstone_message_key?: (string|null);
            geostore_suspension_message_key?: (string|null);
            vps_info?: (POGOProtos.Rpc.IFortVpsInfoProto|null);
        }

        class GymGetInfoOutProto implements IGymGetInfoOutProto {
            constructor(properties?: POGOProtos.Rpc.IGymGetInfoOutProto);
            public gym_status_and_defenders?: (POGOProtos.Rpc.IGymStatusAndDefendersProto|null);
            public name: string;
            public url: string;
            public result: POGOProtos.Rpc.GymGetInfoOutProto.Result;
            public description: string;
            public secondary_url: string;
            public awarded_gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge|null);
            public checkin_image_url: string;
            public event_info?: (POGOProtos.Rpc.IEventInfoProto|null);
            public display_weather?: (POGOProtos.Rpc.IDisplayWeatherProto|null);
            public promo_image: string[];
            public promo_description: string[];
            public call_to_action_link: string;
            public server_ms: (number|Long);
            public sponsored_details?: (POGOProtos.Rpc.ISponsoredDetailsProto|null);
            public poi_images_count: number;
            public geostore_tombstone_message_key: string;
            public geostore_suspension_message_key: string;
            public vps_info?: (POGOProtos.Rpc.IFortVpsInfoProto|null);
            public static encode(message: POGOProtos.Rpc.IGymGetInfoOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymGetInfoOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymGetInfoOutProto;
            public static toObject(message: POGOProtos.Rpc.GymGetInfoOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymGetInfoOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_GYM_DISABLED = 3
            }
        }

        interface IGymGetInfoProto {
            gym_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
            inviter_id?: (string|null);
        }

        class GymGetInfoProto implements IGymGetInfoProto {
            constructor(properties?: POGOProtos.Rpc.IGymGetInfoProto);
            public gym_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public inviter_id: string;
            public static encode(message: POGOProtos.Rpc.IGymGetInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymGetInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymGetInfoProto;
            public static toObject(message: POGOProtos.Rpc.GymGetInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymMembershipProto {
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            training_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class GymMembershipProto implements IGymMembershipProto {
            constructor(properties?: POGOProtos.Rpc.IGymMembershipProto);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public trainer_public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public training_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IGymMembershipProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymMembershipProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymMembershipProto;
            public static toObject(message: POGOProtos.Rpc.GymMembershipProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymPokemonSectionProto {
            pokemon_in_gym?: (POGOProtos.Rpc.GymPokemonSectionProto.IGymPokemonProto[]|null);
            pokemon_returned_today?: (POGOProtos.Rpc.GymPokemonSectionProto.IGymPokemonProto[]|null);
        }

        class GymPokemonSectionProto implements IGymPokemonSectionProto {
            constructor(properties?: POGOProtos.Rpc.IGymPokemonSectionProto);
            public pokemon_in_gym: POGOProtos.Rpc.GymPokemonSectionProto.IGymPokemonProto[];
            public pokemon_returned_today: POGOProtos.Rpc.GymPokemonSectionProto.IGymPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IGymPokemonSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymPokemonSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymPokemonSectionProto;
            public static toObject(message: POGOProtos.Rpc.GymPokemonSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymPokemonSectionProto {

            interface IGymPokemonProto {
                pokemon_id?: (number|Long|null);
                motivation?: (number|null);
                deployed_timestamp_ms?: (number|Long|null);
                coins_returned?: (number|null);
            }

            class GymPokemonProto implements IGymPokemonProto {
                constructor(properties?: POGOProtos.Rpc.GymPokemonSectionProto.IGymPokemonProto);
                public pokemon_id: (number|Long);
                public motivation: number;
                public deployed_timestamp_ms: (number|Long);
                public coins_returned: number;
                public static encode(message: POGOProtos.Rpc.GymPokemonSectionProto.IGymPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymPokemonSectionProto.GymPokemonProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymPokemonSectionProto.GymPokemonProto;
                public static toObject(message: POGOProtos.Rpc.GymPokemonSectionProto.GymPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGymStartSessionOutProto {
            result?: (POGOProtos.Rpc.GymStartSessionOutProto.Result|null);
            battle?: (POGOProtos.Rpc.IBattleProto|null);
        }

        class GymStartSessionOutProto implements IGymStartSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.IGymStartSessionOutProto);
            public result: POGOProtos.Rpc.GymStartSessionOutProto.Result;
            public battle?: (POGOProtos.Rpc.IBattleProto|null);
            public static encode(message: POGOProtos.Rpc.IGymStartSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymStartSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymStartSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.GymStartSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace GymStartSessionOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_GYM_NOT_FOUND = 2,
                ERROR_GYM_NEUTRAL = 3,
                ERROR_GYM_WRONG_TEAM = 4,
                ERROR_GYM_EMPTY = 5,
                ERROR_INVALID_DEFENDER = 6,
                ERROR_TRAINING_INVALID_ATTACKER_COUNT = 7,
                ERROR_ALL_POKEMON_FAINTED = 8,
                ERROR_TOO_MANY_BATTLES = 9,
                ERROR_TOO_MANY_PLAYERS = 10,
                ERROR_GYM_BATTLE_LOCKOUT = 11,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 12,
                ERROR_NOT_IN_RANGE = 13,
                ERROR_POI_INACCESSIBLE = 14,
                ERROR_RAID_ACTIVE = 15
            }
        }

        interface IGymStartSessionProto {
            gym_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            defending_pokemon_id?: (number|Long|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            lobby_join_time_ms?: (number|Long|null);
        }

        class GymStartSessionProto implements IGymStartSessionProto {
            constructor(properties?: POGOProtos.Rpc.IGymStartSessionProto);
            public gym_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public defending_pokemon_id: (number|Long);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public lobby_join_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IGymStartSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymStartSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymStartSessionProto;
            public static toObject(message: POGOProtos.Rpc.GymStartSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymStateProto {
            fort_map_data?: (POGOProtos.Rpc.IPokemonFortProto|null);
            gym_membership?: (POGOProtos.Rpc.IGymMembershipProto[]|null);
            deploy_lockout?: (boolean|null);
        }

        class GymStateProto implements IGymStateProto {
            constructor(properties?: POGOProtos.Rpc.IGymStateProto);
            public fort_map_data?: (POGOProtos.Rpc.IPokemonFortProto|null);
            public gym_membership: POGOProtos.Rpc.IGymMembershipProto[];
            public deploy_lockout: boolean;
            public static encode(message: POGOProtos.Rpc.IGymStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymStateProto;
            public static toObject(message: POGOProtos.Rpc.GymStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGymStatusAndDefendersProto {
            pokemon_fort_proto?: (POGOProtos.Rpc.IPokemonFortProto|null);
            gym_defender?: (POGOProtos.Rpc.IGymDefenderProto[]|null);
        }

        class GymStatusAndDefendersProto implements IGymStatusAndDefendersProto {
            constructor(properties?: POGOProtos.Rpc.IGymStatusAndDefendersProto);
            public pokemon_fort_proto?: (POGOProtos.Rpc.IPokemonFortProto|null);
            public gym_defender: POGOProtos.Rpc.IGymDefenderProto[];
            public static encode(message: POGOProtos.Rpc.IGymStatusAndDefendersProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.GymStatusAndDefendersProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.GymStatusAndDefendersProto;
            public static toObject(message: POGOProtos.Rpc.GymStatusAndDefendersProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHappeningNowSectionProto {
            events?: (POGOProtos.Rpc.IEventSectionProto[]|null);
        }

        class HappeningNowSectionProto implements IHappeningNowSectionProto {
            constructor(properties?: POGOProtos.Rpc.IHappeningNowSectionProto);
            public events: POGOProtos.Rpc.IEventSectionProto[];
            public static encode(message: POGOProtos.Rpc.IHappeningNowSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HappeningNowSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HappeningNowSectionProto;
            public static toObject(message: POGOProtos.Rpc.HappeningNowSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHapticsSettingsProto {
            advanced_haptics_enabled?: (boolean|null);
        }

        class HapticsSettingsProto implements IHapticsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IHapticsSettingsProto);
            public advanced_haptics_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IHapticsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HapticsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HapticsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.HapticsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHashedKeyProto {
            hashed_key_raw?: (string|null);
        }

        class HashedKeyProto implements IHashedKeyProto {
            constructor(properties?: POGOProtos.Rpc.IHashedKeyProto);
            public hashed_key_raw: string;
            public static encode(message: POGOProtos.Rpc.IHashedKeyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HashedKeyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HashedKeyProto;
            public static toObject(message: POGOProtos.Rpc.HashedKeyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHelpshiftSettingsProto {
            min_player_level?: (number|null);
            default_player_level?: (number|null);
        }

        class HelpshiftSettingsProto implements IHelpshiftSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IHelpshiftSettingsProto);
            public min_player_level: number;
            public default_player_level: number;
            public static encode(message: POGOProtos.Rpc.IHelpshiftSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HelpshiftSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HelpshiftSettingsProto;
            public static toObject(message: POGOProtos.Rpc.HelpshiftSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloFitnessReportProto {
            num_eggs_hatched?: (number|null);
            num_buddy_candy_earned?: (number|null);
            distance_walked_km?: (number|null);
            week_bucket?: (number|Long|null);
        }

        class HoloFitnessReportProto implements IHoloFitnessReportProto {
            constructor(properties?: POGOProtos.Rpc.IHoloFitnessReportProto);
            public num_eggs_hatched: number;
            public num_buddy_candy_earned: number;
            public distance_walked_km: number;
            public week_bucket: (number|Long);
            public static encode(message: POGOProtos.Rpc.IHoloFitnessReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloFitnessReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloFitnessReportProto;
            public static toObject(message: POGOProtos.Rpc.HoloFitnessReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloInventoryItemProto {
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            item?: (POGOProtos.Rpc.IItemProto|null);
            pokedex_entry?: (POGOProtos.Rpc.IPokedexEntryProto|null);
            player_stats?: (POGOProtos.Rpc.IPlayerStatsProto|null);
            player_currency?: (POGOProtos.Rpc.IPlayerCurrencyProto|null);
            player_camera?: (POGOProtos.Rpc.IPlayerCameraProto|null);
            inventory_upgrades?: (POGOProtos.Rpc.IInventoryUpgradesProto|null);
            applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
            egg_incubators?: (POGOProtos.Rpc.IEggIncubatorsProto|null);
            pokemon_family?: (POGOProtos.Rpc.IPokemonFamilyProto|null);
            quest?: (POGOProtos.Rpc.IQuestProto|null);
            avatar_item?: (POGOProtos.Rpc.IAvatarItemProto|null);
            raid_tickets?: (POGOProtos.Rpc.IRaidTicketsProto|null);
            quests?: (POGOProtos.Rpc.IQuestsProto|null);
            gift_boxes?: (POGOProtos.Rpc.IGiftBoxesProto|null);
            beluga_incense?: (POGOProtos.Rpc.IBelugaIncenseBoxProto|null);
            sparkly_incense?: (POGOProtos.Rpc.IBelugaIncenseBoxProto|null);
            limited_purchase_sku_record?: (POGOProtos.Rpc.ILimitedPurchaseSkuRecordProto|null);
            route_play?: (POGOProtos.Rpc.IRoutePlayProto|null);
            mega_evolve_species?: (POGOProtos.Rpc.IMegaEvolvePokemonSpeciesProto|null);
            sticker?: (POGOProtos.Rpc.IStickerProto|null);
            pokemon_home?: (POGOProtos.Rpc.IPokemonHomeProto|null);
            badge_data?: (POGOProtos.Rpc.IBadgeData|null);
            player_stats_snapshots?: (POGOProtos.Rpc.IPlayerStatsSnapshotsProto|null);
            fake_data?: (POGOProtos.Rpc.IFakeDataProto|null);
            pokedex_category_milestone?: (POGOProtos.Rpc.IPokedexCategoryMilestoneProto|null);
            sleep_records?: (POGOProtos.Rpc.ISleepRecordsProto|null);
            player_attributes?: (POGOProtos.Rpc.IPlayerAttributesProto|null);
            follower_data?: (POGOProtos.Rpc.IFollowerDataProto|null);
            squash_count?: (POGOProtos.Rpc.IDailyCounterProto|null);
            route_creations?: (POGOProtos.Rpc.IRouteCreationsProto|null);
            neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            neutral_avatar_item?: (POGOProtos.Rpc.INeutralAvatarItemProto|null);
            applied_bonuses?: (POGOProtos.Rpc.IAppliedBonusesProto|null);
            event_passes?: (POGOProtos.Rpc.IEventPassesStateProto|null);
            event_rsvps?: (POGOProtos.Rpc.IEventRsvpsProto|null);
            active_training_pokemon?: (POGOProtos.Rpc.IActivePokemonTrainingProto|null);
        }

        class HoloInventoryItemProto implements IHoloInventoryItemProto {
            constructor(properties?: POGOProtos.Rpc.IHoloInventoryItemProto);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public item?: (POGOProtos.Rpc.IItemProto|null);
            public pokedex_entry?: (POGOProtos.Rpc.IPokedexEntryProto|null);
            public player_stats?: (POGOProtos.Rpc.IPlayerStatsProto|null);
            public player_currency?: (POGOProtos.Rpc.IPlayerCurrencyProto|null);
            public player_camera?: (POGOProtos.Rpc.IPlayerCameraProto|null);
            public inventory_upgrades?: (POGOProtos.Rpc.IInventoryUpgradesProto|null);
            public applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
            public egg_incubators?: (POGOProtos.Rpc.IEggIncubatorsProto|null);
            public pokemon_family?: (POGOProtos.Rpc.IPokemonFamilyProto|null);
            public quest?: (POGOProtos.Rpc.IQuestProto|null);
            public avatar_item?: (POGOProtos.Rpc.IAvatarItemProto|null);
            public raid_tickets?: (POGOProtos.Rpc.IRaidTicketsProto|null);
            public quests?: (POGOProtos.Rpc.IQuestsProto|null);
            public gift_boxes?: (POGOProtos.Rpc.IGiftBoxesProto|null);
            public beluga_incense?: (POGOProtos.Rpc.IBelugaIncenseBoxProto|null);
            public sparkly_incense?: (POGOProtos.Rpc.IBelugaIncenseBoxProto|null);
            public limited_purchase_sku_record?: (POGOProtos.Rpc.ILimitedPurchaseSkuRecordProto|null);
            public route_play?: (POGOProtos.Rpc.IRoutePlayProto|null);
            public mega_evolve_species?: (POGOProtos.Rpc.IMegaEvolvePokemonSpeciesProto|null);
            public sticker?: (POGOProtos.Rpc.IStickerProto|null);
            public pokemon_home?: (POGOProtos.Rpc.IPokemonHomeProto|null);
            public badge_data?: (POGOProtos.Rpc.IBadgeData|null);
            public player_stats_snapshots?: (POGOProtos.Rpc.IPlayerStatsSnapshotsProto|null);
            public fake_data?: (POGOProtos.Rpc.IFakeDataProto|null);
            public pokedex_category_milestone?: (POGOProtos.Rpc.IPokedexCategoryMilestoneProto|null);
            public sleep_records?: (POGOProtos.Rpc.ISleepRecordsProto|null);
            public player_attributes?: (POGOProtos.Rpc.IPlayerAttributesProto|null);
            public follower_data?: (POGOProtos.Rpc.IFollowerDataProto|null);
            public squash_count?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public route_creations?: (POGOProtos.Rpc.IRouteCreationsProto|null);
            public neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public neutral_avatar_item?: (POGOProtos.Rpc.INeutralAvatarItemProto|null);
            public applied_bonuses?: (POGOProtos.Rpc.IAppliedBonusesProto|null);
            public event_passes?: (POGOProtos.Rpc.IEventPassesStateProto|null);
            public event_rsvps?: (POGOProtos.Rpc.IEventRsvpsProto|null);
            public active_training_pokemon?: (POGOProtos.Rpc.IActivePokemonTrainingProto|null);
            public Type?: ("pokemon"|"item"|"pokedex_entry"|"player_stats"|"player_currency"|"player_camera"|"inventory_upgrades"|"applied_items"|"egg_incubators"|"pokemon_family"|"quest"|"avatar_item"|"raid_tickets"|"quests"|"gift_boxes"|"beluga_incense"|"sparkly_incense"|"limited_purchase_sku_record"|"route_play"|"mega_evolve_species"|"sticker"|"pokemon_home"|"badge_data"|"player_stats_snapshots"|"fake_data"|"pokedex_category_milestone"|"sleep_records"|"player_attributes"|"follower_data"|"squash_count"|"route_creations"|"neutral_avatar"|"neutral_avatar_item"|"applied_bonuses"|"event_passes"|"event_rsvps"|"active_training_pokemon");
            public static encode(message: POGOProtos.Rpc.IHoloInventoryItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloInventoryItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloInventoryItemProto;
            public static toObject(message: POGOProtos.Rpc.HoloInventoryItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloInventoryKeyProto {
            pokemon_id?: (number|Long|null);
            item?: (POGOProtos.Rpc.Item|null);
            pokedex_entry_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            player_stats?: (boolean|null);
            player_currency?: (boolean|null);
            player_camera?: (boolean|null);
            inventory_upgrades?: (boolean|null);
            applied_items?: (boolean|null);
            egg_incubators?: (boolean|null);
            pokemon_family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            quest_type?: (POGOProtos.Rpc.QuestType|null);
            avatar_template_id?: (string|null);
            raid_tickets?: (boolean|null);
            quests?: (boolean|null);
            gift_boxes?: (boolean|null);
            beluga_incense_box?: (boolean|null);
            vs_seeker_upgrades?: (boolean|null);
            limited_purchase_sku_record?: (boolean|null);
            route_play?: (boolean|null);
            mega_evo_pokemon_species_id?: (number|null);
            sticker_id?: (string|null);
            pokemon_home?: (boolean|null);
            badge?: (POGOProtos.Rpc.HoloBadgeType|null);
            player_stats_snapshot?: (boolean|null);
            unknown_key?: (number|Long|null);
            fake_data?: (number|Long|null);
            pokedex_category?: (POGOProtos.Rpc.PokedexCategory|null);
            sleep_records?: (boolean|null);
            player_attributes?: (boolean|null);
            follower_data?: (boolean|null);
            sparkly_incense?: (boolean|null);
            squash_count?: (boolean|null);
            route_creation?: (boolean|null);
            neutral_avatar?: (boolean|null);
            neutral_avatar_item_template_id?: (string|null);
            applied_bonuses?: (boolean|null);
            event_passes?: (boolean|null);
            event_rsvps?: (boolean|null);
            active_training_pokemon?: (boolean|null);
        }

        class HoloInventoryKeyProto implements IHoloInventoryKeyProto {
            constructor(properties?: POGOProtos.Rpc.IHoloInventoryKeyProto);
            public pokemon_id?: (number|Long|null);
            public item?: (POGOProtos.Rpc.Item|null);
            public pokedex_entry_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            public player_stats?: (boolean|null);
            public player_currency?: (boolean|null);
            public player_camera?: (boolean|null);
            public inventory_upgrades?: (boolean|null);
            public applied_items?: (boolean|null);
            public egg_incubators?: (boolean|null);
            public pokemon_family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            public quest_type?: (POGOProtos.Rpc.QuestType|null);
            public avatar_template_id?: (string|null);
            public raid_tickets?: (boolean|null);
            public quests?: (boolean|null);
            public gift_boxes?: (boolean|null);
            public beluga_incense_box?: (boolean|null);
            public vs_seeker_upgrades?: (boolean|null);
            public limited_purchase_sku_record?: (boolean|null);
            public route_play?: (boolean|null);
            public mega_evo_pokemon_species_id?: (number|null);
            public sticker_id?: (string|null);
            public pokemon_home?: (boolean|null);
            public badge?: (POGOProtos.Rpc.HoloBadgeType|null);
            public player_stats_snapshot?: (boolean|null);
            public unknown_key?: (number|Long|null);
            public fake_data?: (number|Long|null);
            public pokedex_category?: (POGOProtos.Rpc.PokedexCategory|null);
            public sleep_records?: (boolean|null);
            public player_attributes?: (boolean|null);
            public follower_data?: (boolean|null);
            public sparkly_incense?: (boolean|null);
            public squash_count?: (boolean|null);
            public route_creation?: (boolean|null);
            public neutral_avatar?: (boolean|null);
            public neutral_avatar_item_template_id?: (string|null);
            public applied_bonuses?: (boolean|null);
            public event_passes?: (boolean|null);
            public event_rsvps?: (boolean|null);
            public active_training_pokemon?: (boolean|null);
            public Type?: ("pokemon_id"|"item"|"pokedex_entry_id"|"player_stats"|"player_currency"|"player_camera"|"inventory_upgrades"|"applied_items"|"egg_incubators"|"pokemon_family_id"|"quest_type"|"avatar_template_id"|"raid_tickets"|"quests"|"gift_boxes"|"beluga_incense_box"|"vs_seeker_upgrades"|"limited_purchase_sku_record"|"route_play"|"mega_evo_pokemon_species_id"|"sticker_id"|"pokemon_home"|"badge"|"player_stats_snapshot"|"unknown_key"|"fake_data"|"pokedex_category"|"sleep_records"|"player_attributes"|"follower_data"|"sparkly_incense"|"squash_count"|"route_creation"|"neutral_avatar"|"neutral_avatar_item_template_id"|"applied_bonuses"|"event_passes"|"event_rsvps"|"active_training_pokemon");
            public static encode(message: POGOProtos.Rpc.IHoloInventoryKeyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloInventoryKeyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloInventoryKeyProto;
            public static toObject(message: POGOProtos.Rpc.HoloInventoryKeyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloholoARBoundaryProto {
            vertices_with_relative_position?: (POGOProtos.Rpc.IHoloholoARBoundaryVertexProto[]|null);
            boundary_area_in_square_meters?: (number|null);
        }

        class HoloholoARBoundaryProto implements IHoloholoARBoundaryProto {
            constructor(properties?: POGOProtos.Rpc.IHoloholoARBoundaryProto);
            public vertices_with_relative_position: POGOProtos.Rpc.IHoloholoARBoundaryVertexProto[];
            public boundary_area_in_square_meters: number;
            public static encode(message: POGOProtos.Rpc.IHoloholoARBoundaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloholoARBoundaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloholoARBoundaryProto;
            public static toObject(message: POGOProtos.Rpc.HoloholoARBoundaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloholoARBoundaryVertexProto {
            x?: (number|null);
            y?: (number|null);
            z?: (number|null);
        }

        class HoloholoARBoundaryVertexProto implements IHoloholoARBoundaryVertexProto {
            constructor(properties?: POGOProtos.Rpc.IHoloholoARBoundaryVertexProto);
            public x: number;
            public y: number;
            public z: number;
            public static encode(message: POGOProtos.Rpc.IHoloholoARBoundaryVertexProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloholoARBoundaryVertexProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloholoARBoundaryVertexProto;
            public static toObject(message: POGOProtos.Rpc.HoloholoARBoundaryVertexProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloholoClientTelemetryOmniProto {
            boot_time?: (POGOProtos.Rpc.IBootTime|null);
            frame_rate?: (POGOProtos.Rpc.IFrameRate|null);
            generic_click_telemetry?: (POGOProtos.Rpc.IGenericClickTelemetry|null);
            map_events_telemetry?: (POGOProtos.Rpc.IMapEventsTelemetry|null);
            spin_pokestop_telemetry?: (POGOProtos.Rpc.ISpinPokestopTelemetry|null);
            profile_page_telemetry?: (POGOProtos.Rpc.IProfilePageTelemetry|null);
            shopping_page_telemetry?: (POGOProtos.Rpc.IShoppingPageTelemetry|null);
            encounter_pokemon_telemetry?: (POGOProtos.Rpc.IEncounterPokemonTelemetry|null);
            catch_pokemon_telemetry?: (POGOProtos.Rpc.ICatchPokemonTelemetry|null);
            deploy_pokemon_telemetry?: (POGOProtos.Rpc.IDeployPokemonTelemetry|null);
            feed_pokemon_telemetry?: (POGOProtos.Rpc.IFeedPokemonTelemetry|null);
            evolve_pokemon_telemetry?: (POGOProtos.Rpc.IEvolvePokemonTelemetry|null);
            release_pokemon_telemetry?: (POGOProtos.Rpc.IReleasePokemonTelemetry|null);
            nickname_pokemon_telemetry?: (POGOProtos.Rpc.INicknamePokemonTelemetry|null);
            news_page_telemetry?: (POGOProtos.Rpc.INewsPageTelemetry|null);
            item_telemetry?: (POGOProtos.Rpc.IItemTelemetry|null);
            battle_party_telemetry?: (POGOProtos.Rpc.IBattlePartyTelemetry|null);
            passcode_redeem_telemetry?: (POGOProtos.Rpc.IPasscodeRedeemTelemetry|null);
            link_login_telemetry?: (POGOProtos.Rpc.ILinkLoginTelemetry|null);
            raid_telemetry?: (POGOProtos.Rpc.IRaidTelemetry|null);
            push_notification_telemetry?: (POGOProtos.Rpc.IPushNotificationTelemetry|null);
            avatar_customization_telemetry?: (POGOProtos.Rpc.IAvatarCustomizationTelemetry|null);
            read_point_of_interest_description_telemetry?: (POGOProtos.Rpc.IReadPointOfInterestDescriptionTelemetry|null);
            web_telemetry?: (POGOProtos.Rpc.IWebTelemetry|null);
            change_ar_telemetry?: (POGOProtos.Rpc.IChangeArTelemetry|null);
            weather_detail_click_telemetry?: (POGOProtos.Rpc.IWeatherDetailClickTelemetry|null);
            user_issue_weather_report?: (POGOProtos.Rpc.IUserIssueWeatherReport|null);
            pokemon_inventory_telemetry?: (POGOProtos.Rpc.IPokemonInventoryTelemetry|null);
            social_telemetry?: (POGOProtos.Rpc.ISocialTelemetry|null);
            check_encounter_info_telemetry?: (POGOProtos.Rpc.ICheckEncounterTrayInfoTelemetry|null);
            pokemon_go_plus_telemetry?: (POGOProtos.Rpc.IPokemonGoPlusTelemetry|null);
            rpc_timing_telemetry?: (POGOProtos.Rpc.IRpcResponseTelemetry|null);
            social_gift_count_telemetry?: (POGOProtos.Rpc.ISocialGiftCountTelemetry|null);
            asset_bundle_telemetry?: (POGOProtos.Rpc.IAssetBundleDownloadTelemetry|null);
            asset_poi_download_telemetry?: (POGOProtos.Rpc.IAssetPoiDownloadTelemetry|null);
            asset_stream_download_telemetry?: (POGOProtos.Rpc.IAssetStreamDownloadTelemetry|null);
            asset_stream_cache_culled_telemetry?: (POGOProtos.Rpc.IAssetStreamCacheCulledTelemetry|null);
            rpc_socket_timing_telemetry?: (POGOProtos.Rpc.IRpcSocketResponseTelemetry|null);
            permissions_flow?: (POGOProtos.Rpc.IPermissionsFlowTelemetry|null);
            device_service_toggle?: (POGOProtos.Rpc.IDeviceServiceToggleTelemetry|null);
            boot_telemetry?: (POGOProtos.Rpc.IBootTelemetry|null);
            user_attributes?: (POGOProtos.Rpc.IUserAttributesProto|null);
            onboarding_telemetry?: (POGOProtos.Rpc.IOnboardingTelemetry|null);
            login_action_telemetry?: (POGOProtos.Rpc.ILoginActionTelemetry|null);
            ar_photo_session_telemetry?: (POGOProtos.Rpc.IArPhotoSessionProto|null);
            invasion_telemetry?: (POGOProtos.Rpc.IInvasionTelemetry|null);
            combat_minigame_telemetry?: (POGOProtos.Rpc.ICombatMinigameTelemetry|null);
            leave_point_of_interest_telemetry?: (POGOProtos.Rpc.ILeavePointOfInterestTelemetry|null);
            view_point_of_interest_image_telemetry?: (POGOProtos.Rpc.IViewPointOfInterestImageTelemetry|null);
            combat_hub_entrance_telemetry?: (POGOProtos.Rpc.ICombatHubEntranceTelemetry|null);
            leave_interaction_range_telemetry?: (POGOProtos.Rpc.ILeaveInteractionRangeTelemetry|null);
            shopping_page_click_telemetry?: (POGOProtos.Rpc.IShoppingPageClickTelemetry|null);
            shopping_page_scroll_telemetry?: (POGOProtos.Rpc.IShoppingPageScrollTelemetry|null);
            device_specifications_telemetry?: (POGOProtos.Rpc.IDeviceSpecificationsTelemetry|null);
            screen_resolution_telemetry?: (POGOProtos.Rpc.IScreenResolutionTelemetry|null);
            ar_buddy_multiplayer_session_telemetry?: (POGOProtos.Rpc.IARBuddyMultiplayerSessionTelemetry|null);
            buddy_multiplayer_connection_failed_telemetry?: (POGOProtos.Rpc.IBuddyMultiplayerConnectionFailedProto|null);
            buddy_multiplayer_connection_succeeded_telemetry?: (POGOProtos.Rpc.IBuddyMultiplayerConnectionSucceededProto|null);
            buddy_multiplayer_time_to_get_session_telemetry?: (POGOProtos.Rpc.IBuddyMultiplayerTimeToGetSessionProto|null);
            player_hud_notification_click_telemetry?: (POGOProtos.Rpc.IPlayerHudNotificationClickTelemetry|null);
            monodepth_download_telemetry?: (POGOProtos.Rpc.IMonodepthDownloadTelemetry|null);
            ar_mapping_telemetry?: (POGOProtos.Rpc.IArMappingTelemetryProto|null);
            remote_raid_telemetry?: (POGOProtos.Rpc.IRemoteRaidTelemetry|null);
            device_os_telemetry?: (POGOProtos.Rpc.IDeviceOSTelemetry|null);
            niantic_profile_telemetry?: (POGOProtos.Rpc.INianticProfileTelemetry|null);
            change_online_status_telemetry?: (POGOProtos.Rpc.IChangeOnlineStatusTelemetry|null);
            deep_linking_telemetry?: (POGOProtos.Rpc.IDeepLinkingTelemetry|null);
            ar_mapping_session_telemetry?: (POGOProtos.Rpc.IArMappingSessionTelemetryProto|null);
            pokemon_home_telemetry?: (POGOProtos.Rpc.IPokemonHomeTelemetry|null);
            pokemon_search_telemetry?: (POGOProtos.Rpc.IPokemonSearchTelemetry|null);
            image_gallery_telemetry?: (POGOProtos.Rpc.IImageGalleryTelemetry|null);
            player_shown_level_up_share_screen_telemetry?: (POGOProtos.Rpc.IPlayerShownLevelUpShareScreenTelemetry|null);
            referral_telemetry?: (POGOProtos.Rpc.IReferralTelemetry|null);
            upload_management_telemetry?: (POGOProtos.Rpc.IUploadManagementTelemetry|null);
            wayspot_edit_telemetry?: (POGOProtos.Rpc.IWayspotEditTelemetry|null);
            client_settings_telemetry?: (POGOProtos.Rpc.IClientSettingsTelemetry|null);
            pokedex_category_selected_telemetry?: (POGOProtos.Rpc.IPokedexCategorySelectedTelemetry|null);
            percent_scrolled_telemetry?: (POGOProtos.Rpc.IPercentScrolledTelemetry|null);
            address_book_import_telemetry?: (POGOProtos.Rpc.IAddressBookImportTelemetry|null);
            missing_translation_telemetry?: (POGOProtos.Rpc.IMissingTranslationTelemetry|null);
            egg_hatch_telemetry?: (POGOProtos.Rpc.IEggHatchTelemetry|null);
            push_gateway_telemetry?: (POGOProtos.Rpc.IPushGatewayTelemetry|null);
            push_gateway_upstream_error_telemetry?: (POGOProtos.Rpc.IPushGatewayUpstreamErrorTelemetry|null);
            username_suggestion_telemetry?: (POGOProtos.Rpc.IUsernameSuggestionTelemetry|null);
            tutorial_telemetry?: (POGOProtos.Rpc.ITutorialTelemetry|null);
            postcard_book_telemetry?: (POGOProtos.Rpc.IPostcardBookTelemetry|null);
            social_inbox_telemetry?: (POGOProtos.Rpc.ISocialInboxLatencyTelemetry|null);
            home_widget_telemetry?: (POGOProtos.Rpc.IHomeWidgetTelemetry|null);
            pokemon_load_delay?: (POGOProtos.Rpc.IPokemonLoadDelay|null);
            account_deletion_initiated_telemetry?: (POGOProtos.Rpc.IAccountDeletionInitiatedTelemetry|null);
            fort_update_latency_telemetry?: (POGOProtos.Rpc.IFortUpdateLatencyTelemetry|null);
            get_map_objects_trigger_telemetry?: (POGOProtos.Rpc.IGetMapObjectsTriggerTelemetry|null);
            update_combat_response_time_telemetry?: (POGOProtos.Rpc.IUpdateCombatResponseTimeTelemetry|null);
            open_campfire_map_telemetry?: (POGOProtos.Rpc.IOpenCampfireMapTelemetry|null);
            download_all_assets_telemetry?: (POGOProtos.Rpc.IDownloadAllAssetsTelemetry|null);
            daily_adventure_incense_telemetry?: (POGOProtos.Rpc.IDailyAdventureIncenseTelemetry|null);
            client_toggle_settings_telemetry?: (POGOProtos.Rpc.IClientToggleSettingsTelemetry|null);
            notification_permissions_telemetry?: (POGOProtos.Rpc.INotificationPermissionsTelemetry|null);
            asset_refresh_telemetry?: (POGOProtos.Rpc.IAssetRefreshTelemetry|null);
            catch_card_telemetry?: (POGOProtos.Rpc.ICatchCardTelemetry|null);
            follower_pokemon_tapped_telemetry?: (POGOProtos.Rpc.IFollowerPokemonTappedTelemetry|null);
            size_record_break_telemetry?: (POGOProtos.Rpc.ISizeRecordBreakTelemetry|null);
            time_to_playable_telemetry?: (POGOProtos.Rpc.ITimeToPlayable|null);
            language_telemetry?: (POGOProtos.Rpc.ILanguageTelemetry|null);
            quest_list_telemetry?: (POGOProtos.Rpc.IQuestListTelemetry|null);
            map_righthand_icons_telemetry?: (POGOProtos.Rpc.IMapRighthandIconsTelemetry|null);
            showcase_details_telemetry?: (POGOProtos.Rpc.IShowcaseDetailsTelemetry|null);
            showcase_rewards_telemetry?: (POGOProtos.Rpc.IShowcaseRewardTelemetry|null);
            route_discovery_telemetry?: (POGOProtos.Rpc.IRouteDiscoveryTelemetry|null);
            route_play_tappable_spawned_telemetry?: (POGOProtos.Rpc.IRoutePlayTappableSpawnedTelemetry|null);
            route_error_telemetry?: (POGOProtos.Rpc.IRouteErrorTelemetry|null);
            field_effect_telemetry?: (POGOProtos.Rpc.IFieldEffectTelemetry|null);
            graphics_capabilities_telemetry?: (POGOProtos.Rpc.IGraphicsCapabilitiesTelemetry|null);
            iris_social_event_telemetry?: (POGOProtos.Rpc.IIrisSocialEventTelemetry|null);
            pokedex_filter_selected_telemetry?: (POGOProtos.Rpc.IPokedexFilterSelectedTelemetry|null);
            pokedex_region_selected_telemetry?: (POGOProtos.Rpc.IPokedexRegionSelectedTelemetry|null);
            pokedex_pokemon_selected_telemetry?: (POGOProtos.Rpc.IPokedexPokemonSelectedTelemetry|null);
            pokedex_session_telemetry?: (POGOProtos.Rpc.IPokedexSessionTelemetry|null);
            quest_dialog_telemetry?: (POGOProtos.Rpc.IQuestDialogTelemetry|null);
            raid_egg_notification_telemetry?: (POGOProtos.Rpc.IRaidEggNotificationTelemetry|null);
            tracked_pokemon_push_notification_telemetry?: (POGOProtos.Rpc.ITrackedPokemonPushNotificationTelemetry|null);
            server_data?: (POGOProtos.Rpc.IPlatformServerData|null);
            common_filters?: (POGOProtos.Rpc.IPlatformCommonFilterProto|null);
        }

        class HoloholoClientTelemetryOmniProto implements IHoloholoClientTelemetryOmniProto {
            constructor(properties?: POGOProtos.Rpc.IHoloholoClientTelemetryOmniProto);
            public boot_time?: (POGOProtos.Rpc.IBootTime|null);
            public frame_rate?: (POGOProtos.Rpc.IFrameRate|null);
            public generic_click_telemetry?: (POGOProtos.Rpc.IGenericClickTelemetry|null);
            public map_events_telemetry?: (POGOProtos.Rpc.IMapEventsTelemetry|null);
            public spin_pokestop_telemetry?: (POGOProtos.Rpc.ISpinPokestopTelemetry|null);
            public profile_page_telemetry?: (POGOProtos.Rpc.IProfilePageTelemetry|null);
            public shopping_page_telemetry?: (POGOProtos.Rpc.IShoppingPageTelemetry|null);
            public encounter_pokemon_telemetry?: (POGOProtos.Rpc.IEncounterPokemonTelemetry|null);
            public catch_pokemon_telemetry?: (POGOProtos.Rpc.ICatchPokemonTelemetry|null);
            public deploy_pokemon_telemetry?: (POGOProtos.Rpc.IDeployPokemonTelemetry|null);
            public feed_pokemon_telemetry?: (POGOProtos.Rpc.IFeedPokemonTelemetry|null);
            public evolve_pokemon_telemetry?: (POGOProtos.Rpc.IEvolvePokemonTelemetry|null);
            public release_pokemon_telemetry?: (POGOProtos.Rpc.IReleasePokemonTelemetry|null);
            public nickname_pokemon_telemetry?: (POGOProtos.Rpc.INicknamePokemonTelemetry|null);
            public news_page_telemetry?: (POGOProtos.Rpc.INewsPageTelemetry|null);
            public item_telemetry?: (POGOProtos.Rpc.IItemTelemetry|null);
            public battle_party_telemetry?: (POGOProtos.Rpc.IBattlePartyTelemetry|null);
            public passcode_redeem_telemetry?: (POGOProtos.Rpc.IPasscodeRedeemTelemetry|null);
            public link_login_telemetry?: (POGOProtos.Rpc.ILinkLoginTelemetry|null);
            public raid_telemetry?: (POGOProtos.Rpc.IRaidTelemetry|null);
            public push_notification_telemetry?: (POGOProtos.Rpc.IPushNotificationTelemetry|null);
            public avatar_customization_telemetry?: (POGOProtos.Rpc.IAvatarCustomizationTelemetry|null);
            public read_point_of_interest_description_telemetry?: (POGOProtos.Rpc.IReadPointOfInterestDescriptionTelemetry|null);
            public web_telemetry?: (POGOProtos.Rpc.IWebTelemetry|null);
            public change_ar_telemetry?: (POGOProtos.Rpc.IChangeArTelemetry|null);
            public weather_detail_click_telemetry?: (POGOProtos.Rpc.IWeatherDetailClickTelemetry|null);
            public user_issue_weather_report?: (POGOProtos.Rpc.IUserIssueWeatherReport|null);
            public pokemon_inventory_telemetry?: (POGOProtos.Rpc.IPokemonInventoryTelemetry|null);
            public social_telemetry?: (POGOProtos.Rpc.ISocialTelemetry|null);
            public check_encounter_info_telemetry?: (POGOProtos.Rpc.ICheckEncounterTrayInfoTelemetry|null);
            public pokemon_go_plus_telemetry?: (POGOProtos.Rpc.IPokemonGoPlusTelemetry|null);
            public rpc_timing_telemetry?: (POGOProtos.Rpc.IRpcResponseTelemetry|null);
            public social_gift_count_telemetry?: (POGOProtos.Rpc.ISocialGiftCountTelemetry|null);
            public asset_bundle_telemetry?: (POGOProtos.Rpc.IAssetBundleDownloadTelemetry|null);
            public asset_poi_download_telemetry?: (POGOProtos.Rpc.IAssetPoiDownloadTelemetry|null);
            public asset_stream_download_telemetry?: (POGOProtos.Rpc.IAssetStreamDownloadTelemetry|null);
            public asset_stream_cache_culled_telemetry?: (POGOProtos.Rpc.IAssetStreamCacheCulledTelemetry|null);
            public rpc_socket_timing_telemetry?: (POGOProtos.Rpc.IRpcSocketResponseTelemetry|null);
            public permissions_flow?: (POGOProtos.Rpc.IPermissionsFlowTelemetry|null);
            public device_service_toggle?: (POGOProtos.Rpc.IDeviceServiceToggleTelemetry|null);
            public boot_telemetry?: (POGOProtos.Rpc.IBootTelemetry|null);
            public user_attributes?: (POGOProtos.Rpc.IUserAttributesProto|null);
            public onboarding_telemetry?: (POGOProtos.Rpc.IOnboardingTelemetry|null);
            public login_action_telemetry?: (POGOProtos.Rpc.ILoginActionTelemetry|null);
            public ar_photo_session_telemetry?: (POGOProtos.Rpc.IArPhotoSessionProto|null);
            public invasion_telemetry?: (POGOProtos.Rpc.IInvasionTelemetry|null);
            public combat_minigame_telemetry?: (POGOProtos.Rpc.ICombatMinigameTelemetry|null);
            public leave_point_of_interest_telemetry?: (POGOProtos.Rpc.ILeavePointOfInterestTelemetry|null);
            public view_point_of_interest_image_telemetry?: (POGOProtos.Rpc.IViewPointOfInterestImageTelemetry|null);
            public combat_hub_entrance_telemetry?: (POGOProtos.Rpc.ICombatHubEntranceTelemetry|null);
            public leave_interaction_range_telemetry?: (POGOProtos.Rpc.ILeaveInteractionRangeTelemetry|null);
            public shopping_page_click_telemetry?: (POGOProtos.Rpc.IShoppingPageClickTelemetry|null);
            public shopping_page_scroll_telemetry?: (POGOProtos.Rpc.IShoppingPageScrollTelemetry|null);
            public device_specifications_telemetry?: (POGOProtos.Rpc.IDeviceSpecificationsTelemetry|null);
            public screen_resolution_telemetry?: (POGOProtos.Rpc.IScreenResolutionTelemetry|null);
            public ar_buddy_multiplayer_session_telemetry?: (POGOProtos.Rpc.IARBuddyMultiplayerSessionTelemetry|null);
            public buddy_multiplayer_connection_failed_telemetry?: (POGOProtos.Rpc.IBuddyMultiplayerConnectionFailedProto|null);
            public buddy_multiplayer_connection_succeeded_telemetry?: (POGOProtos.Rpc.IBuddyMultiplayerConnectionSucceededProto|null);
            public buddy_multiplayer_time_to_get_session_telemetry?: (POGOProtos.Rpc.IBuddyMultiplayerTimeToGetSessionProto|null);
            public player_hud_notification_click_telemetry?: (POGOProtos.Rpc.IPlayerHudNotificationClickTelemetry|null);
            public monodepth_download_telemetry?: (POGOProtos.Rpc.IMonodepthDownloadTelemetry|null);
            public ar_mapping_telemetry?: (POGOProtos.Rpc.IArMappingTelemetryProto|null);
            public remote_raid_telemetry?: (POGOProtos.Rpc.IRemoteRaidTelemetry|null);
            public device_os_telemetry?: (POGOProtos.Rpc.IDeviceOSTelemetry|null);
            public niantic_profile_telemetry?: (POGOProtos.Rpc.INianticProfileTelemetry|null);
            public change_online_status_telemetry?: (POGOProtos.Rpc.IChangeOnlineStatusTelemetry|null);
            public deep_linking_telemetry?: (POGOProtos.Rpc.IDeepLinkingTelemetry|null);
            public ar_mapping_session_telemetry?: (POGOProtos.Rpc.IArMappingSessionTelemetryProto|null);
            public pokemon_home_telemetry?: (POGOProtos.Rpc.IPokemonHomeTelemetry|null);
            public pokemon_search_telemetry?: (POGOProtos.Rpc.IPokemonSearchTelemetry|null);
            public image_gallery_telemetry?: (POGOProtos.Rpc.IImageGalleryTelemetry|null);
            public player_shown_level_up_share_screen_telemetry?: (POGOProtos.Rpc.IPlayerShownLevelUpShareScreenTelemetry|null);
            public referral_telemetry?: (POGOProtos.Rpc.IReferralTelemetry|null);
            public upload_management_telemetry?: (POGOProtos.Rpc.IUploadManagementTelemetry|null);
            public wayspot_edit_telemetry?: (POGOProtos.Rpc.IWayspotEditTelemetry|null);
            public client_settings_telemetry?: (POGOProtos.Rpc.IClientSettingsTelemetry|null);
            public pokedex_category_selected_telemetry?: (POGOProtos.Rpc.IPokedexCategorySelectedTelemetry|null);
            public percent_scrolled_telemetry?: (POGOProtos.Rpc.IPercentScrolledTelemetry|null);
            public address_book_import_telemetry?: (POGOProtos.Rpc.IAddressBookImportTelemetry|null);
            public missing_translation_telemetry?: (POGOProtos.Rpc.IMissingTranslationTelemetry|null);
            public egg_hatch_telemetry?: (POGOProtos.Rpc.IEggHatchTelemetry|null);
            public push_gateway_telemetry?: (POGOProtos.Rpc.IPushGatewayTelemetry|null);
            public push_gateway_upstream_error_telemetry?: (POGOProtos.Rpc.IPushGatewayUpstreamErrorTelemetry|null);
            public username_suggestion_telemetry?: (POGOProtos.Rpc.IUsernameSuggestionTelemetry|null);
            public tutorial_telemetry?: (POGOProtos.Rpc.ITutorialTelemetry|null);
            public postcard_book_telemetry?: (POGOProtos.Rpc.IPostcardBookTelemetry|null);
            public social_inbox_telemetry?: (POGOProtos.Rpc.ISocialInboxLatencyTelemetry|null);
            public home_widget_telemetry?: (POGOProtos.Rpc.IHomeWidgetTelemetry|null);
            public pokemon_load_delay?: (POGOProtos.Rpc.IPokemonLoadDelay|null);
            public account_deletion_initiated_telemetry?: (POGOProtos.Rpc.IAccountDeletionInitiatedTelemetry|null);
            public fort_update_latency_telemetry?: (POGOProtos.Rpc.IFortUpdateLatencyTelemetry|null);
            public get_map_objects_trigger_telemetry?: (POGOProtos.Rpc.IGetMapObjectsTriggerTelemetry|null);
            public update_combat_response_time_telemetry?: (POGOProtos.Rpc.IUpdateCombatResponseTimeTelemetry|null);
            public open_campfire_map_telemetry?: (POGOProtos.Rpc.IOpenCampfireMapTelemetry|null);
            public download_all_assets_telemetry?: (POGOProtos.Rpc.IDownloadAllAssetsTelemetry|null);
            public daily_adventure_incense_telemetry?: (POGOProtos.Rpc.IDailyAdventureIncenseTelemetry|null);
            public client_toggle_settings_telemetry?: (POGOProtos.Rpc.IClientToggleSettingsTelemetry|null);
            public notification_permissions_telemetry?: (POGOProtos.Rpc.INotificationPermissionsTelemetry|null);
            public asset_refresh_telemetry?: (POGOProtos.Rpc.IAssetRefreshTelemetry|null);
            public catch_card_telemetry?: (POGOProtos.Rpc.ICatchCardTelemetry|null);
            public follower_pokemon_tapped_telemetry?: (POGOProtos.Rpc.IFollowerPokemonTappedTelemetry|null);
            public size_record_break_telemetry?: (POGOProtos.Rpc.ISizeRecordBreakTelemetry|null);
            public time_to_playable_telemetry?: (POGOProtos.Rpc.ITimeToPlayable|null);
            public language_telemetry?: (POGOProtos.Rpc.ILanguageTelemetry|null);
            public quest_list_telemetry?: (POGOProtos.Rpc.IQuestListTelemetry|null);
            public map_righthand_icons_telemetry?: (POGOProtos.Rpc.IMapRighthandIconsTelemetry|null);
            public showcase_details_telemetry?: (POGOProtos.Rpc.IShowcaseDetailsTelemetry|null);
            public showcase_rewards_telemetry?: (POGOProtos.Rpc.IShowcaseRewardTelemetry|null);
            public route_discovery_telemetry?: (POGOProtos.Rpc.IRouteDiscoveryTelemetry|null);
            public route_play_tappable_spawned_telemetry?: (POGOProtos.Rpc.IRoutePlayTappableSpawnedTelemetry|null);
            public route_error_telemetry?: (POGOProtos.Rpc.IRouteErrorTelemetry|null);
            public field_effect_telemetry?: (POGOProtos.Rpc.IFieldEffectTelemetry|null);
            public graphics_capabilities_telemetry?: (POGOProtos.Rpc.IGraphicsCapabilitiesTelemetry|null);
            public iris_social_event_telemetry?: (POGOProtos.Rpc.IIrisSocialEventTelemetry|null);
            public pokedex_filter_selected_telemetry?: (POGOProtos.Rpc.IPokedexFilterSelectedTelemetry|null);
            public pokedex_region_selected_telemetry?: (POGOProtos.Rpc.IPokedexRegionSelectedTelemetry|null);
            public pokedex_pokemon_selected_telemetry?: (POGOProtos.Rpc.IPokedexPokemonSelectedTelemetry|null);
            public pokedex_session_telemetry?: (POGOProtos.Rpc.IPokedexSessionTelemetry|null);
            public quest_dialog_telemetry?: (POGOProtos.Rpc.IQuestDialogTelemetry|null);
            public raid_egg_notification_telemetry?: (POGOProtos.Rpc.IRaidEggNotificationTelemetry|null);
            public tracked_pokemon_push_notification_telemetry?: (POGOProtos.Rpc.ITrackedPokemonPushNotificationTelemetry|null);
            public server_data?: (POGOProtos.Rpc.IPlatformServerData|null);
            public common_filters?: (POGOProtos.Rpc.IPlatformCommonFilterProto|null);
            public TelemetryData?: ("boot_time"|"frame_rate"|"generic_click_telemetry"|"map_events_telemetry"|"spin_pokestop_telemetry"|"profile_page_telemetry"|"shopping_page_telemetry"|"encounter_pokemon_telemetry"|"catch_pokemon_telemetry"|"deploy_pokemon_telemetry"|"feed_pokemon_telemetry"|"evolve_pokemon_telemetry"|"release_pokemon_telemetry"|"nickname_pokemon_telemetry"|"news_page_telemetry"|"item_telemetry"|"battle_party_telemetry"|"passcode_redeem_telemetry"|"link_login_telemetry"|"raid_telemetry"|"push_notification_telemetry"|"avatar_customization_telemetry"|"read_point_of_interest_description_telemetry"|"web_telemetry"|"change_ar_telemetry"|"weather_detail_click_telemetry"|"user_issue_weather_report"|"pokemon_inventory_telemetry"|"social_telemetry"|"check_encounter_info_telemetry"|"pokemon_go_plus_telemetry"|"rpc_timing_telemetry"|"social_gift_count_telemetry"|"asset_bundle_telemetry"|"asset_poi_download_telemetry"|"asset_stream_download_telemetry"|"asset_stream_cache_culled_telemetry"|"rpc_socket_timing_telemetry"|"permissions_flow"|"device_service_toggle"|"boot_telemetry"|"user_attributes"|"onboarding_telemetry"|"login_action_telemetry"|"ar_photo_session_telemetry"|"invasion_telemetry"|"combat_minigame_telemetry"|"leave_point_of_interest_telemetry"|"view_point_of_interest_image_telemetry"|"combat_hub_entrance_telemetry"|"leave_interaction_range_telemetry"|"shopping_page_click_telemetry"|"shopping_page_scroll_telemetry"|"device_specifications_telemetry"|"screen_resolution_telemetry"|"ar_buddy_multiplayer_session_telemetry"|"buddy_multiplayer_connection_failed_telemetry"|"buddy_multiplayer_connection_succeeded_telemetry"|"buddy_multiplayer_time_to_get_session_telemetry"|"player_hud_notification_click_telemetry"|"monodepth_download_telemetry"|"ar_mapping_telemetry"|"remote_raid_telemetry"|"device_os_telemetry"|"niantic_profile_telemetry"|"change_online_status_telemetry"|"deep_linking_telemetry"|"ar_mapping_session_telemetry"|"pokemon_home_telemetry"|"pokemon_search_telemetry"|"image_gallery_telemetry"|"player_shown_level_up_share_screen_telemetry"|"referral_telemetry"|"upload_management_telemetry"|"wayspot_edit_telemetry"|"client_settings_telemetry"|"pokedex_category_selected_telemetry"|"percent_scrolled_telemetry"|"address_book_import_telemetry"|"missing_translation_telemetry"|"egg_hatch_telemetry"|"push_gateway_telemetry"|"push_gateway_upstream_error_telemetry"|"username_suggestion_telemetry"|"tutorial_telemetry"|"postcard_book_telemetry"|"social_inbox_telemetry"|"home_widget_telemetry"|"pokemon_load_delay"|"account_deletion_initiated_telemetry"|"fort_update_latency_telemetry"|"get_map_objects_trigger_telemetry"|"update_combat_response_time_telemetry"|"open_campfire_map_telemetry"|"download_all_assets_telemetry"|"daily_adventure_incense_telemetry"|"client_toggle_settings_telemetry"|"notification_permissions_telemetry"|"asset_refresh_telemetry"|"catch_card_telemetry"|"follower_pokemon_tapped_telemetry"|"size_record_break_telemetry"|"time_to_playable_telemetry"|"language_telemetry"|"quest_list_telemetry"|"map_righthand_icons_telemetry"|"showcase_details_telemetry"|"showcase_rewards_telemetry"|"route_discovery_telemetry"|"route_play_tappable_spawned_telemetry"|"route_error_telemetry"|"field_effect_telemetry"|"graphics_capabilities_telemetry"|"iris_social_event_telemetry"|"pokedex_filter_selected_telemetry"|"pokedex_region_selected_telemetry"|"pokedex_pokemon_selected_telemetry"|"pokedex_session_telemetry"|"quest_dialog_telemetry"|"raid_egg_notification_telemetry"|"tracked_pokemon_push_notification_telemetry");
            public static encode(message: POGOProtos.Rpc.IHoloholoClientTelemetryOmniProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloholoClientTelemetryOmniProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloholoClientTelemetryOmniProto;
            public static toObject(message: POGOProtos.Rpc.HoloholoClientTelemetryOmniProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHoloholoMeshMetadata {
            ar_boundaries?: (POGOProtos.Rpc.IHoloholoARBoundaryProto[]|null);
        }

        class HoloholoMeshMetadata implements IHoloholoMeshMetadata {
            constructor(properties?: POGOProtos.Rpc.IHoloholoMeshMetadata);
            public ar_boundaries: POGOProtos.Rpc.IHoloholoARBoundaryProto[];
            public static encode(message: POGOProtos.Rpc.IHoloholoMeshMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HoloholoMeshMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HoloholoMeshMetadata;
            public static toObject(message: POGOProtos.Rpc.HoloholoMeshMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IHomeWidgetSettingsProto {
            eggs_widget_rewards_enabled?: (boolean|null);
            eggs_widget_rewards?: (POGOProtos.Rpc.HomeWidgetSettingsProto.IEggsWidgetRewards|null);
            buddy_widget_rewards_enabled?: (boolean|null);
            buddy_widget_rewards?: (POGOProtos.Rpc.HomeWidgetSettingsProto.IBuddyWidgetRewards|null);
            widget_tutorial_settings?: (POGOProtos.Rpc.HomeWidgetSettingsProto.IWidgetTutorialSettings[]|null);
            global_widget_tutorial_cooldown_ms?: (number|Long|null);
        }

        class HomeWidgetSettingsProto implements IHomeWidgetSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IHomeWidgetSettingsProto);
            public eggs_widget_rewards_enabled: boolean;
            public eggs_widget_rewards?: (POGOProtos.Rpc.HomeWidgetSettingsProto.IEggsWidgetRewards|null);
            public buddy_widget_rewards_enabled: boolean;
            public buddy_widget_rewards?: (POGOProtos.Rpc.HomeWidgetSettingsProto.IBuddyWidgetRewards|null);
            public widget_tutorial_settings: POGOProtos.Rpc.HomeWidgetSettingsProto.IWidgetTutorialSettings[];
            public global_widget_tutorial_cooldown_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IHomeWidgetSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HomeWidgetSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HomeWidgetSettingsProto;
            public static toObject(message: POGOProtos.Rpc.HomeWidgetSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace HomeWidgetSettingsProto {

            interface IBuddyWidgetRewards {
                affection_distance_multiplier?: (number|null);
                bonus_candies?: (number|null);
            }

            class BuddyWidgetRewards implements IBuddyWidgetRewards {
                constructor(properties?: POGOProtos.Rpc.HomeWidgetSettingsProto.IBuddyWidgetRewards);
                public affection_distance_multiplier: number;
                public bonus_candies: number;
                public static encode(message: POGOProtos.Rpc.HomeWidgetSettingsProto.IBuddyWidgetRewards, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HomeWidgetSettingsProto.BuddyWidgetRewards;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HomeWidgetSettingsProto.BuddyWidgetRewards;
                public static toObject(message: POGOProtos.Rpc.HomeWidgetSettingsProto.BuddyWidgetRewards, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEggsWidgetRewards {
                distance_multiplier?: (number|null);
                reward_hatch_count?: (number|null);
                counter_attribute_key?: (string|null);
            }

            class EggsWidgetRewards implements IEggsWidgetRewards {
                constructor(properties?: POGOProtos.Rpc.HomeWidgetSettingsProto.IEggsWidgetRewards);
                public distance_multiplier: number;
                public reward_hatch_count: number;
                public counter_attribute_key: string;
                public static encode(message: POGOProtos.Rpc.HomeWidgetSettingsProto.IEggsWidgetRewards, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HomeWidgetSettingsProto.EggsWidgetRewards;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HomeWidgetSettingsProto.EggsWidgetRewards;
                public static toObject(message: POGOProtos.Rpc.HomeWidgetSettingsProto.EggsWidgetRewards, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWidgetTutorialSettings {
                widget_type?: (POGOProtos.Rpc.AdventureSyncProgressRequest.WidgetType|null);
                tutorial_enabled?: (boolean|null);
                reshow_cooldown_ms?: (number|Long|null);
            }

            class WidgetTutorialSettings implements IWidgetTutorialSettings {
                constructor(properties?: POGOProtos.Rpc.HomeWidgetSettingsProto.IWidgetTutorialSettings);
                public widget_type: POGOProtos.Rpc.AdventureSyncProgressRequest.WidgetType;
                public tutorial_enabled: boolean;
                public reshow_cooldown_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.HomeWidgetSettingsProto.IWidgetTutorialSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HomeWidgetSettingsProto.WidgetTutorialSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HomeWidgetSettingsProto.WidgetTutorialSettings;
                public static toObject(message: POGOProtos.Rpc.HomeWidgetSettingsProto.WidgetTutorialSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IHomeWidgetTelemetry {
            widget_type?: (POGOProtos.Rpc.AdventureSyncProgressRequest.WidgetType|null);
            status?: (POGOProtos.Rpc.HomeWidgetTelemetry.Status|null);
            platform?: (POGOProtos.Rpc.Platform|null);
        }

        class HomeWidgetTelemetry implements IHomeWidgetTelemetry {
            constructor(properties?: POGOProtos.Rpc.IHomeWidgetTelemetry);
            public widget_type: POGOProtos.Rpc.AdventureSyncProgressRequest.WidgetType;
            public status: POGOProtos.Rpc.HomeWidgetTelemetry.Status;
            public platform: POGOProtos.Rpc.Platform;
            public static encode(message: POGOProtos.Rpc.IHomeWidgetTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HomeWidgetTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HomeWidgetTelemetry;
            public static toObject(message: POGOProtos.Rpc.HomeWidgetTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace HomeWidgetTelemetry {

            enum Status {
                UNUSED = 0,
                IN_USE = 1,
                PAUSED = 2
            }
        }

        interface IHyperlocalExperimentClientProto {
            experiment_id?: (number|null);
            start_ms?: (number|Long|null);
            end_ms?: (number|Long|null);
            lat_degrees?: (number|null);
            lng_degrees?: (number|null);
            event_radius_m?: (number|null);
            challenge_bonus_key?: (string|null);
        }

        class HyperlocalExperimentClientProto implements IHyperlocalExperimentClientProto {
            constructor(properties?: POGOProtos.Rpc.IHyperlocalExperimentClientProto);
            public experiment_id: number;
            public start_ms: (number|Long);
            public end_ms: (number|Long);
            public lat_degrees: number;
            public lng_degrees: number;
            public event_radius_m: number;
            public challenge_bonus_key: string;
            public static encode(message: POGOProtos.Rpc.IHyperlocalExperimentClientProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.HyperlocalExperimentClientProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.HyperlocalExperimentClientProto;
            public static toObject(message: POGOProtos.Rpc.HyperlocalExperimentClientProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIBFCLightweightSettings {
            default_defense_multiplier?: (number|null);
            default_defense_override?: (number|null);
            default_attack_multiplier?: (number|null);
            default_attack_override?: (number|null);
            default_stamina_multiplier?: (number|null);
            default_stamina_override?: (number|null);
            default_energy_charge_multiplier?: (number|null);
            default_energy_charge_override?: (number|null);
        }

        class IBFCLightweightSettings implements IIBFCLightweightSettings {
            constructor(properties?: POGOProtos.Rpc.IIBFCLightweightSettings);
            public default_defense_multiplier: number;
            public default_defense_override: number;
            public default_attack_multiplier: number;
            public default_attack_override: number;
            public default_stamina_multiplier: number;
            public default_stamina_override: number;
            public default_energy_charge_multiplier: number;
            public default_energy_charge_override: number;
            public static encode(message: POGOProtos.Rpc.IIBFCLightweightSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IBFCLightweightSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IBFCLightweightSettings;
            public static toObject(message: POGOProtos.Rpc.IBFCLightweightSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapAvailableSkuProto {
            id?: (string|null);
            is_third_party_vendor_item?: (boolean|null);
            price?: (POGOProtos.Rpc.IIapCurrencyQuantityProto[]|null);
            currency_granted?: (POGOProtos.Rpc.IIapCurrencyQuantityProto[]|null);
            game_item_content?: (POGOProtos.Rpc.IIapGameItemContentProto[]|null);
            presentation_data?: (POGOProtos.Rpc.IIapSkuPresentationProto[]|null);
            can_be_purchased?: (boolean|null);
            subscription_id?: (string|null);
            rule_data?: (POGOProtos.Rpc.IIapStoreRuleDataProto[]|null);
            offer_id?: (string|null);
            has_purchased_subscription?: (boolean|null);
            subscription_group_id?: (string|null);
            subscription_level?: (number|null);
            rewarded_spend_points?: (number|null);
        }

        class IapAvailableSkuProto implements IIapAvailableSkuProto {
            constructor(properties?: POGOProtos.Rpc.IIapAvailableSkuProto);
            public id: string;
            public is_third_party_vendor_item: boolean;
            public price: POGOProtos.Rpc.IIapCurrencyQuantityProto[];
            public currency_granted: POGOProtos.Rpc.IIapCurrencyQuantityProto[];
            public game_item_content: POGOProtos.Rpc.IIapGameItemContentProto[];
            public presentation_data: POGOProtos.Rpc.IIapSkuPresentationProto[];
            public can_be_purchased: boolean;
            public subscription_id: string;
            public rule_data: POGOProtos.Rpc.IIapStoreRuleDataProto[];
            public offer_id: string;
            public has_purchased_subscription: boolean;
            public subscription_group_id: string;
            public subscription_level: number;
            public rewarded_spend_points: number;
            public static encode(message: POGOProtos.Rpc.IIapAvailableSkuProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapAvailableSkuProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapAvailableSkuProto;
            public static toObject(message: POGOProtos.Rpc.IapAvailableSkuProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapCurrencyQuantityProto {
            currency_type?: (string|null);
            quantity?: (number|null);
        }

        class IapCurrencyQuantityProto implements IIapCurrencyQuantityProto {
            constructor(properties?: POGOProtos.Rpc.IIapCurrencyQuantityProto);
            public currency_type: string;
            public quantity: number;
            public static encode(message: POGOProtos.Rpc.IIapCurrencyQuantityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapCurrencyQuantityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapCurrencyQuantityProto;
            public static toObject(message: POGOProtos.Rpc.IapCurrencyQuantityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapCurrencyUpdateProto {
            currency_name?: (string|null);
            currency_delta?: (number|null);
            currency_balance?: (number|null);
            fiat_purchased_balance?: (number|null);
        }

        class IapCurrencyUpdateProto implements IIapCurrencyUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IIapCurrencyUpdateProto);
            public currency_name: string;
            public currency_delta: number;
            public currency_balance: number;
            public fiat_purchased_balance: number;
            public static encode(message: POGOProtos.Rpc.IIapCurrencyUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapCurrencyUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapCurrencyUpdateProto;
            public static toObject(message: POGOProtos.Rpc.IapCurrencyUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapDisclosureDisplaySettingsProto {
            enabled_currency_language_pair?: (POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.ICurrencyLanguagePairProto[]|null);
        }

        class IapDisclosureDisplaySettingsProto implements IIapDisclosureDisplaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIapDisclosureDisplaySettingsProto);
            public enabled_currency_language_pair: POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.ICurrencyLanguagePairProto[];
            public static encode(message: POGOProtos.Rpc.IIapDisclosureDisplaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapDisclosureDisplaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapDisclosureDisplaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.IapDisclosureDisplaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapDisclosureDisplaySettingsProto {

            interface ICurrencyLanguagePairProto {
                currency?: (string|null);
                language?: (string|null);
            }

            class CurrencyLanguagePairProto implements ICurrencyLanguagePairProto {
                constructor(properties?: POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.ICurrencyLanguagePairProto);
                public currency: string;
                public language: string;
                public static encode(message: POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.ICurrencyLanguagePairProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.CurrencyLanguagePairProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.CurrencyLanguagePairProto;
                public static toObject(message: POGOProtos.Rpc.IapDisclosureDisplaySettingsProto.CurrencyLanguagePairProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIapGameItemContentProto {
            type?: (string|null);
            quantity?: (number|null);
        }

        class IapGameItemContentProto implements IIapGameItemContentProto {
            constructor(properties?: POGOProtos.Rpc.IIapGameItemContentProto);
            public type: string;
            public quantity: number;
            public static encode(message: POGOProtos.Rpc.IIapGameItemContentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGameItemContentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGameItemContentProto;
            public static toObject(message: POGOProtos.Rpc.IapGameItemContentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapGetActiveSubscriptionsRequestProto {
        }

        class IapGetActiveSubscriptionsRequestProto implements IIapGetActiveSubscriptionsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetActiveSubscriptionsRequestProto);
            public static encode(message: POGOProtos.Rpc.IIapGetActiveSubscriptionsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetActiveSubscriptionsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetActiveSubscriptionsRequestProto;
            public static toObject(message: POGOProtos.Rpc.IapGetActiveSubscriptionsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapGetActiveSubscriptionsResponseProto {
            subscription?: (POGOProtos.Rpc.IIapInAppPurchaseSubscriptionInfo[]|null);
        }

        class IapGetActiveSubscriptionsResponseProto implements IIapGetActiveSubscriptionsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetActiveSubscriptionsResponseProto);
            public subscription: POGOProtos.Rpc.IIapInAppPurchaseSubscriptionInfo[];
            public static encode(message: POGOProtos.Rpc.IIapGetActiveSubscriptionsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetActiveSubscriptionsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetActiveSubscriptionsResponseProto;
            public static toObject(message: POGOProtos.Rpc.IapGetActiveSubscriptionsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapGetAvailableSkusAndBalancesOutProto {
            status?: (POGOProtos.Rpc.IapGetAvailableSkusAndBalancesOutProto.Status|null);
            available_sku?: (POGOProtos.Rpc.IIapAvailableSkuProto[]|null);
            balance?: (POGOProtos.Rpc.IIapCurrencyQuantityProto[]|null);
            player_token?: (string|null);
            blocked_sku?: (POGOProtos.Rpc.IIapAvailableSkuProto[]|null);
            processed_at_ms?: (number|Long|null);
            rewarded_spend_state?: (POGOProtos.Rpc.IRewardedSpendStateProto|null);
        }

        class IapGetAvailableSkusAndBalancesOutProto implements IIapGetAvailableSkusAndBalancesOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesOutProto);
            public status: POGOProtos.Rpc.IapGetAvailableSkusAndBalancesOutProto.Status;
            public available_sku: POGOProtos.Rpc.IIapAvailableSkuProto[];
            public balance: POGOProtos.Rpc.IIapCurrencyQuantityProto[];
            public player_token: string;
            public blocked_sku: POGOProtos.Rpc.IIapAvailableSkuProto[];
            public processed_at_ms: (number|Long);
            public rewarded_spend_state?: (POGOProtos.Rpc.IRewardedSpendStateProto|null);
            public static encode(message: POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetAvailableSkusAndBalancesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetAvailableSkusAndBalancesOutProto;
            public static toObject(message: POGOProtos.Rpc.IapGetAvailableSkusAndBalancesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapGetAvailableSkusAndBalancesOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapGetAvailableSkusAndBalancesProto {
            store_name?: (string|null);
        }

        class IapGetAvailableSkusAndBalancesProto implements IIapGetAvailableSkusAndBalancesProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesProto);
            public store_name: string;
            public static encode(message: POGOProtos.Rpc.IIapGetAvailableSkusAndBalancesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetAvailableSkusAndBalancesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetAvailableSkusAndBalancesProto;
            public static toObject(message: POGOProtos.Rpc.IapGetAvailableSkusAndBalancesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapGetAvailableSubscriptionsRequestProto {
        }

        class IapGetAvailableSubscriptionsRequestProto implements IIapGetAvailableSubscriptionsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetAvailableSubscriptionsRequestProto);
            public static encode(message: POGOProtos.Rpc.IIapGetAvailableSubscriptionsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetAvailableSubscriptionsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetAvailableSubscriptionsRequestProto;
            public static toObject(message: POGOProtos.Rpc.IapGetAvailableSubscriptionsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapGetAvailableSubscriptionsResponseProto {
            status?: (POGOProtos.Rpc.IapGetAvailableSubscriptionsResponseProto.Status|null);
            player_token?: (string|null);
            available_subscription?: (POGOProtos.Rpc.IIapAvailableSkuProto[]|null);
        }

        class IapGetAvailableSubscriptionsResponseProto implements IIapGetAvailableSubscriptionsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetAvailableSubscriptionsResponseProto);
            public status: POGOProtos.Rpc.IapGetAvailableSubscriptionsResponseProto.Status;
            public player_token: string;
            public available_subscription: POGOProtos.Rpc.IIapAvailableSkuProto[];
            public static encode(message: POGOProtos.Rpc.IIapGetAvailableSubscriptionsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetAvailableSubscriptionsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetAvailableSubscriptionsResponseProto;
            public static toObject(message: POGOProtos.Rpc.IapGetAvailableSubscriptionsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapGetAvailableSubscriptionsResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapGetUserRequestProto {
            nia_account_id?: (string|null);
        }

        class IapGetUserRequestProto implements IIapGetUserRequestProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetUserRequestProto);
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IIapGetUserRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetUserRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetUserRequestProto;
            public static toObject(message: POGOProtos.Rpc.IapGetUserRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapGetUserResponseProto {
            status?: (POGOProtos.Rpc.IapGetUserResponseProto.Status|null);
            user_game_data?: (POGOProtos.Rpc.IIapUserGameDataProto|null);
        }

        class IapGetUserResponseProto implements IIapGetUserResponseProto {
            constructor(properties?: POGOProtos.Rpc.IIapGetUserResponseProto);
            public status: POGOProtos.Rpc.IapGetUserResponseProto.Status;
            public user_game_data?: (POGOProtos.Rpc.IIapUserGameDataProto|null);
            public static encode(message: POGOProtos.Rpc.IIapGetUserResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapGetUserResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapGetUserResponseProto;
            public static toObject(message: POGOProtos.Rpc.IapGetUserResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapGetUserResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                PLAYER_NOT_FOUND = 3,
                DISALLOW_IAP_PLAYER = 4
            }
        }

        interface IIapInAppPurchaseSubscriptionEntry {
            instance_id?: (string|null);
            player_id?: (string|null);
            start_time?: (number|Long|null);
            end_time?: (number|Long|null);
        }

        class IapInAppPurchaseSubscriptionEntry implements IIapInAppPurchaseSubscriptionEntry {
            constructor(properties?: POGOProtos.Rpc.IIapInAppPurchaseSubscriptionEntry);
            public instance_id: string;
            public player_id: string;
            public start_time: (number|Long);
            public end_time: (number|Long);
            public static encode(message: POGOProtos.Rpc.IIapInAppPurchaseSubscriptionEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapInAppPurchaseSubscriptionEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapInAppPurchaseSubscriptionEntry;
            public static toObject(message: POGOProtos.Rpc.IapInAppPurchaseSubscriptionEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapInAppPurchaseSubscriptionInfo {
            subscription_id?: (string|null);
            sku_id?: (string|null);
            purchase_period?: (POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.IPurchasePeriod[]|null);
            last_notification_time_ms?: (number|Long|null);
            lookup_id?: (string|null);
            tiered_sub_price?: ({ [k: string]: POGOProtos.Rpc.IIapSkuStorePrice }|null);
            state?: (POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.State|null);
            payment_state?: (POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.PaymentState|null);
        }

        class IapInAppPurchaseSubscriptionInfo implements IIapInAppPurchaseSubscriptionInfo {
            constructor(properties?: POGOProtos.Rpc.IIapInAppPurchaseSubscriptionInfo);
            public subscription_id: string;
            public sku_id: string;
            public purchase_period: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.IPurchasePeriod[];
            public last_notification_time_ms: (number|Long);
            public lookup_id: string;
            public tiered_sub_price: { [k: string]: POGOProtos.Rpc.IIapSkuStorePrice };
            public state: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.State;
            public payment_state: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.PaymentState;
            public static encode(message: POGOProtos.Rpc.IIapInAppPurchaseSubscriptionInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo;
            public static toObject(message: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapInAppPurchaseSubscriptionInfo {

            enum NativeStoreVendor {
                UNKNOWN_STORE = 0,
                GOOGLE = 1,
                APPLE = 2,
                DESKTOP = 3
            }

            enum PaymentState {
                UNKNOWN_STATE = 0,
                SUCCESS = 1,
                BILLING_ISSUE = 2
            }

            enum State {
                UNKNOWN = 0,
                ACTIVE = 1,
                CANCELLED = 2,
                EXPIRED = 3,
                GRACE_PERIOD = 4,
                FREE_TRIAL = 5,
                PENDING_PURCHASE = 6,
                REVOKED = 7,
                ON_HOLD = 8,
                OFFER_PERIOD = 9
            }

            interface IPurchasePeriod {
                subscription_end_time_ms?: (number|Long|null);
                receipt_timestamp_ms?: (number|Long|null);
                receipt?: (string|null);
                store_price?: (POGOProtos.Rpc.IIapSkuStorePrice|null);
                country_code?: (string|null);
                sku_id?: (string|null);
            }

            class PurchasePeriod implements IPurchasePeriod {
                constructor(properties?: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.IPurchasePeriod);
                public subscription_end_time_ms: (number|Long);
                public receipt_timestamp_ms: (number|Long);
                public receipt: string;
                public store_price?: (POGOProtos.Rpc.IIapSkuStorePrice|null);
                public country_code: string;
                public sku_id: string;
                public static encode(message: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.IPurchasePeriod, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.PurchasePeriod;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.PurchasePeriod;
                public static toObject(message: POGOProtos.Rpc.IapInAppPurchaseSubscriptionInfo.PurchasePeriod, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIapItemCategoryDisplayProto {
            category?: (POGOProtos.Rpc.HoloIapItemCategory|null);
            name?: (string|null);
            hidden?: (boolean|null);
            sort_order?: (number|null);
            banner_enabled?: (boolean|null);
            banner_title?: (string|null);
            image_url?: (string|null);
            description?: (string|null);
            display_rows?: (number|null);
            subcategory?: (string|null);
        }

        class IapItemCategoryDisplayProto implements IIapItemCategoryDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IIapItemCategoryDisplayProto);
            public category: POGOProtos.Rpc.HoloIapItemCategory;
            public name: string;
            public hidden: boolean;
            public sort_order: number;
            public banner_enabled: boolean;
            public banner_title: string;
            public image_url: string;
            public description: string;
            public display_rows: number;
            public subcategory: string;
            public static encode(message: POGOProtos.Rpc.IIapItemCategoryDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapItemCategoryDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapItemCategoryDisplayProto;
            public static toObject(message: POGOProtos.Rpc.IapItemCategoryDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapItemDisplayProto {
            sku?: (string|null);
            category?: (POGOProtos.Rpc.HoloIapItemCategory|null);
            sort_order?: (number|null);
            hidden?: (boolean|null);
            sale?: (boolean|null);
            sprite_id?: (string|null);
            title?: (string|null);
            description?: (string|null);
            sku_enable_time?: (string|null);
            sku_disable_time?: (string|null);
            sku_enable_time_utc_ms?: (number|Long|null);
            sku_disable_time_utc_ms?: (number|Long|null);
            subcategories?: (string[]|null);
            image_url?: (string|null);
            min_level?: (number|null);
            max_level?: (number|null);
            show_discount_tag?: (boolean|null);
            show_strikethrough_price?: (boolean|null);
            total_value?: (number|null);
        }

        class IapItemDisplayProto implements IIapItemDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IIapItemDisplayProto);
            public sku: string;
            public category: POGOProtos.Rpc.HoloIapItemCategory;
            public sort_order: number;
            public hidden: boolean;
            public sale: boolean;
            public sprite_id: string;
            public title: string;
            public description: string;
            public sku_enable_time: string;
            public sku_disable_time: string;
            public sku_enable_time_utc_ms: (number|Long);
            public sku_disable_time_utc_ms: (number|Long);
            public subcategories: string[];
            public image_url: string;
            public min_level: number;
            public max_level: number;
            public show_discount_tag: boolean;
            public show_strikethrough_price: boolean;
            public total_value: number;
            public static encode(message: POGOProtos.Rpc.IIapItemDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapItemDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapItemDisplayProto;
            public static toObject(message: POGOProtos.Rpc.IapItemDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapOfferRecord {
            offer_id?: (string|null);
            purchase_time_ms?: ((number|Long)[]|null);
            total_purchases?: (number|null);
            associated_sku_id?: (string[]|null);
        }

        class IapOfferRecord implements IIapOfferRecord {
            constructor(properties?: POGOProtos.Rpc.IIapOfferRecord);
            public offer_id: string;
            public purchase_time_ms: (number|Long)[];
            public total_purchases: number;
            public associated_sku_id: string[];
            public static encode(message: POGOProtos.Rpc.IIapOfferRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapOfferRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapOfferRecord;
            public static toObject(message: POGOProtos.Rpc.IapOfferRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapPlayerLocaleProto {
            country?: (string|null);
            language?: (string|null);
            timezone?: (string|null);
        }

        class IapPlayerLocaleProto implements IIapPlayerLocaleProto {
            constructor(properties?: POGOProtos.Rpc.IIapPlayerLocaleProto);
            public country: string;
            public language: string;
            public timezone: string;
            public static encode(message: POGOProtos.Rpc.IIapPlayerLocaleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapPlayerLocaleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapPlayerLocaleProto;
            public static toObject(message: POGOProtos.Rpc.IapPlayerLocaleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapProvisionedAppleTransactionProto {
            status?: (POGOProtos.Rpc.IapProvisionedAppleTransactionProto.Status|null);
            transaction_token?: (string|null);
            product_id?: (string|null);
            is_subscription?: (boolean|null);
            currency_code?: (string|null);
            price_paid?: (number|Long|null);
            purchase_time_ms?: (number|Long|null);
            subscription_receipt_id?: (string|null);
        }

        class IapProvisionedAppleTransactionProto implements IIapProvisionedAppleTransactionProto {
            constructor(properties?: POGOProtos.Rpc.IIapProvisionedAppleTransactionProto);
            public status: POGOProtos.Rpc.IapProvisionedAppleTransactionProto.Status;
            public transaction_token: string;
            public product_id: string;
            public is_subscription: boolean;
            public currency_code: string;
            public price_paid: (number|Long);
            public purchase_time_ms: (number|Long);
            public subscription_receipt_id: string;
            public static encode(message: POGOProtos.Rpc.IIapProvisionedAppleTransactionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapProvisionedAppleTransactionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapProvisionedAppleTransactionProto;
            public static toObject(message: POGOProtos.Rpc.IapProvisionedAppleTransactionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapProvisionedAppleTransactionProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                UNPROCESSED = 3
            }
        }

        interface IIapPurchaseSkuOutProto {
            status?: (POGOProtos.Rpc.IapPurchaseSkuOutProto.Status|null);
            added_inventory_item?: (Uint8Array[]|null);
            currency_update?: (POGOProtos.Rpc.IIapCurrencyUpdateProto[]|null);
        }

        class IapPurchaseSkuOutProto implements IIapPurchaseSkuOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapPurchaseSkuOutProto);
            public status: POGOProtos.Rpc.IapPurchaseSkuOutProto.Status;
            public added_inventory_item: Uint8Array[];
            public currency_update: POGOProtos.Rpc.IIapCurrencyUpdateProto[];
            public static encode(message: POGOProtos.Rpc.IIapPurchaseSkuOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapPurchaseSkuOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapPurchaseSkuOutProto;
            public static toObject(message: POGOProtos.Rpc.IapPurchaseSkuOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapPurchaseSkuOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                BALANCE_TOO_LOW = 3,
                SKU_NOT_AVAILABLE = 4,
                OVER_INVENTORY_LIMIT = 5,
                OFFER_NOT_AVAILABLE = 6
            }
        }

        interface IIapPurchaseSkuProto {
            sku_id?: (string|null);
            offer_id?: (string|null);
            store_name?: (string|null);
        }

        class IapPurchaseSkuProto implements IIapPurchaseSkuProto {
            constructor(properties?: POGOProtos.Rpc.IIapPurchaseSkuProto);
            public sku_id: string;
            public offer_id: string;
            public store_name: string;
            public static encode(message: POGOProtos.Rpc.IIapPurchaseSkuProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapPurchaseSkuProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapPurchaseSkuProto;
            public static toObject(message: POGOProtos.Rpc.IapPurchaseSkuProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapRedeemAppleReceiptOutProto {
            status?: (POGOProtos.Rpc.IapRedeemAppleReceiptOutProto.Status|null);
            provisioned_transaction_tokens?: (string[]|null);
            provisioned_transaction?: (POGOProtos.Rpc.IIapProvisionedAppleTransactionProto[]|null);
        }

        class IapRedeemAppleReceiptOutProto implements IIapRedeemAppleReceiptOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemAppleReceiptOutProto);
            public status: POGOProtos.Rpc.IapRedeemAppleReceiptOutProto.Status;
            public provisioned_transaction_tokens: string[];
            public provisioned_transaction: POGOProtos.Rpc.IIapProvisionedAppleTransactionProto[];
            public static encode(message: POGOProtos.Rpc.IIapRedeemAppleReceiptOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemAppleReceiptOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemAppleReceiptOutProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemAppleReceiptOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapRedeemAppleReceiptOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapRedeemAppleReceiptProto {
            receipt?: (string|null);
            purchase_currency?: (string|null);
            price_paid_e6?: (number|null);
            price_paid_e6_long?: (number|Long|null);
            store_prices?: ({ [k: string]: POGOProtos.Rpc.IIapSkuStorePrice }|null);
            country_code?: (string|null);
        }

        class IapRedeemAppleReceiptProto implements IIapRedeemAppleReceiptProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemAppleReceiptProto);
            public receipt: string;
            public purchase_currency: string;
            public price_paid_e6: number;
            public price_paid_e6_long: (number|Long);
            public store_prices: { [k: string]: POGOProtos.Rpc.IIapSkuStorePrice };
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IIapRedeemAppleReceiptProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemAppleReceiptProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemAppleReceiptProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemAppleReceiptProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapRedeemDesktopReceiptOutProto {
            status?: (POGOProtos.Rpc.IapRedeemDesktopReceiptOutProto.Status|null);
        }

        class IapRedeemDesktopReceiptOutProto implements IIapRedeemDesktopReceiptOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemDesktopReceiptOutProto);
            public status: POGOProtos.Rpc.IapRedeemDesktopReceiptOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IIapRedeemDesktopReceiptOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemDesktopReceiptOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemDesktopReceiptOutProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemDesktopReceiptOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapRedeemDesktopReceiptOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapRedeemDesktopReceiptProto {
            sku_id?: (string|null);
        }

        class IapRedeemDesktopReceiptProto implements IIapRedeemDesktopReceiptProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemDesktopReceiptProto);
            public sku_id: string;
            public static encode(message: POGOProtos.Rpc.IIapRedeemDesktopReceiptProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemDesktopReceiptProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemDesktopReceiptProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemDesktopReceiptProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapRedeemGoogleReceiptOutProto {
            status?: (POGOProtos.Rpc.IapRedeemGoogleReceiptOutProto.Status|null);
            transaction_token?: (string|null);
        }

        class IapRedeemGoogleReceiptOutProto implements IIapRedeemGoogleReceiptOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemGoogleReceiptOutProto);
            public status: POGOProtos.Rpc.IapRedeemGoogleReceiptOutProto.Status;
            public transaction_token: string;
            public static encode(message: POGOProtos.Rpc.IIapRedeemGoogleReceiptOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemGoogleReceiptOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemGoogleReceiptOutProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemGoogleReceiptOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapRedeemGoogleReceiptOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapRedeemGoogleReceiptProto {
            receipt?: (string|null);
            receipt_signature?: (string|null);
            purchase_currency?: (string|null);
            price_paid_e6?: (number|null);
            price_paid_e6_long?: (number|Long|null);
            country_code?: (string|null);
        }

        class IapRedeemGoogleReceiptProto implements IIapRedeemGoogleReceiptProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemGoogleReceiptProto);
            public receipt: string;
            public receipt_signature: string;
            public purchase_currency: string;
            public price_paid_e6: number;
            public price_paid_e6_long: (number|Long);
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IIapRedeemGoogleReceiptProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemGoogleReceiptProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemGoogleReceiptProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemGoogleReceiptProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapRedeemSamsungReceiptOutProto {
            status?: (POGOProtos.Rpc.IapRedeemSamsungReceiptOutProto.Status|null);
            purchase_id?: (string|null);
        }

        class IapRedeemSamsungReceiptOutProto implements IIapRedeemSamsungReceiptOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemSamsungReceiptOutProto);
            public status: POGOProtos.Rpc.IapRedeemSamsungReceiptOutProto.Status;
            public purchase_id: string;
            public static encode(message: POGOProtos.Rpc.IIapRedeemSamsungReceiptOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemSamsungReceiptOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemSamsungReceiptOutProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemSamsungReceiptOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapRedeemSamsungReceiptOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapRedeemSamsungReceiptProto {
            purchase_data?: (string|null);
            purchase_id?: (string|null);
            purchase_currency?: (string|null);
            price_paid_e6_long?: (number|Long|null);
        }

        class IapRedeemSamsungReceiptProto implements IIapRedeemSamsungReceiptProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemSamsungReceiptProto);
            public purchase_data: string;
            public purchase_id: string;
            public purchase_currency: string;
            public price_paid_e6_long: (number|Long);
            public static encode(message: POGOProtos.Rpc.IIapRedeemSamsungReceiptProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemSamsungReceiptProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemSamsungReceiptProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemSamsungReceiptProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapRedeemXsollaReceiptRequestProto {
            nia_account_id?: (string|null);
            receipt_id?: (string|null);
            receipt_content?: (POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.IReceiptContent[]|null);
            country?: (string|null);
        }

        class IapRedeemXsollaReceiptRequestProto implements IIapRedeemXsollaReceiptRequestProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemXsollaReceiptRequestProto);
            public nia_account_id: string;
            public receipt_id: string;
            public receipt_content: POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.IReceiptContent[];
            public country: string;
            public static encode(message: POGOProtos.Rpc.IIapRedeemXsollaReceiptRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapRedeemXsollaReceiptRequestProto {

            interface IReceiptContent {
                sku_id?: (string|null);
                quantity?: (number|null);
                store_price?: (POGOProtos.Rpc.IIapSkuStorePrice|null);
            }

            class ReceiptContent implements IReceiptContent {
                constructor(properties?: POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.IReceiptContent);
                public sku_id: string;
                public quantity: number;
                public store_price?: (POGOProtos.Rpc.IIapSkuStorePrice|null);
                public static encode(message: POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.IReceiptContent, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.ReceiptContent;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.ReceiptContent;
                public static toObject(message: POGOProtos.Rpc.IapRedeemXsollaReceiptRequestProto.ReceiptContent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIapRedeemXsollaReceiptResponseProto {
            status?: (POGOProtos.Rpc.IapRedeemXsollaReceiptResponseProto.Status|null);
            items?: (POGOProtos.Rpc.IIapGameItemContentProto[]|null);
            currency?: (POGOProtos.Rpc.IIapCurrencyQuantityProto[]|null);
        }

        class IapRedeemXsollaReceiptResponseProto implements IIapRedeemXsollaReceiptResponseProto {
            constructor(properties?: POGOProtos.Rpc.IIapRedeemXsollaReceiptResponseProto);
            public status: POGOProtos.Rpc.IapRedeemXsollaReceiptResponseProto.Status;
            public items: POGOProtos.Rpc.IIapGameItemContentProto[];
            public currency: POGOProtos.Rpc.IIapCurrencyQuantityProto[];
            public static encode(message: POGOProtos.Rpc.IIapRedeemXsollaReceiptResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapRedeemXsollaReceiptResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapRedeemXsollaReceiptResponseProto;
            public static toObject(message: POGOProtos.Rpc.IapRedeemXsollaReceiptResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapRedeemXsollaReceiptResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapSetInGameCurrencyExchangeRateOutProto {
            status?: (POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateOutProto.Status|null);
        }

        class IapSetInGameCurrencyExchangeRateOutProto implements IIapSetInGameCurrencyExchangeRateOutProto {
            constructor(properties?: POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateOutProto);
            public status: POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateOutProto;
            public static toObject(message: POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapSetInGameCurrencyExchangeRateOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IIapSetInGameCurrencyExchangeRateProto {
            in_game_currency?: (string|null);
            fiat_currency?: (string|null);
            fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
        }

        class IapSetInGameCurrencyExchangeRateProto implements IIapSetInGameCurrencyExchangeRateProto {
            constructor(properties?: POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateProto);
            public in_game_currency: string;
            public fiat_currency: string;
            public fiat_currency_cost_e6_per_in_game_unit: (number|Long);
            public static encode(message: POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateProto;
            public static toObject(message: POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSetInGameCurrencyExchangeRateTrackingProto {
            in_game_currency?: (string|null);
            fiat_currency?: (string|null);
            fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
            status?: (string|null);
        }

        class IapSetInGameCurrencyExchangeRateTrackingProto implements IIapSetInGameCurrencyExchangeRateTrackingProto {
            constructor(properties?: POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateTrackingProto);
            public in_game_currency: string;
            public fiat_currency: string;
            public fiat_currency_cost_e6_per_in_game_unit: (number|Long);
            public status: string;
            public static encode(message: POGOProtos.Rpc.IIapSetInGameCurrencyExchangeRateTrackingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateTrackingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateTrackingProto;
            public static toObject(message: POGOProtos.Rpc.IapSetInGameCurrencyExchangeRateTrackingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSettingsProto {
            daily_bonus_coins?: (number|null);
            daily_defender_bonus_per_pokemon?: (number[]|null);
            daily_defender_bonus_max_defenders?: (number|null);
            daily_defender_bonus_currency?: (string[]|null);
            min_time_between_claims_ms?: (number|Long|null);
            daily_bonus_enabled?: (boolean|null);
            daily_defender_bonus_enabled?: (boolean|null);
            prohibit_purchase_in_test_envirnment?: (boolean|null);
            ml_bundle_timer_enabled?: (boolean|null);
            iap_store_banners_enabled?: (boolean|null);
        }

        class IapSettingsProto implements IIapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIapSettingsProto);
            public daily_bonus_coins: number;
            public daily_defender_bonus_per_pokemon: number[];
            public daily_defender_bonus_max_defenders: number;
            public daily_defender_bonus_currency: string[];
            public min_time_between_claims_ms: (number|Long);
            public daily_bonus_enabled: boolean;
            public daily_defender_bonus_enabled: boolean;
            public prohibit_purchase_in_test_envirnment: boolean;
            public ml_bundle_timer_enabled: boolean;
            public iap_store_banners_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IIapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.IapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSkuContentProto {
            item_type?: (string|null);
            quantity?: (number|null);
        }

        class IapSkuContentProto implements IIapSkuContentProto {
            constructor(properties?: POGOProtos.Rpc.IIapSkuContentProto);
            public item_type: string;
            public quantity: number;
            public static encode(message: POGOProtos.Rpc.IIapSkuContentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuContentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuContentProto;
            public static toObject(message: POGOProtos.Rpc.IapSkuContentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSkuDataProto {
            id?: (string|null);
            is_enabled?: (boolean|null);
            content?: (POGOProtos.Rpc.IIapSkuContentProto[]|null);
            price?: (POGOProtos.Rpc.IIapSkuPriceProto[]|null);
            payment_type?: (POGOProtos.Rpc.IapSkuDataProto.SkuPaymentType|null);
            last_modified_timestamp_ms?: (number|Long|null);
            presentation_data?: (POGOProtos.Rpc.IIapSkuPresentationDataProto[]|null);
            enabled_window_start_ms?: (number|Long|null);
            enabled_window_end_ms?: (number|Long|null);
            subscription_id?: (string|null);
            sku_limit?: (POGOProtos.Rpc.IIapSkuLimitProto[]|null);
            is_offer_only?: (boolean|null);
            subscription_group_id?: (string|null);
            subscription_level?: (number|null);
            store_filter?: (string|null);
            rewarded_spend_points?: (number|null);
        }

        class IapSkuDataProto implements IIapSkuDataProto {
            constructor(properties?: POGOProtos.Rpc.IIapSkuDataProto);
            public id: string;
            public is_enabled: boolean;
            public content: POGOProtos.Rpc.IIapSkuContentProto[];
            public price: POGOProtos.Rpc.IIapSkuPriceProto[];
            public payment_type: POGOProtos.Rpc.IapSkuDataProto.SkuPaymentType;
            public last_modified_timestamp_ms: (number|Long);
            public presentation_data: POGOProtos.Rpc.IIapSkuPresentationDataProto[];
            public enabled_window_start_ms: (number|Long);
            public enabled_window_end_ms: (number|Long);
            public subscription_id: string;
            public sku_limit: POGOProtos.Rpc.IIapSkuLimitProto[];
            public is_offer_only: boolean;
            public subscription_group_id: string;
            public subscription_level: number;
            public store_filter: string;
            public rewarded_spend_points: number;
            public static encode(message: POGOProtos.Rpc.IIapSkuDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuDataProto;
            public static toObject(message: POGOProtos.Rpc.IapSkuDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapSkuDataProto {

            enum SkuPaymentType {
                UNSET = 0,
                THIRD_PARTY = 1,
                IN_GAME = 2,
                WEB = 3
            }
        }

        interface IIapSkuLimitProto {
            name?: (string|null);
            params?: ({ [k: string]: string }|null);
        }

        class IapSkuLimitProto implements IIapSkuLimitProto {
            constructor(properties?: POGOProtos.Rpc.IIapSkuLimitProto);
            public name: string;
            public params: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IIapSkuLimitProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuLimitProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuLimitProto;
            public static toObject(message: POGOProtos.Rpc.IapSkuLimitProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSkuPresentationDataProto {
            key?: (string|null);
            value?: (string|null);
        }

        class IapSkuPresentationDataProto implements IIapSkuPresentationDataProto {
            constructor(properties?: POGOProtos.Rpc.IIapSkuPresentationDataProto);
            public key: string;
            public value: string;
            public static encode(message: POGOProtos.Rpc.IIapSkuPresentationDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuPresentationDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuPresentationDataProto;
            public static toObject(message: POGOProtos.Rpc.IapSkuPresentationDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSkuPresentationProto {
            key?: (string|null);
            value?: (string|null);
        }

        class IapSkuPresentationProto implements IIapSkuPresentationProto {
            constructor(properties?: POGOProtos.Rpc.IIapSkuPresentationProto);
            public key: string;
            public value: string;
            public static encode(message: POGOProtos.Rpc.IIapSkuPresentationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuPresentationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuPresentationProto;
            public static toObject(message: POGOProtos.Rpc.IapSkuPresentationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSkuPriceProto {
            currency_type?: (string|null);
            price?: (number|null);
        }

        class IapSkuPriceProto implements IIapSkuPriceProto {
            constructor(properties?: POGOProtos.Rpc.IIapSkuPriceProto);
            public currency_type: string;
            public price: number;
            public static encode(message: POGOProtos.Rpc.IIapSkuPriceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuPriceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuPriceProto;
            public static toObject(message: POGOProtos.Rpc.IapSkuPriceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapSkuRecord {
            sku_id?: (string|null);
            purchase_time_ms?: ((number|Long)[]|null);
            total_purchases?: (number|null);
            offer_records?: ({ [k: string]: POGOProtos.Rpc.IapSkuRecord.ISkuOfferRecord }|null);
        }

        class IapSkuRecord implements IIapSkuRecord {
            constructor(properties?: POGOProtos.Rpc.IIapSkuRecord);
            public sku_id: string;
            public purchase_time_ms: (number|Long)[];
            public total_purchases: number;
            public offer_records: { [k: string]: POGOProtos.Rpc.IapSkuRecord.ISkuOfferRecord };
            public static encode(message: POGOProtos.Rpc.IIapSkuRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuRecord;
            public static toObject(message: POGOProtos.Rpc.IapSkuRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapSkuRecord {

            interface ISkuOfferRecord {
                purchase_time_ms?: ((number|Long)[]|null);
                total_purchases?: (number|null);
            }

            class SkuOfferRecord implements ISkuOfferRecord {
                constructor(properties?: POGOProtos.Rpc.IapSkuRecord.ISkuOfferRecord);
                public purchase_time_ms: (number|Long)[];
                public total_purchases: number;
                public static encode(message: POGOProtos.Rpc.IapSkuRecord.ISkuOfferRecord, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuRecord.SkuOfferRecord;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuRecord.SkuOfferRecord;
                public static toObject(message: POGOProtos.Rpc.IapSkuRecord.SkuOfferRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIapSkuStorePrice {
            currency_code?: (string|null);
            price_paid_e6?: (number|Long|null);
        }

        class IapSkuStorePrice implements IIapSkuStorePrice {
            constructor(properties?: POGOProtos.Rpc.IIapSkuStorePrice);
            public currency_code: string;
            public price_paid_e6: (number|Long);
            public static encode(message: POGOProtos.Rpc.IIapSkuStorePrice, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapSkuStorePrice;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapSkuStorePrice;
            public static toObject(message: POGOProtos.Rpc.IapSkuStorePrice, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapStoreBannerProto {
            category?: (POGOProtos.Rpc.HoloIapItemCategory|null);
            tag_str_key?: (string|null);
            title_str_key?: (string|null);
            banner_click_url?: (string|null);
            banner_image_address?: (string|null);
            position_in_category?: (POGOProtos.Rpc.IapStoreBannerProto.Position|null);
            is_visible?: (boolean|null);
        }

        class IapStoreBannerProto implements IIapStoreBannerProto {
            constructor(properties?: POGOProtos.Rpc.IIapStoreBannerProto);
            public category: POGOProtos.Rpc.HoloIapItemCategory;
            public tag_str_key: string;
            public title_str_key: string;
            public banner_click_url: string;
            public banner_image_address: string;
            public position_in_category: POGOProtos.Rpc.IapStoreBannerProto.Position;
            public is_visible: boolean;
            public static encode(message: POGOProtos.Rpc.IIapStoreBannerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapStoreBannerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapStoreBannerProto;
            public static toObject(message: POGOProtos.Rpc.IapStoreBannerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapStoreBannerProto {

            enum Position {
                TOP = 0,
                BOTTOM = 1
            }
        }

        interface IIapStoreRuleDataProto {
            rule_name?: (string|null);
            entry?: (POGOProtos.Rpc.IapStoreRuleDataProto.IRuleEntry[]|null);
        }

        class IapStoreRuleDataProto implements IIapStoreRuleDataProto {
            constructor(properties?: POGOProtos.Rpc.IIapStoreRuleDataProto);
            public rule_name: string;
            public entry: POGOProtos.Rpc.IapStoreRuleDataProto.IRuleEntry[];
            public static encode(message: POGOProtos.Rpc.IIapStoreRuleDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapStoreRuleDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapStoreRuleDataProto;
            public static toObject(message: POGOProtos.Rpc.IapStoreRuleDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IapStoreRuleDataProto {

            interface IRuleEntry {
                key?: (string|null);
                value?: (string|null);
            }

            class RuleEntry implements IRuleEntry {
                constructor(properties?: POGOProtos.Rpc.IapStoreRuleDataProto.IRuleEntry);
                public key: string;
                public value: string;
                public static encode(message: POGOProtos.Rpc.IapStoreRuleDataProto.IRuleEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapStoreRuleDataProto.RuleEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapStoreRuleDataProto.RuleEntry;
                public static toObject(message: POGOProtos.Rpc.IapStoreRuleDataProto.RuleEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIapUserGameDataProto {
            code_name?: (string|null);
            locale?: (POGOProtos.Rpc.IIapPlayerLocaleProto|null);
            virtual_currency?: (POGOProtos.Rpc.IIapVirtualCurrencyBalanceProto[]|null);
            plfe_instance?: (number|null);
            email?: (string|null);
            game_values?: (Uint8Array|null);
        }

        class IapUserGameDataProto implements IIapUserGameDataProto {
            constructor(properties?: POGOProtos.Rpc.IIapUserGameDataProto);
            public code_name: string;
            public locale?: (POGOProtos.Rpc.IIapPlayerLocaleProto|null);
            public virtual_currency: POGOProtos.Rpc.IIapVirtualCurrencyBalanceProto[];
            public plfe_instance: number;
            public email: string;
            public game_values: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IIapUserGameDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapUserGameDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapUserGameDataProto;
            public static toObject(message: POGOProtos.Rpc.IapUserGameDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIapVirtualCurrencyBalanceProto {
            currency_type?: (string|null);
            balance?: (number|null);
            fiat_purchased_balance?: (number|null);
        }

        class IapVirtualCurrencyBalanceProto implements IIapVirtualCurrencyBalanceProto {
            constructor(properties?: POGOProtos.Rpc.IIapVirtualCurrencyBalanceProto);
            public currency_type: string;
            public balance: number;
            public fiat_purchased_balance: number;
            public static encode(message: POGOProtos.Rpc.IIapVirtualCurrencyBalanceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IapVirtualCurrencyBalanceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IapVirtualCurrencyBalanceProto;
            public static toObject(message: POGOProtos.Rpc.IapVirtualCurrencyBalanceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIbfcProto {
            raid_enable?: (boolean|null);
            gym_battle_enable?: (boolean|null);
            combat_enable?: (boolean|null);
            default_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            alternate_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            default_to_alternate_ibfc_settings?: (POGOProtos.Rpc.IIbfcTransitionSettings|null);
            alternate_to_default_ibfc_settings?: (POGOProtos.Rpc.IIbfcTransitionSettings|null);
        }

        class IbfcProto implements IIbfcProto {
            constructor(properties?: POGOProtos.Rpc.IIbfcProto);
            public raid_enable: boolean;
            public gym_battle_enable: boolean;
            public combat_enable: boolean;
            public default_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public alternate_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public default_to_alternate_ibfc_settings?: (POGOProtos.Rpc.IIbfcTransitionSettings|null);
            public alternate_to_default_ibfc_settings?: (POGOProtos.Rpc.IIbfcTransitionSettings|null);
            public static encode(message: POGOProtos.Rpc.IIbfcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IbfcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IbfcProto;
            public static toObject(message: POGOProtos.Rpc.IbfcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIbfcTransitionSettings {
            animation_duration_turns?: (number|null);
            player?: (POGOProtos.Rpc.AnimationPlayPoint|null);
            ibfc_vfx_key?: (POGOProtos.Rpc.IbfcVfxKey|null);
            current_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
            replacement_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class IbfcTransitionSettings implements IIbfcTransitionSettings {
            constructor(properties?: POGOProtos.Rpc.IIbfcTransitionSettings);
            public animation_duration_turns: number;
            public player: POGOProtos.Rpc.AnimationPlayPoint;
            public ibfc_vfx_key: POGOProtos.Rpc.IbfcVfxKey;
            public current_move: POGOProtos.Rpc.HoloPokemonMove;
            public replacement_move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IIbfcTransitionSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IbfcTransitionSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IbfcTransitionSettings;
            public static toObject(message: POGOProtos.Rpc.IbfcTransitionSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIdfaSettingsProto {
            optin_enabled?: (boolean|null);
        }

        class IdfaSettingsProto implements IIdfaSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIdfaSettingsProto);
            public optin_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IIdfaSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IdfaSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IdfaSettingsProto;
            public static toObject(message: POGOProtos.Rpc.IdfaSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IImageGalleryTelemetry {
            image_gallery_telemetry_id?: (POGOProtos.Rpc.ImageGalleryTelemetry.ImageGalleryEventId|null);
        }

        class ImageGalleryTelemetry implements IImageGalleryTelemetry {
            constructor(properties?: POGOProtos.Rpc.IImageGalleryTelemetry);
            public image_gallery_telemetry_id: POGOProtos.Rpc.ImageGalleryTelemetry.ImageGalleryEventId;
            public static encode(message: POGOProtos.Rpc.IImageGalleryTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ImageGalleryTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ImageGalleryTelemetry;
            public static toObject(message: POGOProtos.Rpc.ImageGalleryTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ImageGalleryTelemetry {

            enum ImageGalleryEventId {
                UNKNOWN = 0,
                ENTER_IMAGE_GALLERY = 1,
                ENTER_IMAGE_DETAILS_PAGE = 2,
                VOTE_FROM_MAIN_GALLERY_PAGE = 3,
                UNVOTE_FROM_MAIN_GALLERY_PAGE = 4,
                VOTE_FROM_IMAGE_DETAILS_PAGE = 5,
                UNVOTE_FROM_IMAGE_DETAILS_PAGE = 6,
                ENTER_IMAGE_EDIT_FROM_GALLERY = 7
            }
        }

        interface IImageTextCreativeProto {
            name?: (string|null);
            title?: (string|null);
            description?: (string|null);
            preview_image_url?: (string|null);
            fullscreen_image_url?: (string|null);
            cta_link?: (string|null);
            web_ar_url?: (string|null);
            cta_text?: (POGOProtos.Rpc.CTAText|null);
        }

        class ImageTextCreativeProto implements IImageTextCreativeProto {
            constructor(properties?: POGOProtos.Rpc.IImageTextCreativeProto);
            public name: string;
            public title: string;
            public description: string;
            public preview_image_url: string;
            public fullscreen_image_url: string;
            public cta_link: string;
            public web_ar_url: string;
            public cta_text: POGOProtos.Rpc.CTAText;
            public static encode(message: POGOProtos.Rpc.IImageTextCreativeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ImageTextCreativeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ImageTextCreativeProto;
            public static toObject(message: POGOProtos.Rpc.ImageTextCreativeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IImpressionTrackingSettingsProto {
            impression_tracking_enabled?: (boolean|null);
            full_screen_ad_view_tracking_enabled?: (boolean|null);
            full_screen_poi_inspection_tracking_enabled?: (boolean|null);
            pokestop_spinner_interaction_tracking_enabled?: (boolean|null);
            approach_gym_tracking_enabled?: (boolean|null);
            approach_raid_tracking_enabled?: (boolean|null);
        }

        class ImpressionTrackingSettingsProto implements IImpressionTrackingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IImpressionTrackingSettingsProto);
            public impression_tracking_enabled: boolean;
            public full_screen_ad_view_tracking_enabled: boolean;
            public full_screen_poi_inspection_tracking_enabled: boolean;
            public pokestop_spinner_interaction_tracking_enabled: boolean;
            public approach_gym_tracking_enabled: boolean;
            public approach_raid_tracking_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IImpressionTrackingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ImpressionTrackingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ImpressionTrackingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ImpressionTrackingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IImpressionTrackingTag {
            tag_id?: (string|null);
            base_url?: (string|null);
            static_tags?: ({ [k: string]: string }|null);
            server_tags?: ({ [k: string]: string }|null);
            client_tags?: ({ [k: string]: string }|null);
        }

        class ImpressionTrackingTag implements IImpressionTrackingTag {
            constructor(properties?: POGOProtos.Rpc.IImpressionTrackingTag);
            public tag_id: string;
            public base_url: string;
            public static_tags: { [k: string]: string };
            public server_tags: { [k: string]: string };
            public client_tags: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IImpressionTrackingTag, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ImpressionTrackingTag;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ImpressionTrackingTag;
            public static toObject(message: POGOProtos.Rpc.ImpressionTrackingTag, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInAppSurveySettingsProto {
            feature_enabled?: (boolean|null);
            survey_poll_frequency_s?: (number|null);
        }

        class InAppSurveySettingsProto implements IInAppSurveySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInAppSurveySettingsProto);
            public feature_enabled: boolean;
            public survey_poll_frequency_s: number;
            public static encode(message: POGOProtos.Rpc.IInAppSurveySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InAppSurveySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InAppSurveySettingsProto;
            public static toObject(message: POGOProtos.Rpc.InAppSurveySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInGamePurchaseDetails {
            ingame_type?: (string|null);
            ingame_price?: (number|Long|null);
            remaining_ingame_balance?: (number|Long|null);
        }

        class InGamePurchaseDetails implements IInGamePurchaseDetails {
            constructor(properties?: POGOProtos.Rpc.IInGamePurchaseDetails);
            public ingame_type: string;
            public ingame_price: (number|Long);
            public remaining_ingame_balance: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInGamePurchaseDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InGamePurchaseDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InGamePurchaseDetails;
            public static toObject(message: POGOProtos.Rpc.InGamePurchaseDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInboxRouteErrorEvent {
            downstream_message_count?: (number|Long|null);
        }

        class InboxRouteErrorEvent implements IInboxRouteErrorEvent {
            constructor(properties?: POGOProtos.Rpc.IInboxRouteErrorEvent);
            public downstream_message_count: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInboxRouteErrorEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InboxRouteErrorEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InboxRouteErrorEvent;
            public static toObject(message: POGOProtos.Rpc.InboxRouteErrorEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncenseAttributesProto {
            incense_lifetime_seconds?: (number|null);
            pokemon_type?: (POGOProtos.Rpc.HoloPokemonType[]|null);
            pokemon_incense_type_probability?: (number|null);
            standing_time_between_encounters_sec?: (number|null);
            moving_time_between_encounter_sec?: (number|null);
            distance_required_for_shorter_interval_meters?: (number|null);
            pokemon_attracted_length_sec?: (number|null);
            spawn_table?: (POGOProtos.Rpc.ISpawnTablePokemonProto[]|null);
            spawn_table_probability?: (number|null);
            regional_pokemon_probability?: (number|null);
        }

        class IncenseAttributesProto implements IIncenseAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IIncenseAttributesProto);
            public incense_lifetime_seconds: number;
            public pokemon_type: POGOProtos.Rpc.HoloPokemonType[];
            public pokemon_incense_type_probability: number;
            public standing_time_between_encounters_sec: number;
            public moving_time_between_encounter_sec: number;
            public distance_required_for_shorter_interval_meters: number;
            public pokemon_attracted_length_sec: number;
            public spawn_table: POGOProtos.Rpc.ISpawnTablePokemonProto[];
            public spawn_table_probability: number;
            public regional_pokemon_probability: number;
            public static encode(message: POGOProtos.Rpc.IIncenseAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncenseAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncenseAttributesProto;
            public static toObject(message: POGOProtos.Rpc.IncenseAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncenseCreateDetail {
            incense_type?: (POGOProtos.Rpc.Item|null);
        }

        class IncenseCreateDetail implements IIncenseCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IIncenseCreateDetail);
            public incense_type: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IIncenseCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncenseCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncenseCreateDetail;
            public static toObject(message: POGOProtos.Rpc.IncenseCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncenseEncounterOutProto {
            result?: (POGOProtos.Rpc.IncenseEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class IncenseEncounterOutProto implements IIncenseEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IIncenseEncounterOutProto);
            public result: POGOProtos.Rpc.IncenseEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IIncenseEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncenseEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncenseEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.IncenseEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IncenseEncounterOutProto {

            enum Result {
                INCENSE_ENCOUNTER_UNKNOWN = 0,
                INCENSE_ENCOUNTER_SUCCESS = 1,
                INCENSE_ENCOUNTER_NOT_AVAILABLE = 2,
                POKEMON_INVENTORY_FULL = 3
            }
        }

        interface IIncenseEncounterProto {
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
        }

        class IncenseEncounterProto implements IIncenseEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IIncenseEncounterProto);
            public encounter_id: (number|Long);
            public encounter_location: string;
            public static encode(message: POGOProtos.Rpc.IIncenseEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncenseEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncenseEncounterProto;
            public static toObject(message: POGOProtos.Rpc.IncenseEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncidentGlobalSettingsProto {
            min_player_level?: (number|null);
            min_player_level_for_v2?: (number|null);
        }

        class IncidentGlobalSettingsProto implements IIncidentGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIncidentGlobalSettingsProto);
            public min_player_level: number;
            public min_player_level_for_v2: number;
            public static encode(message: POGOProtos.Rpc.IIncidentGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.IncidentGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncidentLookupProto {
            incident_id?: (string|null);
            fort_id?: (string|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
            context?: (POGOProtos.Rpc.EnumWrapper.InvasionContext|null);
        }

        class IncidentLookupProto implements IIncidentLookupProto {
            constructor(properties?: POGOProtos.Rpc.IIncidentLookupProto);
            public incident_id: string;
            public fort_id: string;
            public fort_lat: number;
            public fort_lng: number;
            public context: POGOProtos.Rpc.EnumWrapper.InvasionContext;
            public static encode(message: POGOProtos.Rpc.IIncidentLookupProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentLookupProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentLookupProto;
            public static toObject(message: POGOProtos.Rpc.IncidentLookupProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncidentPrioritySettingsProto {
            incident_priority?: (POGOProtos.Rpc.IncidentPrioritySettingsProto.IIncidentPriority[]|null);
        }

        class IncidentPrioritySettingsProto implements IIncidentPrioritySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIncidentPrioritySettingsProto);
            public incident_priority: POGOProtos.Rpc.IncidentPrioritySettingsProto.IIncidentPriority[];
            public static encode(message: POGOProtos.Rpc.IIncidentPrioritySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentPrioritySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentPrioritySettingsProto;
            public static toObject(message: POGOProtos.Rpc.IncidentPrioritySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IncidentPrioritySettingsProto {

            interface IIncidentPriority {
                priority?: (number|null);
                display_type?: (POGOProtos.Rpc.IncidentDisplayType|null);
                one_of_badge_types?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            }

            class IncidentPriority implements IIncidentPriority {
                constructor(properties?: POGOProtos.Rpc.IncidentPrioritySettingsProto.IIncidentPriority);
                public priority: number;
                public display_type: POGOProtos.Rpc.IncidentDisplayType;
                public one_of_badge_types: POGOProtos.Rpc.HoloBadgeType[];
                public static encode(message: POGOProtos.Rpc.IncidentPrioritySettingsProto.IIncidentPriority, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentPrioritySettingsProto.IncidentPriority;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentPrioritySettingsProto.IncidentPriority;
                public static toObject(message: POGOProtos.Rpc.IncidentPrioritySettingsProto.IncidentPriority, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIncidentRewardProto {
            invasion_spawn_group_template_id?: (string|null);
        }

        class IncidentRewardProto implements IIncidentRewardProto {
            constructor(properties?: POGOProtos.Rpc.IIncidentRewardProto);
            public invasion_spawn_group_template_id: string;
            public static encode(message: POGOProtos.Rpc.IIncidentRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentRewardProto;
            public static toObject(message: POGOProtos.Rpc.IncidentRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncidentTicketAttributesProto {
            ignore_full_inventory?: (boolean|null);
            upgrade_requirement_count?: (number|null);
            upgraded_item?: (POGOProtos.Rpc.Item|null);
        }

        class IncidentTicketAttributesProto implements IIncidentTicketAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IIncidentTicketAttributesProto);
            public ignore_full_inventory: boolean;
            public upgrade_requirement_count: number;
            public upgraded_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IIncidentTicketAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentTicketAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentTicketAttributesProto;
            public static toObject(message: POGOProtos.Rpc.IncidentTicketAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIncidentVisibilitySettingsProto {
            hide_incident_for_character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter[]|null);
        }

        class IncidentVisibilitySettingsProto implements IIncidentVisibilitySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIncidentVisibilitySettingsProto);
            public hide_incident_for_character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter[];
            public static encode(message: POGOProtos.Rpc.IIncidentVisibilitySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IncidentVisibilitySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IncidentVisibilitySettingsProto;
            public static toObject(message: POGOProtos.Rpc.IncidentVisibilitySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIndividualValueSettings {
            enabled?: (boolean|null);
            atk_floor?: (number|null);
            def_floor?: (number|null);
            sta_floor?: (number|null);
        }

        class IndividualValueSettings implements IIndividualValueSettings {
            constructor(properties?: POGOProtos.Rpc.IIndividualValueSettings);
            public enabled: boolean;
            public atk_floor: number;
            public def_floor: number;
            public sta_floor: number;
            public static encode(message: POGOProtos.Rpc.IIndividualValueSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IndividualValueSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IndividualValueSettings;
            public static toObject(message: POGOProtos.Rpc.IndividualValueSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInitializationEvent {
            install_mode?: (string|null);
            processor?: (string|null);
        }

        class InitializationEvent implements IInitializationEvent {
            constructor(properties?: POGOProtos.Rpc.IInitializationEvent);
            public install_mode: string;
            public processor: string;
            public static encode(message: POGOProtos.Rpc.IInitializationEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InitializationEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InitializationEvent;
            public static toObject(message: POGOProtos.Rpc.InitializationEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInputSettingsProto {
            enable_frame_independent_spin?: (boolean|null);
            milliseconds_processed_spin_force?: (number|null);
            spin_speed_multiplier?: (number|null);
        }

        class InputSettingsProto implements IInputSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInputSettingsProto);
            public enable_frame_independent_spin: boolean;
            public milliseconds_processed_spin_force: number;
            public spin_speed_multiplier: number;
            public static encode(message: POGOProtos.Rpc.IInputSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InputSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InputSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InputSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInstallTime {
            duration?: (number|null);
            install_phase?: (POGOProtos.Rpc.InstallTime.InstallPhase|null);
        }

        class InstallTime implements IInstallTime {
            constructor(properties?: POGOProtos.Rpc.IInstallTime);
            public duration: number;
            public install_phase: POGOProtos.Rpc.InstallTime.InstallPhase;
            public static encode(message: POGOProtos.Rpc.IInstallTime, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InstallTime;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InstallTime;
            public static toObject(message: POGOProtos.Rpc.InstallTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InstallTime {

            enum InstallPhase {
                UNDEFINED = 0,
                BOOT_UTIL = 1,
                BOOT_METRICS = 2,
                BOOT_NETWORK = 3,
                BOOT_STORAGE = 4,
                BOOT_LOCATION = 5,
                BOOT_AUTH = 6
            }
        }

        interface IInt32Value {
            value?: (number|null);
        }

        class Int32Value implements IInt32Value {
            constructor(properties?: POGOProtos.Rpc.IInt32Value);
            public value: number;
            public static encode(message: POGOProtos.Rpc.IInt32Value, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Int32Value;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Int32Value;
            public static toObject(message: POGOProtos.Rpc.Int32Value, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInt64Value {
            value?: (number|Long|null);
        }

        class Int64Value implements IInt64Value {
            constructor(properties?: POGOProtos.Rpc.IInt64Value);
            public value: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInt64Value, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Int64Value;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Int64Value;
            public static toObject(message: POGOProtos.Rpc.Int64Value, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAcceptFriendInviteOutProto {
            result?: (POGOProtos.Rpc.InternalAcceptFriendInviteOutProto.Result|null);
            friend?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
        }

        class InternalAcceptFriendInviteOutProto implements IInternalAcceptFriendInviteOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAcceptFriendInviteOutProto);
            public result: POGOProtos.Rpc.InternalAcceptFriendInviteOutProto.Result;
            public friend?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalAcceptFriendInviteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAcceptFriendInviteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAcceptFriendInviteOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalAcceptFriendInviteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAcceptFriendInviteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVITE_DOES_NOT_EXIST = 3,
                ERROR_MAX_FRIENDS_LIMIT_REACHED_DELETED = 4,
                ERROR_INVITE_HAS_BEEN_CANCELLED = 5,
                ERROR_SENDER_HAS_MAX_FRIENDS = 6,
                ERROR_RECEIVER_HAS_MAX_FRIENDS = 7,
                ERROR_SENDER_IS_BLOCKED = 8
            }
        }

        interface IInternalAcceptFriendInviteProto {
            player_id?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalAcceptFriendInviteProto implements IInternalAcceptFriendInviteProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAcceptFriendInviteProto);
            public player_id: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalAcceptFriendInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAcceptFriendInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAcceptFriendInviteProto;
            public static toObject(message: POGOProtos.Rpc.InternalAcceptFriendInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAccountContactSettings {
        }

        class InternalAccountContactSettings implements IInternalAccountContactSettings {
            constructor(properties?: POGOProtos.Rpc.IInternalAccountContactSettings);
            public static encode(message: POGOProtos.Rpc.IInternalAccountContactSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountContactSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountContactSettings;
            public static toObject(message: POGOProtos.Rpc.InternalAccountContactSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAccountContactSettings {

            enum ConsentStatus {
                UNKNOWN = 0,
                OPT_IN = 1,
                OPT_OUT = 2
            }
        }

        interface IInternalAccountSettingsDataProto {
            onboarded_identity_portal?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded.Status|null);
            game_to_settings?: ({ [k: string]: POGOProtos.Rpc.InternalAccountSettingsDataProto.IGameSettings }|null);
            contact_list_consent?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.IConsent|null);
            acknowledge_reset?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.IAcknowledgeReset|null);
        }

        class InternalAccountSettingsDataProto implements IInternalAccountSettingsDataProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAccountSettingsDataProto);
            public onboarded_identity_portal: POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded.Status;
            public game_to_settings: { [k: string]: POGOProtos.Rpc.InternalAccountSettingsDataProto.IGameSettings };
            public contact_list_consent?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.IConsent|null);
            public acknowledge_reset?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.IAcknowledgeReset|null);
            public static encode(message: POGOProtos.Rpc.IInternalAccountSettingsDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsDataProto;
            public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAccountSettingsDataProto {

            interface IAcknowledgeReset {
                needs_to_acknowledge_username_reset?: (boolean|null);
                needs_to_acknowledge_display_name_reset?: (boolean|null);
                needs_to_acknowledge_photo_reset?: (boolean|null);
            }

            class AcknowledgeReset implements IAcknowledgeReset {
                constructor(properties?: POGOProtos.Rpc.InternalAccountSettingsDataProto.IAcknowledgeReset);
                public needs_to_acknowledge_username_reset: boolean;
                public needs_to_acknowledge_display_name_reset: boolean;
                public needs_to_acknowledge_photo_reset: boolean;
                public static encode(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.IAcknowledgeReset, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsDataProto.AcknowledgeReset;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsDataProto.AcknowledgeReset;
                public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.AcknowledgeReset, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IConsent {
                status?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.Consent.Status|null);
            }

            class Consent implements IConsent {
                constructor(properties?: POGOProtos.Rpc.InternalAccountSettingsDataProto.IConsent);
                public status: POGOProtos.Rpc.InternalAccountSettingsDataProto.Consent.Status;
                public static encode(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.IConsent, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsDataProto.Consent;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsDataProto.Consent;
                public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.Consent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Consent {

                enum Status {
                    UNKNOWN = 0,
                    OPT_IN = 1,
                    OPT_OUT = 2
                }
            }

            interface IGameSettings {
                visibility?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility.Status|null);
            }

            class GameSettings implements IGameSettings {
                constructor(properties?: POGOProtos.Rpc.InternalAccountSettingsDataProto.IGameSettings);
                public visibility: POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility.Status;
                public static encode(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.IGameSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsDataProto.GameSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsDataProto.GameSettings;
                public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.GameSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOnboarded {
                status?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded.Status|null);
            }

            class Onboarded implements IOnboarded {
                constructor(properties?: POGOProtos.Rpc.InternalAccountSettingsDataProto.IOnboarded);
                public status: POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded.Status;
                public static encode(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.IOnboarded, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded;
                public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.Onboarded, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Onboarded {

                enum Status {
                    UNSET = 0,
                    SKIPPED = 1,
                    SEEN = 2
                }
            }

            interface IVisibility {
                status?: (POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility.Status|null);
            }

            class Visibility implements IVisibility {
                constructor(properties?: POGOProtos.Rpc.InternalAccountSettingsDataProto.IVisibility);
                public status: POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility.Status;
                public static encode(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.IVisibility, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility;
                public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsDataProto.Visibility, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Visibility {

                enum Status {
                    UNSET = 0,
                    EVERYONE = 1,
                    FRIENDS = 2,
                    PRIVATE = 3
                }
            }
        }

        interface IInternalAccountSettingsProto {
            opt_out_social_graph_import?: (boolean|null);
            online_status_consent?: (POGOProtos.Rpc.InternalSocialSettings.ConsentStatus|null);
            last_played_date_consent?: (POGOProtos.Rpc.InternalSocialSettings.ConsentStatus|null);
            codename_consent?: (POGOProtos.Rpc.InternalSocialSettings.ConsentStatus|null);
            contact_list_consent?: (POGOProtos.Rpc.InternalSocialSettings.ConsentStatus|null);
            full_name?: (string|null);
        }

        class InternalAccountSettingsProto implements IInternalAccountSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAccountSettingsProto);
            public opt_out_social_graph_import: boolean;
            public online_status_consent: POGOProtos.Rpc.InternalSocialSettings.ConsentStatus;
            public last_played_date_consent: POGOProtos.Rpc.InternalSocialSettings.ConsentStatus;
            public codename_consent: POGOProtos.Rpc.InternalSocialSettings.ConsentStatus;
            public contact_list_consent: POGOProtos.Rpc.InternalSocialSettings.ConsentStatus;
            public full_name: string;
            public static encode(message: POGOProtos.Rpc.IInternalAccountSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAccountSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAccountSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalAccountSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAcknowledgeInformationRequest {
            acknowledge_username_reset?: (boolean|null);
            acknowledge_display_name_reset?: (boolean|null);
            acknowledge_photo_reset?: (boolean|null);
        }

        class InternalAcknowledgeInformationRequest implements IInternalAcknowledgeInformationRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalAcknowledgeInformationRequest);
            public acknowledge_username_reset: boolean;
            public acknowledge_display_name_reset: boolean;
            public acknowledge_photo_reset: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalAcknowledgeInformationRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAcknowledgeInformationRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAcknowledgeInformationRequest;
            public static toObject(message: POGOProtos.Rpc.InternalAcknowledgeInformationRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAcknowledgeInformationResponse {
            status?: (POGOProtos.Rpc.InternalAcknowledgeInformationResponse.Status|null);
        }

        class InternalAcknowledgeInformationResponse implements IInternalAcknowledgeInformationResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalAcknowledgeInformationResponse);
            public status: POGOProtos.Rpc.InternalAcknowledgeInformationResponse.Status;
            public static encode(message: POGOProtos.Rpc.IInternalAcknowledgeInformationResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAcknowledgeInformationResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAcknowledgeInformationResponse;
            public static toObject(message: POGOProtos.Rpc.InternalAcknowledgeInformationResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAcknowledgeInformationResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalAcknowledgeWarningsRequestProto {
            warning?: (POGOProtos.Rpc.InternalPlatformWarningType[]|null);
        }

        class InternalAcknowledgeWarningsRequestProto implements IInternalAcknowledgeWarningsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAcknowledgeWarningsRequestProto);
            public warning: POGOProtos.Rpc.InternalPlatformWarningType[];
            public static encode(message: POGOProtos.Rpc.IInternalAcknowledgeWarningsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAcknowledgeWarningsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAcknowledgeWarningsRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalAcknowledgeWarningsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAcknowledgeWarningsResponseProto {
            success?: (boolean|null);
        }

        class InternalAcknowledgeWarningsResponseProto implements IInternalAcknowledgeWarningsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAcknowledgeWarningsResponseProto);
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalAcknowledgeWarningsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAcknowledgeWarningsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAcknowledgeWarningsResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalAcknowledgeWarningsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalActionExecution {
        }

        class InternalActionExecution implements IInternalActionExecution {
            constructor(properties?: POGOProtos.Rpc.IInternalActionExecution);
            public static encode(message: POGOProtos.Rpc.IInternalActionExecution, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalActionExecution;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalActionExecution;
            public static toObject(message: POGOProtos.Rpc.InternalActionExecution, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalActionExecution {

            enum ExecutionMethod {
                DEFAULT = 0,
                SYNCHRONOUS = 1,
                ASYNCHRONOUS = 2
            }
        }

        interface IInternalActivityReportProto {
            num_friends?: (number|null);
            num_friends_removed?: (number|null);
            num_friends_made_in_this_period?: (number|null);
            num_friends_removed_in_this_period?: (number|null);
            longest_friend?: (POGOProtos.Rpc.InternalActivityReportProto.IFriendProto|null);
            recent_friends?: (POGOProtos.Rpc.InternalActivityReportProto.IFriendProto[]|null);
            most_walk_km_friends?: (POGOProtos.Rpc.InternalActivityReportProto.IFriendProto[]|null);
            walk_km?: (number|null);
            walk_km_percentile_against_friends?: (number|null);
        }

        class InternalActivityReportProto implements IInternalActivityReportProto {
            constructor(properties?: POGOProtos.Rpc.IInternalActivityReportProto);
            public num_friends: number;
            public num_friends_removed: number;
            public num_friends_made_in_this_period: number;
            public num_friends_removed_in_this_period: number;
            public longest_friend?: (POGOProtos.Rpc.InternalActivityReportProto.IFriendProto|null);
            public recent_friends: POGOProtos.Rpc.InternalActivityReportProto.IFriendProto[];
            public most_walk_km_friends: POGOProtos.Rpc.InternalActivityReportProto.IFriendProto[];
            public walk_km: number;
            public walk_km_percentile_against_friends: number;
            public static encode(message: POGOProtos.Rpc.IInternalActivityReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalActivityReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalActivityReportProto;
            public static toObject(message: POGOProtos.Rpc.InternalActivityReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalActivityReportProto {

            interface IFriendProto {
                nia_account_id?: (string|null);
                walk_km?: (number|null);
                friendship_creation_timestamp_ms?: (number|Long|null);
                friendship_creation_days?: (number|Long|null);
            }

            class FriendProto implements IFriendProto {
                constructor(properties?: POGOProtos.Rpc.InternalActivityReportProto.IFriendProto);
                public nia_account_id: string;
                public walk_km: number;
                public friendship_creation_timestamp_ms: (number|Long);
                public friendship_creation_days: (number|Long);
                public static encode(message: POGOProtos.Rpc.InternalActivityReportProto.IFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalActivityReportProto.FriendProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalActivityReportProto.FriendProto;
                public static toObject(message: POGOProtos.Rpc.InternalActivityReportProto.FriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalAddFavoriteFriendRequest {
            friend_id?: (string|null);
            friend_nia_account_id?: (string|null);
        }

        class InternalAddFavoriteFriendRequest implements IInternalAddFavoriteFriendRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalAddFavoriteFriendRequest);
            public friend_id: string;
            public friend_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalAddFavoriteFriendRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAddFavoriteFriendRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAddFavoriteFriendRequest;
            public static toObject(message: POGOProtos.Rpc.InternalAddFavoriteFriendRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAddFavoriteFriendResponse {
            result?: (POGOProtos.Rpc.InternalAddFavoriteFriendResponse.Result|null);
        }

        class InternalAddFavoriteFriendResponse implements IInternalAddFavoriteFriendResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalAddFavoriteFriendResponse);
            public result: POGOProtos.Rpc.InternalAddFavoriteFriendResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalAddFavoriteFriendResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAddFavoriteFriendResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAddFavoriteFriendResponse;
            public static toObject(message: POGOProtos.Rpc.InternalAddFavoriteFriendResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAddFavoriteFriendResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IInternalAddLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.IInternalLoginDetail[]|null);
            status?: (POGOProtos.Rpc.InternalAddLoginActionOutProto.Status|null);
        }

        class InternalAddLoginActionOutProto implements IInternalAddLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAddLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.IInternalLoginDetail[];
            public status: POGOProtos.Rpc.InternalAddLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalAddLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAddLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAddLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalAddLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAddLoginActionOutProto {

            enum Status {
                UNSET = 0,
                AUTH_FAILURE = 1,
                LOGIN_TAKEN = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IInternalAddLoginActionProto {
            identity_provider?: (POGOProtos.Rpc.InternalIdentityProvider|null);
            inner_message?: (Uint8Array|null);
            auth_provider_id?: (string|null);
        }

        class InternalAddLoginActionProto implements IInternalAddLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAddLoginActionProto);
            public identity_provider: POGOProtos.Rpc.InternalIdentityProvider;
            public inner_message: Uint8Array;
            public auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalAddLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAddLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAddLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.InternalAddLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAdventureSyncProgress {
            notification_selector?: (number|null);
            parameters?: (string[]|null);
            serialized_data?: (Uint8Array|null);
        }

        class InternalAdventureSyncProgress implements IInternalAdventureSyncProgress {
            constructor(properties?: POGOProtos.Rpc.IInternalAdventureSyncProgress);
            public notification_selector: number;
            public parameters: string[];
            public serialized_data: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalAdventureSyncProgress, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAdventureSyncProgress;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAdventureSyncProgress;
            public static toObject(message: POGOProtos.Rpc.InternalAdventureSyncProgress, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAdventureSyncSettingsProto {
            fitness_service_enabled?: (boolean|null);
            awareness_service_enabled?: (boolean|null);
            persistent_breadcrumb_service_enabled?: (boolean|null);
            sensor_service_enabled?: (boolean|null);
            persistent_location_service_enabled?: (boolean|null);
            breadcrumb_service_enabled?: (boolean|null);
        }

        class InternalAdventureSyncSettingsProto implements IInternalAdventureSyncSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAdventureSyncSettingsProto);
            public fitness_service_enabled: boolean;
            public awareness_service_enabled: boolean;
            public persistent_breadcrumb_service_enabled: boolean;
            public sensor_service_enabled: boolean;
            public persistent_location_service_enabled: boolean;
            public breadcrumb_service_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalAdventureSyncSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAdventureSyncSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAdventureSyncSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalAdventureSyncSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAndroidDataSource {
            is_raw?: (boolean|null);
            app_package_name?: (string|null);
            stream_identifier?: (string|null);
            stream_name?: (string|null);
            device?: (POGOProtos.Rpc.IInternalAndroidDevice|null);
            data_type?: (string|null);
        }

        class InternalAndroidDataSource implements IInternalAndroidDataSource {
            constructor(properties?: POGOProtos.Rpc.IInternalAndroidDataSource);
            public is_raw: boolean;
            public app_package_name: string;
            public stream_identifier: string;
            public stream_name: string;
            public device?: (POGOProtos.Rpc.IInternalAndroidDevice|null);
            public data_type: string;
            public static encode(message: POGOProtos.Rpc.IInternalAndroidDataSource, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAndroidDataSource;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAndroidDataSource;
            public static toObject(message: POGOProtos.Rpc.InternalAndroidDataSource, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAndroidDevice {
            manufacturer?: (string|null);
            model?: (string|null);
            type?: (POGOProtos.Rpc.InternalAndroidDevice.DeviceType|null);
            uid?: (string|null);
        }

        class InternalAndroidDevice implements IInternalAndroidDevice {
            constructor(properties?: POGOProtos.Rpc.IInternalAndroidDevice);
            public manufacturer: string;
            public model: string;
            public type: POGOProtos.Rpc.InternalAndroidDevice.DeviceType;
            public uid: string;
            public static encode(message: POGOProtos.Rpc.IInternalAndroidDevice, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAndroidDevice;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAndroidDevice;
            public static toObject(message: POGOProtos.Rpc.InternalAndroidDevice, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAndroidDevice {

            enum DeviceType {
                UNKNOWN = 0,
                PHONE = 1,
                TABLET = 2,
                WATCH = 3,
                CHEST_STRAP = 4,
                SCALE = 5,
                HEAD_MOUNTED = 6
            }
        }

        interface IInternalApnToken {
            registration_id?: (string|null);
            bundle_identifier?: (string|null);
            payload_byte_size?: (number|null);
        }

        class InternalApnToken implements IInternalApnToken {
            constructor(properties?: POGOProtos.Rpc.IInternalApnToken);
            public registration_id: string;
            public bundle_identifier: string;
            public payload_byte_size: number;
            public static encode(message: POGOProtos.Rpc.IInternalApnToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalApnToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalApnToken;
            public static toObject(message: POGOProtos.Rpc.InternalApnToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAsynchronousJobData {
            job_id?: (string|null);
            callback?: (string|null);
            metadata?: ({ [k: string]: string }|null);
        }

        class InternalAsynchronousJobData implements IInternalAsynchronousJobData {
            constructor(properties?: POGOProtos.Rpc.IInternalAsynchronousJobData);
            public job_id: string;
            public callback: string;
            public metadata: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IInternalAsynchronousJobData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAsynchronousJobData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAsynchronousJobData;
            public static toObject(message: POGOProtos.Rpc.InternalAsynchronousJobData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAuthProto {
            email?: (string|null);
            player_id?: (string|null);
            app_id?: (string|null);
            key?: (string|null);
        }

        class InternalAuthProto implements IInternalAuthProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAuthProto);
            public email: string;
            public player_id: string;
            public app_id: string;
            public key: string;
            public static encode(message: POGOProtos.Rpc.IInternalAuthProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAuthProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAuthProto;
            public static toObject(message: POGOProtos.Rpc.InternalAuthProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAuthenticateAppleSignInRequestProto {
            apple_id_token?: (Uint8Array|null);
            auth_code?: (Uint8Array|null);
        }

        class InternalAuthenticateAppleSignInRequestProto implements IInternalAuthenticateAppleSignInRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAuthenticateAppleSignInRequestProto);
            public apple_id_token: Uint8Array;
            public auth_code: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalAuthenticateAppleSignInRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAuthenticateAppleSignInRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAuthenticateAppleSignInRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalAuthenticateAppleSignInRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalAuthenticateAppleSignInResponseProto {
            status?: (POGOProtos.Rpc.InternalAuthenticateAppleSignInResponseProto.Status|null);
            nia_apple_auth_token?: (Uint8Array|null);
        }

        class InternalAuthenticateAppleSignInResponseProto implements IInternalAuthenticateAppleSignInResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalAuthenticateAppleSignInResponseProto);
            public status: POGOProtos.Rpc.InternalAuthenticateAppleSignInResponseProto.Status;
            public nia_apple_auth_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalAuthenticateAppleSignInResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAuthenticateAppleSignInResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAuthenticateAppleSignInResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalAuthenticateAppleSignInResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAuthenticateAppleSignInResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_AUTH = 2,
                SERVER_ERROR = 3
            }
        }

        interface IInternalAvatarImageMetadata {
        }

        class InternalAvatarImageMetadata implements IInternalAvatarImageMetadata {
            constructor(properties?: POGOProtos.Rpc.IInternalAvatarImageMetadata);
            public static encode(message: POGOProtos.Rpc.IInternalAvatarImageMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalAvatarImageMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalAvatarImageMetadata;
            public static toObject(message: POGOProtos.Rpc.InternalAvatarImageMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalAvatarImageMetadata {

            enum GetPhotoMode {
                ORIGINAL = 0,
                MIN_SIZE_64 = 1,
                MIN_SIZE_256 = 2,
                MIN_SIZE_1080 = 3
            }

            enum ImageSpec {
                UNSET = 0,
                AVATAR_HEADSHOT = 1,
                AVATAR_FULL_BODY = 2
            }
        }

        interface IInternalBackgroundModeClientSettingsProto {
            maximum_sample_age_ms?: (number|Long|null);
            accept_manual_fitness_samples?: (boolean|null);
            minimum_location_accuracy_meters?: (number|null);
            background_wake_up_interval_minutes?: (number|null);
            max_upload_size_in_bytes?: (number|null);
            min_enclosing_geofence_radius_m?: (number|null);
            background_token_refresh_interval_s?: (number|Long|null);
            max_session_duration_m?: (number|null);
            min_distance_delta_m?: (number|null);
            min_update_interval_s?: (number|null);
            min_session_reporting_interval_s?: (number|null);
            min_persistent_reporting_interval_s?: (number|null);
            enable_progress_request?: (boolean|null);
            enable_foreground_notification?: (boolean|null);
            proximity_settings?: (POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.IProximitySettingsProto|null);
        }

        class InternalBackgroundModeClientSettingsProto implements IInternalBackgroundModeClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalBackgroundModeClientSettingsProto);
            public maximum_sample_age_ms: (number|Long);
            public accept_manual_fitness_samples: boolean;
            public minimum_location_accuracy_meters: number;
            public background_wake_up_interval_minutes: number;
            public max_upload_size_in_bytes: number;
            public min_enclosing_geofence_radius_m: number;
            public background_token_refresh_interval_s: (number|Long);
            public max_session_duration_m: number;
            public min_distance_delta_m: number;
            public min_update_interval_s: number;
            public min_session_reporting_interval_s: number;
            public min_persistent_reporting_interval_s: number;
            public enable_progress_request: boolean;
            public enable_foreground_notification: boolean;
            public proximity_settings?: (POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.IProximitySettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalBackgroundModeClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalBackgroundModeClientSettingsProto {

            interface IProximitySettingsProto {
                maximum_contact_age_ms?: (number|Long|null);
            }

            class ProximitySettingsProto implements IProximitySettingsProto {
                constructor(properties?: POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.IProximitySettingsProto);
                public maximum_contact_age_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.IProximitySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.ProximitySettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.ProximitySettingsProto;
                public static toObject(message: POGOProtos.Rpc.InternalBackgroundModeClientSettingsProto.ProximitySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalBatchResetProto {
            nia_account_id?: (string|null);
            status?: (POGOProtos.Rpc.InternalBatchResetProto.Status|null);
        }

        class InternalBatchResetProto implements IInternalBatchResetProto {
            constructor(properties?: POGOProtos.Rpc.IInternalBatchResetProto);
            public nia_account_id: string;
            public status: POGOProtos.Rpc.InternalBatchResetProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalBatchResetProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalBatchResetProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalBatchResetProto;
            public static toObject(message: POGOProtos.Rpc.InternalBatchResetProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalBatchResetProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ACCOUNT_NOT_FOUND = 2,
                USERNAME_ALREADY_EMPTY = 3,
                USERNAME_INVALID = 4,
                USERNAME_NOT_ALLOWED = 5,
                USERNAME_ABUSIVE = 6,
                USERNAME_OCCUPIED = 7,
                USERNAME_SERVER_FAILURE = 8,
                SERVER_FAILURE = 9
            }
        }

        interface IInternalBlockAccountOutProto {
            result?: (POGOProtos.Rpc.InternalBlockAccountOutProto.Result|null);
        }

        class InternalBlockAccountOutProto implements IInternalBlockAccountOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalBlockAccountOutProto);
            public result: POGOProtos.Rpc.InternalBlockAccountOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalBlockAccountOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalBlockAccountOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalBlockAccountOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalBlockAccountOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalBlockAccountOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_DOES_NOT_EXIST = 2,
                ERROR_ALREADY_BLOCKED = 3,
                ERROR_UPDATE_FRIENDSHIP_FAILED = 4
            }
        }

        interface IInternalBlockAccountProto {
            blockee_nia_account_id?: (string|null);
        }

        class InternalBlockAccountProto implements IInternalBlockAccountProto {
            constructor(properties?: POGOProtos.Rpc.IInternalBlockAccountProto);
            public blockee_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalBlockAccountProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalBlockAccountProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalBlockAccountProto;
            public static toObject(message: POGOProtos.Rpc.InternalBlockAccountProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalBreadcrumbRecordProto {
            timestamp_ms?: (number|Long|null);
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
            app_is_foregrounded?: (boolean|null);
            altitude_m?: (number|null);
            accuracy_m?: (number|null);
        }

        class InternalBreadcrumbRecordProto implements IInternalBreadcrumbRecordProto {
            constructor(properties?: POGOProtos.Rpc.IInternalBreadcrumbRecordProto);
            public timestamp_ms: (number|Long);
            public latitude_deg: number;
            public longitude_deg: number;
            public app_is_foregrounded: boolean;
            public altitude_m: number;
            public accuracy_m: number;
            public static encode(message: POGOProtos.Rpc.IInternalBreadcrumbRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalBreadcrumbRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalBreadcrumbRecordProto;
            public static toObject(message: POGOProtos.Rpc.InternalBreadcrumbRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCancelFriendInviteOutProto {
            result?: (POGOProtos.Rpc.InternalCancelFriendInviteOutProto.Result|null);
        }

        class InternalCancelFriendInviteOutProto implements IInternalCancelFriendInviteOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalCancelFriendInviteOutProto);
            public result: POGOProtos.Rpc.InternalCancelFriendInviteOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalCancelFriendInviteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCancelFriendInviteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCancelFriendInviteOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalCancelFriendInviteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalCancelFriendInviteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVITE_DOES_NOT_EXIST = 3,
                ERROR_ALREADY_CANCELLED = 4
            }
        }

        interface IInternalCancelFriendInviteProto {
            player_id?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalCancelFriendInviteProto implements IInternalCancelFriendInviteProto {
            constructor(properties?: POGOProtos.Rpc.IInternalCancelFriendInviteProto);
            public player_id: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalCancelFriendInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCancelFriendInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCancelFriendInviteProto;
            public static toObject(message: POGOProtos.Rpc.InternalCancelFriendInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalChatMessageContext {
            text?: (string|null);
            image_id?: (string|null);
            message_id?: (number|Long|null);
            sender_id?: (string|null);
            posted_timestamp_ms?: (number|Long|null);
        }

        class InternalChatMessageContext implements IInternalChatMessageContext {
            constructor(properties?: POGOProtos.Rpc.IInternalChatMessageContext);
            public text?: (string|null);
            public image_id?: (string|null);
            public message_id: (number|Long);
            public sender_id: string;
            public posted_timestamp_ms: (number|Long);
            public FlagContent?: ("text"|"image_id");
            public static encode(message: POGOProtos.Rpc.IInternalChatMessageContext, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalChatMessageContext;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalChatMessageContext;
            public static toObject(message: POGOProtos.Rpc.InternalChatMessageContext, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCheckAvatarImagesRequest {
            avatar_hash?: (string|null);
            image_specs?: (POGOProtos.Rpc.InternalAvatarImageMetadata.ImageSpec[]|null);
        }

        class InternalCheckAvatarImagesRequest implements IInternalCheckAvatarImagesRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalCheckAvatarImagesRequest);
            public avatar_hash: string;
            public image_specs: POGOProtos.Rpc.InternalAvatarImageMetadata.ImageSpec[];
            public static encode(message: POGOProtos.Rpc.IInternalCheckAvatarImagesRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCheckAvatarImagesRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCheckAvatarImagesRequest;
            public static toObject(message: POGOProtos.Rpc.InternalCheckAvatarImagesRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCheckAvatarImagesResponse {
            status?: (POGOProtos.Rpc.InternalCheckAvatarImagesResponse.Status|null);
            results?: (POGOProtos.Rpc.InternalCheckAvatarImagesResponse.IAvatarImageInfo[]|null);
        }

        class InternalCheckAvatarImagesResponse implements IInternalCheckAvatarImagesResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalCheckAvatarImagesResponse);
            public status: POGOProtos.Rpc.InternalCheckAvatarImagesResponse.Status;
            public results: POGOProtos.Rpc.InternalCheckAvatarImagesResponse.IAvatarImageInfo[];
            public static encode(message: POGOProtos.Rpc.IInternalCheckAvatarImagesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCheckAvatarImagesResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCheckAvatarImagesResponse;
            public static toObject(message: POGOProtos.Rpc.InternalCheckAvatarImagesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalCheckAvatarImagesResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                UNKNOWN_ERROR = 2
            }

            interface IAvatarImageInfo {
                status?: (POGOProtos.Rpc.InternalCheckAvatarImagesResponse.AvatarImageInfo.Status|null);
                image_spec?: (POGOProtos.Rpc.InternalAvatarImageMetadata.ImageSpec|null);
            }

            class AvatarImageInfo implements IAvatarImageInfo {
                constructor(properties?: POGOProtos.Rpc.InternalCheckAvatarImagesResponse.IAvatarImageInfo);
                public status: POGOProtos.Rpc.InternalCheckAvatarImagesResponse.AvatarImageInfo.Status;
                public image_spec: POGOProtos.Rpc.InternalAvatarImageMetadata.ImageSpec;
                public static encode(message: POGOProtos.Rpc.InternalCheckAvatarImagesResponse.IAvatarImageInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCheckAvatarImagesResponse.AvatarImageInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCheckAvatarImagesResponse.AvatarImageInfo;
                public static toObject(message: POGOProtos.Rpc.InternalCheckAvatarImagesResponse.AvatarImageInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AvatarImageInfo {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    MISMATCH = 2,
                    NOT_FOUND = 3
                }
            }
        }

        interface IInternalClientGameMasterTemplateProto {
            template_id?: (string|null);
            data?: (POGOProtos.Rpc.IGameMasterClientTemplateProto|null);
        }

        class InternalClientGameMasterTemplateProto implements IInternalClientGameMasterTemplateProto {
            constructor(properties?: POGOProtos.Rpc.IInternalClientGameMasterTemplateProto);
            public template_id: string;
            public data?: (POGOProtos.Rpc.IGameMasterClientTemplateProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalClientGameMasterTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalClientGameMasterTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalClientGameMasterTemplateProto;
            public static toObject(message: POGOProtos.Rpc.InternalClientGameMasterTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalClientInbox {
            notifications?: (POGOProtos.Rpc.InternalClientInbox.INotification[]|null);
        }

        class InternalClientInbox implements IInternalClientInbox {
            constructor(properties?: POGOProtos.Rpc.IInternalClientInbox);
            public notifications: POGOProtos.Rpc.InternalClientInbox.INotification[];
            public static encode(message: POGOProtos.Rpc.IInternalClientInbox, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalClientInbox;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalClientInbox;
            public static toObject(message: POGOProtos.Rpc.InternalClientInbox, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalClientInbox {

            enum Label {
                UNSET_LABEL = 0,
                UNREAD = 1,
                NEW = 2,
                IMMEDIATE = 3
            }

            interface INotification {
                notification_id?: (string|null);
                title_key?: (string|null);
                category?: (string|null);
                create_timestamp_ms?: (number|Long|null);
                variables?: (POGOProtos.Rpc.IInternalTemplateVariable[]|null);
                labels?: (POGOProtos.Rpc.InternalClientInbox.Label[]|null);
                expire_time_ms?: (number|Long|null);
            }

            class Notification implements INotification {
                constructor(properties?: POGOProtos.Rpc.InternalClientInbox.INotification);
                public notification_id: string;
                public title_key: string;
                public category: string;
                public create_timestamp_ms: (number|Long);
                public variables: POGOProtos.Rpc.IInternalTemplateVariable[];
                public labels: POGOProtos.Rpc.InternalClientInbox.Label[];
                public expire_time_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.InternalClientInbox.INotification, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalClientInbox.Notification;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalClientInbox.Notification;
                public static toObject(message: POGOProtos.Rpc.InternalClientInbox.Notification, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalClientUpgradeRequestProto {
            version?: (string|null);
            operating_system?: (POGOProtos.Rpc.InternalClientOperatingSystem|null);
        }

        class InternalClientUpgradeRequestProto implements IInternalClientUpgradeRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalClientUpgradeRequestProto);
            public version: string;
            public operating_system: POGOProtos.Rpc.InternalClientOperatingSystem;
            public static encode(message: POGOProtos.Rpc.IInternalClientUpgradeRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalClientUpgradeRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalClientUpgradeRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalClientUpgradeRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalClientUpgradeResponseProto {
            needs_upgrade?: (boolean|null);
        }

        class InternalClientUpgradeResponseProto implements IInternalClientUpgradeResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalClientUpgradeResponseProto);
            public needs_upgrade: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalClientUpgradeResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalClientUpgradeResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalClientUpgradeResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalClientUpgradeResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalClientWeatherProto {
            s2_cell_id?: (number|Long|null);
            display_weather?: (POGOProtos.Rpc.IInternalDisplayWeatherProto|null);
            gameplay_weather?: (POGOProtos.Rpc.IInternalGameplayWeatherProto|null);
            alerts?: (POGOProtos.Rpc.IInternalWeatherAlertProto[]|null);
        }

        class InternalClientWeatherProto implements IInternalClientWeatherProto {
            constructor(properties?: POGOProtos.Rpc.IInternalClientWeatherProto);
            public s2_cell_id: (number|Long);
            public display_weather?: (POGOProtos.Rpc.IInternalDisplayWeatherProto|null);
            public gameplay_weather?: (POGOProtos.Rpc.IInternalGameplayWeatherProto|null);
            public alerts: POGOProtos.Rpc.IInternalWeatherAlertProto[];
            public static encode(message: POGOProtos.Rpc.IInternalClientWeatherProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalClientWeatherProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalClientWeatherProto;
            public static toObject(message: POGOProtos.Rpc.InternalClientWeatherProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCreateGuestLoginSecretTokenRequestProto {
            api_key?: (string|null);
            device_id?: (string|null);
        }

        class InternalCreateGuestLoginSecretTokenRequestProto implements IInternalCreateGuestLoginSecretTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalCreateGuestLoginSecretTokenRequestProto);
            public api_key: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalCreateGuestLoginSecretTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCreateGuestLoginSecretTokenResponseProto {
            status?: (POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenResponseProto.Status|null);
            secret?: (Uint8Array|null);
        }

        class InternalCreateGuestLoginSecretTokenResponseProto implements IInternalCreateGuestLoginSecretTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalCreateGuestLoginSecretTokenResponseProto);
            public status: POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenResponseProto.Status;
            public secret: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalCreateGuestLoginSecretTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalCreateGuestLoginSecretTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalCreateGuestLoginSecretTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                UNKNOWN_ERROR = 2,
                UNAUTHORIZED = 3,
                DISABLED = 4,
                EXCEEDED_RATE_LIMIT = 5
            }
        }

        interface IInternalCreateSharedLoginTokenRequest {
            device_id?: (string|null);
        }

        class InternalCreateSharedLoginTokenRequest implements IInternalCreateSharedLoginTokenRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalCreateSharedLoginTokenRequest);
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalCreateSharedLoginTokenRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCreateSharedLoginTokenRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCreateSharedLoginTokenRequest;
            public static toObject(message: POGOProtos.Rpc.InternalCreateSharedLoginTokenRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCreateSharedLoginTokenResponse {
            status?: (POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.Status|null);
            shared_login_token?: (Uint8Array|null);
            token_meta_data?: (POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.ITokenMetaData|null);
        }

        class InternalCreateSharedLoginTokenResponse implements IInternalCreateSharedLoginTokenResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalCreateSharedLoginTokenResponse);
            public status: POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.Status;
            public shared_login_token: Uint8Array;
            public token_meta_data?: (POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.ITokenMetaData|null);
            public static encode(message: POGOProtos.Rpc.IInternalCreateSharedLoginTokenResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse;
            public static toObject(message: POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalCreateSharedLoginTokenResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }

            interface ITokenMetaData {
                email?: (string|null);
                expiration_timestamp_ms?: (number|Long|null);
            }

            class TokenMetaData implements ITokenMetaData {
                constructor(properties?: POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.ITokenMetaData);
                public email: string;
                public expiration_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.ITokenMetaData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.TokenMetaData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.TokenMetaData;
                public static toObject(message: POGOProtos.Rpc.InternalCreateSharedLoginTokenResponse.TokenMetaData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalCrmProxyRequestProto {
            action?: (number|null);
            payload?: (Uint8Array|null);
        }

        class InternalCrmProxyRequestProto implements IInternalCrmProxyRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalCrmProxyRequestProto);
            public action: number;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalCrmProxyRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCrmProxyRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCrmProxyRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalCrmProxyRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalCrmProxyResponseProto {
            status?: (POGOProtos.Rpc.InternalCrmProxyResponseProto.Status|null);
            error_message?: (string|null);
            payload?: (Uint8Array|null);
        }

        class InternalCrmProxyResponseProto implements IInternalCrmProxyResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalCrmProxyResponseProto);
            public status: POGOProtos.Rpc.InternalCrmProxyResponseProto.Status;
            public error_message: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalCrmProxyResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalCrmProxyResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalCrmProxyResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalCrmProxyResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalCrmProxyResponseProto {

            enum Status {
                UNSET = 0,
                OK = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PERMISSION_DENIED = 3,
                ERROR_UNAVAILABLE = 4,
                ERROR_UNAUTHENTICATED = 5
            }
        }

        interface IInternalDataAccessRequest {
            email?: (string|null);
            language_short_code?: (string|null);
        }

        class InternalDataAccessRequest implements IInternalDataAccessRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalDataAccessRequest);
            public email: string;
            public language_short_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalDataAccessRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDataAccessRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDataAccessRequest;
            public static toObject(message: POGOProtos.Rpc.InternalDataAccessRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDataAccessResponse {
            status?: (POGOProtos.Rpc.InternalDataAccessResponse.Status|null);
            error_message?: (string|null);
        }

        class InternalDataAccessResponse implements IInternalDataAccessResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalDataAccessResponse);
            public status: POGOProtos.Rpc.InternalDataAccessResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IInternalDataAccessResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDataAccessResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDataAccessResponse;
            public static toObject(message: POGOProtos.Rpc.InternalDataAccessResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDataAccessResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALIDEMAIL = 2,
                ERROR_INVALIDLANGUAGE = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface IInternalDebugInfoProto {
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class InternalDebugInfoProto implements IInternalDebugInfoProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDebugInfoProto);
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IInternalDebugInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDebugInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDebugInfoProto;
            public static toObject(message: POGOProtos.Rpc.InternalDebugInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDeclineFriendInviteOutProto {
            result?: (POGOProtos.Rpc.InternalDeclineFriendInviteOutProto.Result|null);
        }

        class InternalDeclineFriendInviteOutProto implements IInternalDeclineFriendInviteOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDeclineFriendInviteOutProto);
            public result: POGOProtos.Rpc.InternalDeclineFriendInviteOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalDeclineFriendInviteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeclineFriendInviteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeclineFriendInviteOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalDeclineFriendInviteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDeclineFriendInviteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVITE_DOES_NOT_EXIST = 3,
                ERROR_INVITE_ALREADY_DECLINED = 4
            }
        }

        interface IInternalDeclineFriendInviteProto {
            player_id?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalDeclineFriendInviteProto implements IInternalDeclineFriendInviteProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDeclineFriendInviteProto);
            public player_id: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalDeclineFriendInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeclineFriendInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeclineFriendInviteProto;
            public static toObject(message: POGOProtos.Rpc.InternalDeclineFriendInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDeleteAccountEmailOnFileRequest {
            language_short_code?: (string|null);
        }

        class InternalDeleteAccountEmailOnFileRequest implements IInternalDeleteAccountEmailOnFileRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalDeleteAccountEmailOnFileRequest);
            public language_short_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalDeleteAccountEmailOnFileRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeleteAccountEmailOnFileRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeleteAccountEmailOnFileRequest;
            public static toObject(message: POGOProtos.Rpc.InternalDeleteAccountEmailOnFileRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDeleteAccountEmailOnFileResponse {
            status?: (POGOProtos.Rpc.InternalDeleteAccountEmailOnFileResponse.Status|null);
            error_message?: (string|null);
            confirmation_email?: (string|null);
            has_apple_provider?: (boolean|null);
        }

        class InternalDeleteAccountEmailOnFileResponse implements IInternalDeleteAccountEmailOnFileResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalDeleteAccountEmailOnFileResponse);
            public status: POGOProtos.Rpc.InternalDeleteAccountEmailOnFileResponse.Status;
            public error_message: string;
            public confirmation_email: string;
            public has_apple_provider: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalDeleteAccountEmailOnFileResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeleteAccountEmailOnFileResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeleteAccountEmailOnFileResponse;
            public static toObject(message: POGOProtos.Rpc.InternalDeleteAccountEmailOnFileResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDeleteAccountEmailOnFileResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_EMAIL_NOT_ON_FILE = 2,
                ERROR_INVALID_LANGUAGE = 3,
                ERROR_APP_NOT_SUPPORTED = 4,
                ERROR_INVALID_PLAYER = 5,
                ERROR_DUPLICATE_REQUEST = 6,
                ERROR_HELPSHIFT_ERROR = 7,
                ERROR_UNKNOWN = 8,
                ERROR_CODENAME_NOT_ON_FILE = 9
            }
        }

        interface IInternalDeleteAccountRequest {
            email?: (string|null);
            language_short_code?: (string|null);
            is_dry_run?: (boolean|null);
        }

        class InternalDeleteAccountRequest implements IInternalDeleteAccountRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalDeleteAccountRequest);
            public email: string;
            public language_short_code: string;
            public is_dry_run: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalDeleteAccountRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeleteAccountRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeleteAccountRequest;
            public static toObject(message: POGOProtos.Rpc.InternalDeleteAccountRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDeleteAccountResponse {
            status?: (POGOProtos.Rpc.InternalDeleteAccountResponse.Status|null);
            error_message?: (string|null);
        }

        class InternalDeleteAccountResponse implements IInternalDeleteAccountResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalDeleteAccountResponse);
            public status: POGOProtos.Rpc.InternalDeleteAccountResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IInternalDeleteAccountResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeleteAccountResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeleteAccountResponse;
            public static toObject(message: POGOProtos.Rpc.InternalDeleteAccountResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDeleteAccountResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALIDEMAIL = 2,
                ERROR_INVALIDLANGUAGE = 3,
                ERROR_UNKNOWN = 4,
                ERROR_APP_NOT_SUPPORTED = 5,
                ERROR_INVALID_PLAYER = 6,
                ERROR_DUPLICATE_REQUEST = 7
            }
        }

        interface IInternalDeletePhoneNumberRequest {
            contact_id?: (string|null);
        }

        class InternalDeletePhoneNumberRequest implements IInternalDeletePhoneNumberRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalDeletePhoneNumberRequest);
            public contact_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalDeletePhoneNumberRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeletePhoneNumberRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeletePhoneNumberRequest;
            public static toObject(message: POGOProtos.Rpc.InternalDeletePhoneNumberRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDeletePhoneNumberResponse {
            status?: (POGOProtos.Rpc.InternalDeletePhoneNumberResponse.Status|null);
            error_message?: (string|null);
        }

        class InternalDeletePhoneNumberResponse implements IInternalDeletePhoneNumberResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalDeletePhoneNumberResponse);
            public status: POGOProtos.Rpc.InternalDeletePhoneNumberResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IInternalDeletePhoneNumberResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeletePhoneNumberResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeletePhoneNumberResponse;
            public static toObject(message: POGOProtos.Rpc.InternalDeletePhoneNumberResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDeletePhoneNumberResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalDeletePhotoOutProto {
            result?: (POGOProtos.Rpc.InternalDeletePhotoOutProto.Result|null);
        }

        class InternalDeletePhotoOutProto implements IInternalDeletePhotoOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDeletePhotoOutProto);
            public result: POGOProtos.Rpc.InternalDeletePhotoOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalDeletePhotoOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeletePhotoOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeletePhotoOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalDeletePhotoOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDeletePhotoOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                IMAGE_NOT_FOUND = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IInternalDeletePhotoProto {
            photo_id?: (string|null);
        }

        class InternalDeletePhotoProto implements IInternalDeletePhotoProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDeletePhotoProto);
            public photo_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalDeletePhotoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDeletePhotoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDeletePhotoProto;
            public static toObject(message: POGOProtos.Rpc.InternalDeletePhotoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDiffInventoryProto {
            compacted_item?: (POGOProtos.Rpc.IInternalInventoryItemProto[]|null);
            last_compaction_ms?: (number|Long|null);
        }

        class InternalDiffInventoryProto implements IInternalDiffInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDiffInventoryProto);
            public compacted_item: POGOProtos.Rpc.IInternalInventoryItemProto[];
            public last_compaction_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalDiffInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDiffInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDiffInventoryProto;
            public static toObject(message: POGOProtos.Rpc.InternalDiffInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDismissContactListUpdateRequest {
        }

        class InternalDismissContactListUpdateRequest implements IInternalDismissContactListUpdateRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalDismissContactListUpdateRequest);
            public static encode(message: POGOProtos.Rpc.IInternalDismissContactListUpdateRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDismissContactListUpdateRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDismissContactListUpdateRequest;
            public static toObject(message: POGOProtos.Rpc.InternalDismissContactListUpdateRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDismissContactListUpdateResponse {
            result?: (POGOProtos.Rpc.InternalDismissContactListUpdateResponse.Result|null);
        }

        class InternalDismissContactListUpdateResponse implements IInternalDismissContactListUpdateResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalDismissContactListUpdateResponse);
            public result: POGOProtos.Rpc.InternalDismissContactListUpdateResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalDismissContactListUpdateResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDismissContactListUpdateResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDismissContactListUpdateResponse;
            public static toObject(message: POGOProtos.Rpc.InternalDismissContactListUpdateResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDismissContactListUpdateResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalDismissOutgoingGameInvitesRequest {
            friend_id?: (string|null);
            app_key?: (string[]|null);
            friend_nia_account_id?: (string|null);
        }

        class InternalDismissOutgoingGameInvitesRequest implements IInternalDismissOutgoingGameInvitesRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesRequest);
            public friend_id: string;
            public app_key: string[];
            public friend_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDismissOutgoingGameInvitesRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDismissOutgoingGameInvitesRequest;
            public static toObject(message: POGOProtos.Rpc.InternalDismissOutgoingGameInvitesRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDismissOutgoingGameInvitesResponse {
            result?: (POGOProtos.Rpc.InternalDismissOutgoingGameInvitesResponse.Result|null);
        }

        class InternalDismissOutgoingGameInvitesResponse implements IInternalDismissOutgoingGameInvitesResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesResponse);
            public result: POGOProtos.Rpc.InternalDismissOutgoingGameInvitesResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalDismissOutgoingGameInvitesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDismissOutgoingGameInvitesResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDismissOutgoingGameInvitesResponse;
            public static toObject(message: POGOProtos.Rpc.InternalDismissOutgoingGameInvitesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDismissOutgoingGameInvitesResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IInternalDisplayWeatherProto {
            cloud_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
            rain_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
            wind_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
            snow_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
            fog_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
            wind_direction?: (number|null);
            special_effect_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
        }

        class InternalDisplayWeatherProto implements IInternalDisplayWeatherProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDisplayWeatherProto);
            public cloud_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
            public rain_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
            public wind_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
            public snow_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
            public fog_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
            public wind_direction: number;
            public special_effect_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
            public static encode(message: POGOProtos.Rpc.IInternalDisplayWeatherProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDisplayWeatherProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDisplayWeatherProto;
            public static toObject(message: POGOProtos.Rpc.InternalDisplayWeatherProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDisplayWeatherProto {

            enum DisplayLevel {
                LEVEL_0 = 0,
                LEVEL_1 = 1,
                LEVEL_2 = 2,
                LEVEL_3 = 3
            }
        }

        interface IInternalDownloadGmTemplatesRequestProto {
            basis_batch_id?: (number|Long|null);
            batch_id?: (number|Long|null);
            page_offset?: (number|null);
            apply_experiments?: (boolean|null);
            basis_experiment_id?: (number[]|null);
            experiment_id?: (number[]|null);
        }

        class InternalDownloadGmTemplatesRequestProto implements IInternalDownloadGmTemplatesRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDownloadGmTemplatesRequestProto);
            public basis_batch_id: (number|Long);
            public batch_id: (number|Long);
            public page_offset: number;
            public apply_experiments: boolean;
            public basis_experiment_id: number[];
            public experiment_id: number[];
            public static encode(message: POGOProtos.Rpc.IInternalDownloadGmTemplatesRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDownloadGmTemplatesRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDownloadGmTemplatesRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalDownloadGmTemplatesRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDownloadGmTemplatesResponseProto {
            result?: (POGOProtos.Rpc.InternalDownloadGmTemplatesResponseProto.Result|null);
            template?: (POGOProtos.Rpc.IInternalClientGameMasterTemplateProto[]|null);
            deleted_template?: (string[]|null);
            batch_id?: (number|Long|null);
            page_offset?: (number|null);
            experiment_id?: (number[]|null);
        }

        class InternalDownloadGmTemplatesResponseProto implements IInternalDownloadGmTemplatesResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDownloadGmTemplatesResponseProto);
            public result: POGOProtos.Rpc.InternalDownloadGmTemplatesResponseProto.Result;
            public template: POGOProtos.Rpc.IInternalClientGameMasterTemplateProto[];
            public deleted_template: string[];
            public batch_id: (number|Long);
            public page_offset: number;
            public experiment_id: number[];
            public static encode(message: POGOProtos.Rpc.IInternalDownloadGmTemplatesResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDownloadGmTemplatesResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDownloadGmTemplatesResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalDownloadGmTemplatesResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalDownloadGmTemplatesResponseProto {

            enum Result {
                UNSET = 0,
                COMPLETE = 1,
                MORE_RESULTS = 2,
                BATCH_ID_NOT_LIVE = 3,
                INVALID_BASIS_BATCH_ID = 4,
                WRONG_EXPERIMENTS = 5
            }
        }

        interface IInternalDownloadSettingsActionProto {
            sha1?: (string|null);
        }

        class InternalDownloadSettingsActionProto implements IInternalDownloadSettingsActionProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDownloadSettingsActionProto);
            public sha1: string;
            public static encode(message: POGOProtos.Rpc.IInternalDownloadSettingsActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDownloadSettingsActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDownloadSettingsActionProto;
            public static toObject(message: POGOProtos.Rpc.InternalDownloadSettingsActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalDownloadSettingsResponseProto {
            error?: (string|null);
            sha1?: (string|null);
            values?: (POGOProtos.Rpc.IGlobalSettingsProto|null);
        }

        class InternalDownloadSettingsResponseProto implements IInternalDownloadSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalDownloadSettingsResponseProto);
            public error: string;
            public sha1: string;
            public values?: (POGOProtos.Rpc.IGlobalSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalDownloadSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalDownloadSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalDownloadSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalDownloadSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFitnessMetricsProto {
            distance_walked_meters?: (number|null);
            step_count?: (number|null);
            calories_burned_kcals?: (number|null);
            exercise_duration_mi?: (number|Long|null);
            wheelchair_distance_meters?: (number|null);
            wheelchair_push_count?: (number|null);
        }

        class InternalFitnessMetricsProto implements IInternalFitnessMetricsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessMetricsProto);
            public distance_walked_meters: number;
            public step_count: number;
            public calories_burned_kcals: number;
            public exercise_duration_mi: (number|Long);
            public wheelchair_distance_meters: number;
            public wheelchair_push_count: number;
            public static encode(message: POGOProtos.Rpc.IInternalFitnessMetricsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessMetricsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessMetricsProto;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessMetricsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFitnessMetricsReportHistory {
            weekly_history?: (POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory[]|null);
            daily_history?: (POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory[]|null);
            hourly_history?: (POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory[]|null);
        }

        class InternalFitnessMetricsReportHistory implements IInternalFitnessMetricsReportHistory {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessMetricsReportHistory);
            public weekly_history: POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory[];
            public daily_history: POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory[];
            public hourly_history: POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory[];
            public static encode(message: POGOProtos.Rpc.IInternalFitnessMetricsReportHistory, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessMetricsReportHistory;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessMetricsReportHistory;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessMetricsReportHistory, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFitnessMetricsReportHistory {

            interface IMetricsHistory {
                bucket?: (number|Long|null);
                metrics?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            }

            class MetricsHistory implements IMetricsHistory {
                constructor(properties?: POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory);
                public bucket: (number|Long);
                public metrics?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
                public static encode(message: POGOProtos.Rpc.InternalFitnessMetricsReportHistory.IMetricsHistory, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessMetricsReportHistory.MetricsHistory;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessMetricsReportHistory.MetricsHistory;
                public static toObject(message: POGOProtos.Rpc.InternalFitnessMetricsReportHistory.MetricsHistory, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalFitnessRecordProto {
            hourly_reports?: ({ [k: string]: POGOProtos.Rpc.IFitnessMetricsProto }|null);
            raw_samples?: (POGOProtos.Rpc.IInternalFitnessSample[]|null);
            last_aggregation_timestamp_ms?: (number|Long|null);
            fitness_stats?: (POGOProtos.Rpc.IInternalFitnessStatsProto|null);
            report_history?: (POGOProtos.Rpc.IInternalFitnessMetricsReportHistory|null);
        }

        class InternalFitnessRecordProto implements IInternalFitnessRecordProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessRecordProto);
            public hourly_reports: { [k: string]: POGOProtos.Rpc.IFitnessMetricsProto };
            public raw_samples: POGOProtos.Rpc.IInternalFitnessSample[];
            public last_aggregation_timestamp_ms: (number|Long);
            public fitness_stats?: (POGOProtos.Rpc.IInternalFitnessStatsProto|null);
            public report_history?: (POGOProtos.Rpc.IInternalFitnessMetricsReportHistory|null);
            public static encode(message: POGOProtos.Rpc.IInternalFitnessRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessRecordProto;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFitnessReportProto {
            day_offset_from_now?: (number|null);
            week_offset_from_now?: (number|null);
            hour_offset_from_now?: (number|null);
            metrics?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            game_data?: (Uint8Array|null);
        }

        class InternalFitnessReportProto implements IInternalFitnessReportProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessReportProto);
            public day_offset_from_now?: (number|null);
            public week_offset_from_now?: (number|null);
            public hour_offset_from_now?: (number|null);
            public metrics?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            public game_data: Uint8Array;
            public Window?: ("day_offset_from_now"|"week_offset_from_now"|"hour_offset_from_now");
            public static encode(message: POGOProtos.Rpc.IInternalFitnessReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessReportProto;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFitnessSample {
            sample_type?: (POGOProtos.Rpc.InternalFitnessSample.FitnessSampleType|null);
            sample_start_timestamp_ms?: (number|Long|null);
            sample_end_timestamp_ms?: (number|Long|null);
            value?: (number|null);
            source_type?: (POGOProtos.Rpc.InternalFitnessSample.FitnessSourceType|null);
            metadata?: (POGOProtos.Rpc.IInternalFitnessSampleMetadata|null);
        }

        class InternalFitnessSample implements IInternalFitnessSample {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessSample);
            public sample_type: POGOProtos.Rpc.InternalFitnessSample.FitnessSampleType;
            public sample_start_timestamp_ms: (number|Long);
            public sample_end_timestamp_ms: (number|Long);
            public value: number;
            public source_type: POGOProtos.Rpc.InternalFitnessSample.FitnessSourceType;
            public metadata?: (POGOProtos.Rpc.IInternalFitnessSampleMetadata|null);
            public static encode(message: POGOProtos.Rpc.IInternalFitnessSample, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessSample;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessSample;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessSample, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFitnessSample {

            enum FitnessSampleType {
                SAMPLE_UNSET = 0,
                STEPS = 1,
                WALKING_DISTANCE_METERS = 2,
                WHEELCHAIR_DISTANCE_METERS = 3,
                CALORIES_KCALS = 4,
                WHEELCHAIR_PUSH_COUNT = 5,
                EXERCISE_TIME_MI = 6
            }

            enum FitnessSourceType {
                SOURCE_UNSET = 0,
                HEALTHKIT = 1,
                GOOGLE_FIT = 2,
                APPLE_WATCH = 3,
                GPS = 4,
                ANDROID_SENSOR_HUB = 5
            }
        }

        interface IInternalFitnessSampleMetadata {
            original_data_source?: (POGOProtos.Rpc.IInternalAndroidDataSource|null);
            data_source?: (POGOProtos.Rpc.IInternalAndroidDataSource|null);
            source_revision?: (POGOProtos.Rpc.IInternalIosSourceRevision|null);
            device?: (POGOProtos.Rpc.IInternalIosDevice|null);
            user_entered?: (boolean|null);
        }

        class InternalFitnessSampleMetadata implements IInternalFitnessSampleMetadata {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessSampleMetadata);
            public original_data_source?: (POGOProtos.Rpc.IInternalAndroidDataSource|null);
            public data_source?: (POGOProtos.Rpc.IInternalAndroidDataSource|null);
            public source_revision?: (POGOProtos.Rpc.IInternalIosSourceRevision|null);
            public device?: (POGOProtos.Rpc.IInternalIosDevice|null);
            public user_entered: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalFitnessSampleMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessSampleMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessSampleMetadata;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessSampleMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFitnessStatsProto {
            last_accumulated_timestamp_ms?: (number|Long|null);
            accumulated?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            pending?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            player_initial_walk_km?: (number|null);
            player_total_walk_km?: (number|null);
            player_total_steps?: (number|Long|null);
        }

        class InternalFitnessStatsProto implements IInternalFitnessStatsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessStatsProto);
            public last_accumulated_timestamp_ms: (number|Long);
            public accumulated?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            public pending?: (POGOProtos.Rpc.IInternalFitnessMetricsProto|null);
            public player_initial_walk_km: number;
            public player_total_walk_km: number;
            public player_total_steps: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalFitnessStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessStatsProto;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFitnessUpdateOutProto {
            status?: (POGOProtos.Rpc.InternalFitnessUpdateOutProto.Status|null);
        }

        class InternalFitnessUpdateOutProto implements IInternalFitnessUpdateOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessUpdateOutProto);
            public status: POGOProtos.Rpc.InternalFitnessUpdateOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalFitnessUpdateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessUpdateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessUpdateOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessUpdateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFitnessUpdateOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalFitnessUpdateProto {
            fitness_samples?: (POGOProtos.Rpc.IInternalFitnessSample[]|null);
        }

        class InternalFitnessUpdateProto implements IInternalFitnessUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFitnessUpdateProto);
            public fitness_samples: POGOProtos.Rpc.IInternalFitnessSample[];
            public static encode(message: POGOProtos.Rpc.IInternalFitnessUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFitnessUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFitnessUpdateProto;
            public static toObject(message: POGOProtos.Rpc.InternalFitnessUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFlagCategory {
        }

        class InternalFlagCategory implements IInternalFlagCategory {
            constructor(properties?: POGOProtos.Rpc.IInternalFlagCategory);
            public static encode(message: POGOProtos.Rpc.IInternalFlagCategory, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFlagCategory;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFlagCategory;
            public static toObject(message: POGOProtos.Rpc.InternalFlagCategory, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFlagCategory {

            enum Category {
                UNDEFINED = 0,
                THREAT = 100,
                SELF_HARM = 101,
                NUDITY = 102,
                VIOLENCE = 103,
                DRUGS = 104,
                CHILD_SAFETY = 105,
                EXTREMISM = 106,
                WEAPONS_AND_SOLICITATION = 107,
                PUBLIC_THREAT = 108,
                INAPPROPRIATE = 200,
                HATE_SPEECH = 201,
                PRIVACY_INVASION = 202,
                SEXUAL = 203,
                IP_VIOLATION = 204,
                HACKING = 205,
                BULLYING = 300,
                SPAM = 301,
                OTHER_VIOLATION = 302
            }
        }

        interface IInternalFlagPhotoRequest {
            reported_player_id?: (string|null);
            photo_id?: (string|null);
            origin?: (POGOProtos.Rpc.InternalReportAttributeData.Origin|null);
            category?: (POGOProtos.Rpc.InternalFlagCategory.Category|null);
            reported_nia_account_id?: (string|null);
        }

        class InternalFlagPhotoRequest implements IInternalFlagPhotoRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalFlagPhotoRequest);
            public reported_player_id: string;
            public photo_id: string;
            public origin: POGOProtos.Rpc.InternalReportAttributeData.Origin;
            public category: POGOProtos.Rpc.InternalFlagCategory.Category;
            public reported_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalFlagPhotoRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFlagPhotoRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFlagPhotoRequest;
            public static toObject(message: POGOProtos.Rpc.InternalFlagPhotoRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFlagPhotoResponse {
            result?: (POGOProtos.Rpc.InternalFlagPhotoResponse.Result|null);
        }

        class InternalFlagPhotoResponse implements IInternalFlagPhotoResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalFlagPhotoResponse);
            public result: POGOProtos.Rpc.InternalFlagPhotoResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalFlagPhotoResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFlagPhotoResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFlagPhotoResponse;
            public static toObject(message: POGOProtos.Rpc.InternalFlagPhotoResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFlagPhotoResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                IMAGE_NOT_FOUND = 2,
                ERROR_UNKNOWN = 3,
                ERROR_FILING_REPORT = 4
            }
        }

        interface IInternalFriendDetailsProto {
            player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
            friend_visible_data?: (POGOProtos.Rpc.IPlayerFriendDisplayProto|null);
            score?: (number|null);
            data_with_me?: (POGOProtos.Rpc.IFriendshipDataProto|null);
            online_status?: (POGOProtos.Rpc.InternalFriendDetailsProto.OnlineStatus|null);
            created_ms?: (number|Long|null);
            shared_data?: (Uint8Array|null);
            data_from_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
            data_to_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
        }

        class InternalFriendDetailsProto implements IInternalFriendDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalFriendDetailsProto);
            public player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
            public friend_visible_data?: (POGOProtos.Rpc.IPlayerFriendDisplayProto|null);
            public score: number;
            public data_with_me?: (POGOProtos.Rpc.IFriendshipDataProto|null);
            public online_status: POGOProtos.Rpc.InternalFriendDetailsProto.OnlineStatus;
            public created_ms: (number|Long);
            public shared_data: Uint8Array;
            public data_from_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
            public data_to_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalFriendDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFriendDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFriendDetailsProto;
            public static toObject(message: POGOProtos.Rpc.InternalFriendDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFriendDetailsProto {

            enum OnlineStatus {
                UNSET = 0,
                STATUS_UNKNOWN = 1,
                STATUS_ONLINE = 2,
                STATUS_OFFLINE = 3
            }
        }

        interface IInternalFriendRecommendation {
            nia_account_id?: (string|null);
            recommendation_score?: (number|null);
            reason?: (POGOProtos.Rpc.InternalFriendRecommendationAttributeData.Reason|null);
            recommendation_id?: (string|null);
        }

        class InternalFriendRecommendation implements IInternalFriendRecommendation {
            constructor(properties?: POGOProtos.Rpc.IInternalFriendRecommendation);
            public nia_account_id: string;
            public recommendation_score: number;
            public reason: POGOProtos.Rpc.InternalFriendRecommendationAttributeData.Reason;
            public recommendation_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalFriendRecommendation, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFriendRecommendation;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFriendRecommendation;
            public static toObject(message: POGOProtos.Rpc.InternalFriendRecommendation, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalFriendRecommendationAttributeData {
        }

        class InternalFriendRecommendationAttributeData implements IInternalFriendRecommendationAttributeData {
            constructor(properties?: POGOProtos.Rpc.IInternalFriendRecommendationAttributeData);
            public static encode(message: POGOProtos.Rpc.IInternalFriendRecommendationAttributeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalFriendRecommendationAttributeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalFriendRecommendationAttributeData;
            public static toObject(message: POGOProtos.Rpc.InternalFriendRecommendationAttributeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalFriendRecommendationAttributeData {

            enum Reason {
                UNSET_REASON = 0
            }

            enum Type {
                UNSET_TYPE = 0,
                NEW_APP_FRIEND_TYPE = 1
            }
        }

        interface IInternalGameplayWeatherProto {
            gameplay_condition?: (POGOProtos.Rpc.InternalGameplayWeatherProto.WeatherCondition|null);
        }

        class InternalGameplayWeatherProto implements IInternalGameplayWeatherProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGameplayWeatherProto);
            public gameplay_condition: POGOProtos.Rpc.InternalGameplayWeatherProto.WeatherCondition;
            public static encode(message: POGOProtos.Rpc.IInternalGameplayWeatherProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGameplayWeatherProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGameplayWeatherProto;
            public static toObject(message: POGOProtos.Rpc.InternalGameplayWeatherProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGameplayWeatherProto {

            enum WeatherCondition {
                NONE = 0,
                CLEAR = 1,
                RAINY = 2,
                PARTLY_CLOUDY = 3,
                OVERCAST = 4,
                WINDY = 5,
                SNOW = 6,
                FOG = 7
            }
        }

        interface IInternalGarAccountInfoProto {
            niantic_id?: (string|null);
            display_name?: (string|null);
        }

        class InternalGarAccountInfoProto implements IInternalGarAccountInfoProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGarAccountInfoProto);
            public niantic_id: string;
            public display_name: string;
            public static encode(message: POGOProtos.Rpc.IInternalGarAccountInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGarAccountInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGarAccountInfoProto;
            public static toObject(message: POGOProtos.Rpc.InternalGarAccountInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGarProxyRequestProto {
            action?: (number|null);
            payload?: (Uint8Array|null);
        }

        class InternalGarProxyRequestProto implements IInternalGarProxyRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGarProxyRequestProto);
            public action: number;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalGarProxyRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGarProxyRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGarProxyRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalGarProxyRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGarProxyResponseProto {
            status?: (POGOProtos.Rpc.InternalGarProxyResponseProto.Status|null);
            error_message?: (string|null);
            payload?: (Uint8Array|null);
        }

        class InternalGarProxyResponseProto implements IInternalGarProxyResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGarProxyResponseProto);
            public status: POGOProtos.Rpc.InternalGarProxyResponseProto.Status;
            public error_message: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalGarProxyResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGarProxyResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGarProxyResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalGarProxyResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGarProxyResponseProto {

            enum Status {
                OK = 0,
                ERROR_UNKNOWN = 2,
                ERROR_PERMISSION_DENIED = 7,
                ERROR_UNAVAILABLE = 14,
                ERROR_UNAUTHENTICATED = 16
            }
        }

        interface IInternalGcmToken {
            registration_id?: (string|null);
            client_operating_system?: (POGOProtos.Rpc.InternalClientOperatingSystem|null);
        }

        class InternalGcmToken implements IInternalGcmToken {
            constructor(properties?: POGOProtos.Rpc.IInternalGcmToken);
            public registration_id: string;
            public client_operating_system: POGOProtos.Rpc.InternalClientOperatingSystem;
            public static encode(message: POGOProtos.Rpc.IInternalGcmToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGcmToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGcmToken;
            public static toObject(message: POGOProtos.Rpc.InternalGcmToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGenerateGmapSignedUrlOutProto {
            result?: (POGOProtos.Rpc.InternalGenerateGmapSignedUrlOutProto.Result|null);
            signed_url?: (string|null);
        }

        class InternalGenerateGmapSignedUrlOutProto implements IInternalGenerateGmapSignedUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGenerateGmapSignedUrlOutProto);
            public result: POGOProtos.Rpc.InternalGenerateGmapSignedUrlOutProto.Result;
            public signed_url: string;
            public static encode(message: POGOProtos.Rpc.IInternalGenerateGmapSignedUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGenerateGmapSignedUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGenerateGmapSignedUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGenerateGmapSignedUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGenerateGmapSignedUrlOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_VALID = 2,
                ERROR_RATE_LIMITED = 3,
                ERROR_MISSING_INPUT = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IInternalGenerateGmapSignedUrlProto {
            latitude?: (number|null);
            longitude?: (number|null);
            width?: (number|null);
            height?: (number|null);
            zoom?: (number|null);
            language_code?: (string|null);
            country_code?: (string|null);
            map_style?: (string|null);
            map_type?: (string|null);
            icon_params?: (string|null);
        }

        class InternalGenerateGmapSignedUrlProto implements IInternalGenerateGmapSignedUrlProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGenerateGmapSignedUrlProto);
            public latitude: number;
            public longitude: number;
            public width: number;
            public height: number;
            public zoom: number;
            public language_code: string;
            public country_code: string;
            public map_style: string;
            public map_type: string;
            public icon_params: string;
            public static encode(message: POGOProtos.Rpc.IInternalGenerateGmapSignedUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGenerateGmapSignedUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGenerateGmapSignedUrlProto;
            public static toObject(message: POGOProtos.Rpc.InternalGenerateGmapSignedUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGenericReportData {
            item_proto?: (POGOProtos.Rpc.IInternalItemProto[]|null);
            origin?: (POGOProtos.Rpc.InternalReportAttributeData.Origin|null);
            content_unit_id?: (string|null);
        }

        class InternalGenericReportData implements IInternalGenericReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalGenericReportData);
            public item_proto: POGOProtos.Rpc.IInternalItemProto[];
            public origin: POGOProtos.Rpc.InternalReportAttributeData.Origin;
            public content_unit_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalGenericReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGenericReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGenericReportData;
            public static toObject(message: POGOProtos.Rpc.InternalGenericReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGeofenceMetadata {
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
            radius?: (number|null);
            identifier?: (string|null);
            expiration_ms?: (number|Long|null);
            dwell_time_ms?: (number|Long|null);
            fire_on_entrance?: (boolean|null);
            fire_on_exit?: (boolean|null);
        }

        class InternalGeofenceMetadata implements IInternalGeofenceMetadata {
            constructor(properties?: POGOProtos.Rpc.IInternalGeofenceMetadata);
            public latitude_deg: number;
            public longitude_deg: number;
            public radius: number;
            public identifier: string;
            public expiration_ms: (number|Long);
            public dwell_time_ms: (number|Long);
            public fire_on_entrance: boolean;
            public fire_on_exit: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalGeofenceMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGeofenceMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGeofenceMetadata;
            public static toObject(message: POGOProtos.Rpc.InternalGeofenceMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGeofenceUpdateOutProto {
            geofence?: (POGOProtos.Rpc.IInternalGeofenceMetadata[]|null);
        }

        class InternalGeofenceUpdateOutProto implements IInternalGeofenceUpdateOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGeofenceUpdateOutProto);
            public geofence: POGOProtos.Rpc.IInternalGeofenceMetadata[];
            public static encode(message: POGOProtos.Rpc.IInternalGeofenceUpdateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGeofenceUpdateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGeofenceUpdateOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGeofenceUpdateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGeofenceUpdateProto {
            number_of_points?: (number|null);
            minimum_point_radius_m?: (number|null);
        }

        class InternalGeofenceUpdateProto implements IInternalGeofenceUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGeofenceUpdateProto);
            public number_of_points: number;
            public minimum_point_radius_m: number;
            public static encode(message: POGOProtos.Rpc.IInternalGeofenceUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGeofenceUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGeofenceUpdateProto;
            public static toObject(message: POGOProtos.Rpc.InternalGeofenceUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetAccountSettingsOutProto {
            result?: (POGOProtos.Rpc.InternalGetAccountSettingsOutProto.Result|null);
            settings?: (POGOProtos.Rpc.IInternalAccountSettingsProto|null);
        }

        class InternalGetAccountSettingsOutProto implements IInternalGetAccountSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAccountSettingsOutProto);
            public result: POGOProtos.Rpc.InternalGetAccountSettingsOutProto.Result;
            public settings?: (POGOProtos.Rpc.IInternalAccountSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetAccountSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAccountSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAccountSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAccountSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetAccountSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetAccountSettingsProto {
        }

        class InternalGetAccountSettingsProto implements IInternalGetAccountSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAccountSettingsProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetAccountSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAccountSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAccountSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAccountSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetAdventureSyncFitnessReportRequestProto {
            num_of_days?: (number|null);
            num_of_weeks?: (number|null);
        }

        class InternalGetAdventureSyncFitnessReportRequestProto implements IInternalGetAdventureSyncFitnessReportRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAdventureSyncFitnessReportRequestProto);
            public num_of_days: number;
            public num_of_weeks: number;
            public static encode(message: POGOProtos.Rpc.IInternalGetAdventureSyncFitnessReportRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetAdventureSyncFitnessReportResponseProto {
            status?: (POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportResponseProto.Status|null);
            daily_reports?: (POGOProtos.Rpc.IInternalFitnessReportProto[]|null);
            weekly_reports?: (POGOProtos.Rpc.IInternalFitnessReportProto[]|null);
            week_reset_timestamp_since_monday_ms?: (number|Long|null);
        }

        class InternalGetAdventureSyncFitnessReportResponseProto implements IInternalGetAdventureSyncFitnessReportResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAdventureSyncFitnessReportResponseProto);
            public status: POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportResponseProto.Status;
            public daily_reports: POGOProtos.Rpc.IInternalFitnessReportProto[];
            public weekly_reports: POGOProtos.Rpc.IInternalFitnessReportProto[];
            public week_reset_timestamp_since_monday_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalGetAdventureSyncFitnessReportResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAdventureSyncFitnessReportResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetAdventureSyncFitnessReportResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_FOUND = 2,
                ERROR_RECORDS_NOT_FOUND = 3,
                ERROR_INVALID_WINDOW = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IInternalGetAdventureSyncProgressOutProto {
            status?: (POGOProtos.Rpc.InternalGetAdventureSyncProgressOutProto.Status|null);
            progress?: (POGOProtos.Rpc.IInternalAdventureSyncProgress|null);
        }

        class InternalGetAdventureSyncProgressOutProto implements IInternalGetAdventureSyncProgressOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAdventureSyncProgressOutProto);
            public status: POGOProtos.Rpc.InternalGetAdventureSyncProgressOutProto.Status;
            public progress?: (POGOProtos.Rpc.IInternalAdventureSyncProgress|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetAdventureSyncProgressOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAdventureSyncProgressOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAdventureSyncProgressOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAdventureSyncProgressOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetAdventureSyncProgressOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                DISABLED = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IInternalGetAdventureSyncProgressProto {
            request?: (Uint8Array|null);
        }

        class InternalGetAdventureSyncProgressProto implements IInternalGetAdventureSyncProgressProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAdventureSyncProgressProto);
            public request: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalGetAdventureSyncProgressProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAdventureSyncProgressProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAdventureSyncProgressProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAdventureSyncProgressProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetAdventureSyncSettingsRequestProto {
        }

        class InternalGetAdventureSyncSettingsRequestProto implements IInternalGetAdventureSyncSettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAdventureSyncSettingsRequestProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetAdventureSyncSettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAdventureSyncSettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAdventureSyncSettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAdventureSyncSettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetAdventureSyncSettingsResponseProto {
            status?: (POGOProtos.Rpc.InternalGetAdventureSyncSettingsResponseProto.Status|null);
            adventure_sync_settings?: (POGOProtos.Rpc.IInternalAdventureSyncSettingsProto|null);
        }

        class InternalGetAdventureSyncSettingsResponseProto implements IInternalGetAdventureSyncSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAdventureSyncSettingsResponseProto);
            public status: POGOProtos.Rpc.InternalGetAdventureSyncSettingsResponseProto.Status;
            public adventure_sync_settings?: (POGOProtos.Rpc.IInternalAdventureSyncSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetAdventureSyncSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAdventureSyncSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAdventureSyncSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAdventureSyncSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetAdventureSyncSettingsResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IInternalGetAvailableSubmissionsOutProto {
            submissions_left?: (number|null);
            min_player_level?: (number|null);
            has_valid_email?: (boolean|null);
            is_feature_enabled?: (boolean|null);
            time_window_for_submissions_limit_ms?: (number|Long|null);
        }

        class InternalGetAvailableSubmissionsOutProto implements IInternalGetAvailableSubmissionsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAvailableSubmissionsOutProto);
            public submissions_left: number;
            public min_player_level: number;
            public has_valid_email: boolean;
            public is_feature_enabled: boolean;
            public time_window_for_submissions_limit_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalGetAvailableSubmissionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAvailableSubmissionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAvailableSubmissionsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAvailableSubmissionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetAvailableSubmissionsProto {
        }

        class InternalGetAvailableSubmissionsProto implements IInternalGetAvailableSubmissionsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetAvailableSubmissionsProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetAvailableSubmissionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetAvailableSubmissionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetAvailableSubmissionsProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetAvailableSubmissionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetBackgroundModeSettingsOutProto {
            status?: (POGOProtos.Rpc.InternalGetBackgroundModeSettingsOutProto.Status|null);
            settings?: (POGOProtos.Rpc.IInternalBackgroundModeClientSettingsProto|null);
        }

        class InternalGetBackgroundModeSettingsOutProto implements IInternalGetBackgroundModeSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetBackgroundModeSettingsOutProto);
            public status: POGOProtos.Rpc.InternalGetBackgroundModeSettingsOutProto.Status;
            public settings?: (POGOProtos.Rpc.IInternalBackgroundModeClientSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetBackgroundModeSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetBackgroundModeSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetBackgroundModeSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetBackgroundModeSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetBackgroundModeSettingsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetBackgroundModeSettingsProto {
        }

        class InternalGetBackgroundModeSettingsProto implements IInternalGetBackgroundModeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetBackgroundModeSettingsProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetBackgroundModeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetBackgroundModeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetBackgroundModeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetBackgroundModeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetClientFeatureFlagsRequest {
            country_code?: (string|null);
        }

        class InternalGetClientFeatureFlagsRequest implements IInternalGetClientFeatureFlagsRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetClientFeatureFlagsRequest);
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetClientFeatureFlagsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetClientFeatureFlagsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetClientFeatureFlagsRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetClientFeatureFlagsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetClientFeatureFlagsResponse {
            feature_flags?: (POGOProtos.Rpc.IInternalSocialClientFeatures|null);
            global_settings?: (POGOProtos.Rpc.IInternalSocialClientGlobalSettings|null);
        }

        class InternalGetClientFeatureFlagsResponse implements IInternalGetClientFeatureFlagsResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetClientFeatureFlagsResponse);
            public feature_flags?: (POGOProtos.Rpc.IInternalSocialClientFeatures|null);
            public global_settings?: (POGOProtos.Rpc.IInternalSocialClientGlobalSettings|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetClientFeatureFlagsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetClientFeatureFlagsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetClientFeatureFlagsResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetClientFeatureFlagsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetClientSettingsRequest {
            country_code?: (string|null);
        }

        class InternalGetClientSettingsRequest implements IInternalGetClientSettingsRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetClientSettingsRequest);
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetClientSettingsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetClientSettingsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetClientSettingsRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetClientSettingsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetClientSettingsResponse {
            phone_number_settings?: (POGOProtos.Rpc.InternalGetClientSettingsResponse.IPhoneNumberSettings|null);
        }

        class InternalGetClientSettingsResponse implements IInternalGetClientSettingsResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetClientSettingsResponse);
            public phone_number_settings?: (POGOProtos.Rpc.InternalGetClientSettingsResponse.IPhoneNumberSettings|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetClientSettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetClientSettingsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetClientSettingsResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetClientSettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetClientSettingsResponse {

            interface IPhoneNumberSettings {
                country?: (POGOProtos.Rpc.IInternalPhoneNumberCountryProto[]|null);
            }

            class PhoneNumberSettings implements IPhoneNumberSettings {
                constructor(properties?: POGOProtos.Rpc.InternalGetClientSettingsResponse.IPhoneNumberSettings);
                public country: POGOProtos.Rpc.IInternalPhoneNumberCountryProto[];
                public static encode(message: POGOProtos.Rpc.InternalGetClientSettingsResponse.IPhoneNumberSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetClientSettingsResponse.PhoneNumberSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetClientSettingsResponse.PhoneNumberSettings;
                public static toObject(message: POGOProtos.Rpc.InternalGetClientSettingsResponse.PhoneNumberSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalGetContactListInfoRequest {
        }

        class InternalGetContactListInfoRequest implements IInternalGetContactListInfoRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetContactListInfoRequest);
            public static encode(message: POGOProtos.Rpc.IInternalGetContactListInfoRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetContactListInfoRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetContactListInfoRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetContactListInfoRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetContactListInfoResponse {
            has_new_account_matching?: (boolean|null);
        }

        class InternalGetContactListInfoResponse implements IInternalGetContactListInfoResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetContactListInfoResponse);
            public has_new_account_matching: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalGetContactListInfoResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetContactListInfoResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetContactListInfoResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetContactListInfoResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFacebookFriendListOutProto {
            result?: (POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.Result|null);
            next_cursor?: (string|null);
        }

        class InternalGetFacebookFriendListOutProto implements IInternalGetFacebookFriendListOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFacebookFriendListOutProto);
            public result: POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.Result;
            public next_cursor: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetFacebookFriendListOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFacebookFriendListOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFacebookFriendListOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFacebookFriendListOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFacebookFriendListOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FACEBOOK_API = 3,
                ERROR_FACEBOOK_PERMISSIONS = 4,
                ERROR_NO_FACEBOOK_ID = 5,
                ERROR_PLAYER_NOT_FOUND = 6
            }

            interface IFacebookFriendProto {
                player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
                full_name?: (string|null);
            }

            class FacebookFriendProto implements IFacebookFriendProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.IFacebookFriendProto);
                public player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
                public full_name: string;
                public static encode(message: POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.IFacebookFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.FacebookFriendProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.FacebookFriendProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetFacebookFriendListOutProto.FacebookFriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalGetFacebookFriendListProto {
            fb_access_token?: (string|null);
            limit?: (number|null);
            cursor?: (string|null);
        }

        class InternalGetFacebookFriendListProto implements IInternalGetFacebookFriendListProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFacebookFriendListProto);
            public fb_access_token: string;
            public limit: number;
            public cursor: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetFacebookFriendListProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFacebookFriendListProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFacebookFriendListProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFacebookFriendListProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFitnessReportOutProto {
            status?: (POGOProtos.Rpc.InternalGetFitnessReportOutProto.Status|null);
            daily_reports?: (POGOProtos.Rpc.IInternalFitnessReportProto[]|null);
            weekly_reports?: (POGOProtos.Rpc.IInternalFitnessReportProto[]|null);
            week_reset_timestamp_since_monday_ms?: (number|Long|null);
            hourly_reports?: (POGOProtos.Rpc.IInternalFitnessReportProto[]|null);
        }

        class InternalGetFitnessReportOutProto implements IInternalGetFitnessReportOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFitnessReportOutProto);
            public status: POGOProtos.Rpc.InternalGetFitnessReportOutProto.Status;
            public daily_reports: POGOProtos.Rpc.IInternalFitnessReportProto[];
            public weekly_reports: POGOProtos.Rpc.IInternalFitnessReportProto[];
            public week_reset_timestamp_since_monday_ms: (number|Long);
            public hourly_reports: POGOProtos.Rpc.IInternalFitnessReportProto[];
            public static encode(message: POGOProtos.Rpc.IInternalGetFitnessReportOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFitnessReportOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFitnessReportOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFitnessReportOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFitnessReportOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_FOUND = 2,
                ERROR_RECORDS_NOT_FOUND = 3,
                ERROR_INVALID_WINDOW = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IInternalGetFitnessReportProto {
            num_of_days?: (number|null);
            num_of_weeks?: (number|null);
            num_of_hours?: (number|null);
        }

        class InternalGetFitnessReportProto implements IInternalGetFitnessReportProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFitnessReportProto);
            public num_of_days: number;
            public num_of_weeks: number;
            public num_of_hours: number;
            public static encode(message: POGOProtos.Rpc.IInternalGetFitnessReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFitnessReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFitnessReportProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFitnessReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFriendCodeOutProto {
            result?: (POGOProtos.Rpc.InternalGetFriendCodeOutProto.Result|null);
            friend_code?: (string|null);
        }

        class InternalGetFriendCodeOutProto implements IInternalGetFriendCodeOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendCodeOutProto);
            public result: POGOProtos.Rpc.InternalGetFriendCodeOutProto.Result;
            public friend_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendCodeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendCodeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendCodeOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendCodeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFriendCodeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IInternalGetFriendCodeProto {
            force_generate_code?: (boolean|null);
        }

        class InternalGetFriendCodeProto implements IInternalGetFriendCodeProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendCodeProto);
            public force_generate_code: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendCodeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendCodeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendCodeProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendCodeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFriendDetailsOutProto {
            result?: (POGOProtos.Rpc.InternalGetFriendDetailsOutProto.Result|null);
            friend?: (POGOProtos.Rpc.IInternalFriendDetailsProto[]|null);
            friend_details_debug_info?: (POGOProtos.Rpc.InternalGetFriendDetailsOutProto.IDebugProto|null);
        }

        class InternalGetFriendDetailsOutProto implements IInternalGetFriendDetailsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendDetailsOutProto);
            public result: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.Result;
            public friend: POGOProtos.Rpc.IInternalFriendDetailsProto[];
            public friend_details_debug_info?: (POGOProtos.Rpc.InternalGetFriendDetailsOutProto.IDebugProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendDetailsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFriendDetailsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                EXCEEDS_MAX_PLAYERS_PER_QUERY = 3
            }

            interface IDebugProto {
                fetched_from_db?: (number|null);
                fetched_from_fanout?: (number|null);
                fetched_from_player_mapper?: (number|null);
                fetched_from_status_cache?: (number|null);
                failed_to_fetch?: (number|null);
                fetched_from_same_server_as_player?: (number|null);
            }

            class DebugProto implements IDebugProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.IDebugProto);
                public fetched_from_db: number;
                public fetched_from_fanout: number;
                public fetched_from_player_mapper: number;
                public fetched_from_status_cache: number;
                public failed_to_fetch: number;
                public fetched_from_same_server_as_player: number;
                public static encode(message: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.IDebugProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DebugProto {

                interface ICallee {
                    player_id?: (string|null);
                    nia_account_id?: (string|null);
                }

                class Callee implements ICallee {
                    constructor(properties?: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto.ICallee);
                    public player_id: string;
                    public nia_account_id: string;
                    public static encode(message: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto.ICallee, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto.Callee;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto.Callee;
                    public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsOutProto.DebugProto.Callee, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IInternalGetFriendDetailsProto {
            player_id?: (string[]|null);
            nia_account_id?: (string[]|null);
            include_online_status?: (boolean|null);
        }

        class InternalGetFriendDetailsProto implements IInternalGetFriendDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendDetailsProto);
            public player_id: string[];
            public nia_account_id: string[];
            public include_online_status: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFriendDetailsRequest {
            friend_id?: (string[]|null);
            feature?: (POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.FeatureType|null);
            friend_nia_account_id?: (string[]|null);
        }

        class InternalGetFriendDetailsRequest implements IInternalGetFriendDetailsRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendDetailsRequest);
            public friend_id: string[];
            public feature: POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.FeatureType;
            public friend_nia_account_id: string[];
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendDetailsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFriendDetailsResponse {
            result?: (POGOProtos.Rpc.InternalGetFriendDetailsResponse.Result|null);
            friend_details?: (POGOProtos.Rpc.InternalGetFriendDetailsResponse.IFriendDetailsEntryProto[]|null);
        }

        class InternalGetFriendDetailsResponse implements IInternalGetFriendDetailsResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendDetailsResponse);
            public result: POGOProtos.Rpc.InternalGetFriendDetailsResponse.Result;
            public friend_details: POGOProtos.Rpc.InternalGetFriendDetailsResponse.IFriendDetailsEntryProto[];
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFriendDetailsResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_EXCEEDS_MAX_FRIENDS_PER_QUERY = 3,
                ERROR_FEATURE_DISABLED = 4
            }

            interface IFriendDetailsEntryProto {
                player_id?: (string|null);
                profile?: (POGOProtos.Rpc.IInternalProfileDetailsProto|null);
                player_status?: (POGOProtos.Rpc.InternalGetFriendDetailsResponse.IPlayerStatusDetailsProto|null);
                calling_game_data?: (POGOProtos.Rpc.IInternalFriendDetailsProto|null);
                outgoing_game_invite_status?: (POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.IOutgoingGameInviteStatus[]|null);
                nia_account_id?: (string|null);
                gar_account_info?: (POGOProtos.Rpc.IInternalGarAccountInfoProto|null);
            }

            class FriendDetailsEntryProto implements IFriendDetailsEntryProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetFriendDetailsResponse.IFriendDetailsEntryProto);
                public player_id: string;
                public profile?: (POGOProtos.Rpc.IInternalProfileDetailsProto|null);
                public player_status?: (POGOProtos.Rpc.InternalGetFriendDetailsResponse.IPlayerStatusDetailsProto|null);
                public calling_game_data?: (POGOProtos.Rpc.IInternalFriendDetailsProto|null);
                public outgoing_game_invite_status: POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.IOutgoingGameInviteStatus[];
                public nia_account_id: string;
                public gar_account_info?: (POGOProtos.Rpc.IInternalGarAccountInfoProto|null);
                public static encode(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse.IFriendDetailsEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FriendDetailsEntryProto {

                interface IOutgoingGameInviteStatus {
                    app_key?: (string|null);
                    invitation_status?: (POGOProtos.Rpc.InternalSocialV2Enum.InvitationStatus|null);
                }

                class OutgoingGameInviteStatus implements IOutgoingGameInviteStatus {
                    constructor(properties?: POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.IOutgoingGameInviteStatus);
                    public app_key: string;
                    public invitation_status: POGOProtos.Rpc.InternalSocialV2Enum.InvitationStatus;
                    public static encode(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.IOutgoingGameInviteStatus, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.OutgoingGameInviteStatus;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.OutgoingGameInviteStatus;
                    public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse.FriendDetailsEntryProto.OutgoingGameInviteStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IPlayerStatusDetailsProto {
                result?: (POGOProtos.Rpc.InternalGetFriendDetailsResponse.PlayerStatusDetailsProto.Result|null);
                online_status?: (POGOProtos.Rpc.InternalSocialV2Enum.OnlineStatus|null);
                last_played_app_key?: (string|null);
            }

            class PlayerStatusDetailsProto implements IPlayerStatusDetailsProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetFriendDetailsResponse.IPlayerStatusDetailsProto);
                public result: POGOProtos.Rpc.InternalGetFriendDetailsResponse.PlayerStatusDetailsProto.Result;
                public online_status: POGOProtos.Rpc.InternalSocialV2Enum.OnlineStatus;
                public last_played_app_key: string;
                public static encode(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse.IPlayerStatusDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendDetailsResponse.PlayerStatusDetailsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendDetailsResponse.PlayerStatusDetailsProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetFriendDetailsResponse.PlayerStatusDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PlayerStatusDetailsProto {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_UNKNOWN = 2,
                    ERROR_STATUS_UNKNOWN = 3,
                    ERROR_STALE_DATA = 4
                }
            }
        }

        interface IInternalGetFriendRecommendationRequest {
            type?: (POGOProtos.Rpc.InternalFriendRecommendationAttributeData.Type|null);
        }

        class InternalGetFriendRecommendationRequest implements IInternalGetFriendRecommendationRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendRecommendationRequest);
            public type: POGOProtos.Rpc.InternalFriendRecommendationAttributeData.Type;
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendRecommendationRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendRecommendationRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendRecommendationRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendRecommendationRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetFriendRecommendationResponse {
            result?: (POGOProtos.Rpc.InternalGetFriendRecommendationResponse.Result|null);
            friend_recommendation?: (POGOProtos.Rpc.IInternalFriendRecommendation[]|null);
        }

        class InternalGetFriendRecommendationResponse implements IInternalGetFriendRecommendationResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendRecommendationResponse);
            public result: POGOProtos.Rpc.InternalGetFriendRecommendationResponse.Result;
            public friend_recommendation: POGOProtos.Rpc.IInternalFriendRecommendation[];
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendRecommendationResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendRecommendationResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendRecommendationResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendRecommendationResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFriendRecommendationResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IInternalGetFriendsListOutProto {
            result?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.Result|null);
            friend?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.IFriendProto[]|null);
        }

        class InternalGetFriendsListOutProto implements IInternalGetFriendsListOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendsListOutProto);
            public result: POGOProtos.Rpc.InternalGetFriendsListOutProto.Result;
            public friend: POGOProtos.Rpc.InternalGetFriendsListOutProto.IFriendProto[];
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendsListOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendsListOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendsListOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendsListOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetFriendsListOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }

            interface IFriendProto {
                player_id?: (string|null);
                codename?: (string|null);
                team?: (string|null);
                score?: (number|null);
                data_with_me?: (POGOProtos.Rpc.IFriendshipDataProto|null);
                version?: (number|Long|null);
                created_ms?: (number|Long|null);
                fb_user_id?: (string|null);
                is_facebook_friendship?: (boolean|null);
                shared_data?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.ISharedFriendshipProto|null);
                online_status?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.FriendProto.OnlineStatus|null);
                nia_account_id?: (string|null);
                display_name?: (string|null);
            }

            class FriendProto implements IFriendProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetFriendsListOutProto.IFriendProto);
                public player_id: string;
                public codename: string;
                public team: string;
                public score: number;
                public data_with_me?: (POGOProtos.Rpc.IFriendshipDataProto|null);
                public version: (number|Long);
                public created_ms: (number|Long);
                public fb_user_id: string;
                public is_facebook_friendship: boolean;
                public shared_data?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.ISharedFriendshipProto|null);
                public online_status: POGOProtos.Rpc.InternalGetFriendsListOutProto.FriendProto.OnlineStatus;
                public nia_account_id: string;
                public display_name: string;
                public static encode(message: POGOProtos.Rpc.InternalGetFriendsListOutProto.IFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendsListOutProto.FriendProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendsListOutProto.FriendProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetFriendsListOutProto.FriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FriendProto {

                enum OnlineStatus {
                    UNSET = 0,
                    STATUS_UNKNOWN = 1,
                    STATUS_ONLINE = 2,
                    STATUS_OFFLINE = 3
                }
            }

            interface ISharedFriendshipProto {
                shared_data?: (Uint8Array|null);
                version?: (number|Long|null);
                data_from_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
                data_to_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
            }

            class SharedFriendshipProto implements ISharedFriendshipProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetFriendsListOutProto.ISharedFriendshipProto);
                public shared_data: Uint8Array;
                public version: (number|Long);
                public data_from_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
                public data_to_me?: (POGOProtos.Rpc.IOneWaySharedFriendshipDataProto|null);
                public static encode(message: POGOProtos.Rpc.InternalGetFriendsListOutProto.ISharedFriendshipProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendsListOutProto.SharedFriendshipProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendsListOutProto.SharedFriendshipProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetFriendsListOutProto.SharedFriendshipProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalGetFriendsListProto {
            list_option?: (POGOProtos.Rpc.InternalSocialSettings.ListOption|null);
        }

        class InternalGetFriendsListProto implements IInternalGetFriendsListProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetFriendsListProto);
            public list_option: POGOProtos.Rpc.InternalSocialSettings.ListOption;
            public static encode(message: POGOProtos.Rpc.IInternalGetFriendsListProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetFriendsListProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetFriendsListProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetFriendsListProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetGmapSettingsOutProto {
            result?: (POGOProtos.Rpc.InternalGetGmapSettingsOutProto.Result|null);
            gmap_template_url?: (string|null);
            max_poi_distance_in_meters?: (number|null);
        }

        class InternalGetGmapSettingsOutProto implements IInternalGetGmapSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetGmapSettingsOutProto);
            public result: POGOProtos.Rpc.InternalGetGmapSettingsOutProto.Result;
            public gmap_template_url: string;
            public max_poi_distance_in_meters: number;
            public static encode(message: POGOProtos.Rpc.IInternalGetGmapSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetGmapSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetGmapSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetGmapSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetGmapSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_MISSING_CONFIG = 3,
                ERROR_NO_UNIQUE_ID = 4
            }
        }

        interface IInternalGetGmapSettingsProto {
        }

        class InternalGetGmapSettingsProto implements IInternalGetGmapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetGmapSettingsProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetGmapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetGmapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetGmapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetGmapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetInboxV2Proto {
            is_history?: (boolean|null);
            is_reverse?: (boolean|null);
            not_before_ms?: (number|Long|null);
        }

        class InternalGetInboxV2Proto implements IInternalGetInboxV2Proto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetInboxV2Proto);
            public is_history: boolean;
            public is_reverse: boolean;
            public not_before_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalGetInboxV2Proto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetInboxV2Proto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetInboxV2Proto;
            public static toObject(message: POGOProtos.Rpc.InternalGetInboxV2Proto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetIncomingFriendInvitesOutProto {
            result?: (POGOProtos.Rpc.InternalGetIncomingFriendInvitesOutProto.Result|null);
            invites?: (POGOProtos.Rpc.IInternalIncomingFriendInviteDisplayProto[]|null);
        }

        class InternalGetIncomingFriendInvitesOutProto implements IInternalGetIncomingFriendInvitesOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetIncomingFriendInvitesOutProto);
            public result: POGOProtos.Rpc.InternalGetIncomingFriendInvitesOutProto.Result;
            public invites: POGOProtos.Rpc.IInternalIncomingFriendInviteDisplayProto[];
            public static encode(message: POGOProtos.Rpc.IInternalGetIncomingFriendInvitesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetIncomingFriendInvitesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetIncomingFriendInvitesOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetIncomingFriendInvitesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetIncomingFriendInvitesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetIncomingFriendInvitesProto {
        }

        class InternalGetIncomingFriendInvitesProto implements IInternalGetIncomingFriendInvitesProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetIncomingFriendInvitesProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetIncomingFriendInvitesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetIncomingFriendInvitesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetIncomingFriendInvitesProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetIncomingFriendInvitesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetIncomingGameInvitesRequest {
        }

        class InternalGetIncomingGameInvitesRequest implements IInternalGetIncomingGameInvitesRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetIncomingGameInvitesRequest);
            public static encode(message: POGOProtos.Rpc.IInternalGetIncomingGameInvitesRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetIncomingGameInvitesRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetIncomingGameInvitesRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetIncomingGameInvitesRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetIncomingGameInvitesResponse {
            invites?: (POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IIncomingGameInvite[]|null);
            result?: (POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.Result|null);
        }

        class InternalGetIncomingGameInvitesResponse implements IInternalGetIncomingGameInvitesResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetIncomingGameInvitesResponse);
            public invites: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IIncomingGameInvite[];
            public result: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalGetIncomingGameInvitesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetIncomingGameInvitesResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FEATURE_DISABLED = 3
            }

            interface IIncomingGameInvite {
                app_key?: (string|null);
                friend_profile_names?: (string[]|null);
                status?: (POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IncomingGameInvite.Status|null);
            }

            class IncomingGameInvite implements IIncomingGameInvite {
                constructor(properties?: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IIncomingGameInvite);
                public app_key: string;
                public friend_profile_names: string[];
                public status: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IncomingGameInvite.Status;
                public static encode(message: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IIncomingGameInvite, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IncomingGameInvite;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IncomingGameInvite;
                public static toObject(message: POGOProtos.Rpc.InternalGetIncomingGameInvitesResponse.IncomingGameInvite, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace IncomingGameInvite {

                enum Status {
                    UNSET = 0,
                    NEW = 1,
                    SEEN = 2
                }
            }
        }

        interface IInternalGetInventoryProto {
            timestamp_millis?: (number|Long|null);
        }

        class InternalGetInventoryProto implements IInternalGetInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetInventoryProto);
            public timestamp_millis: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalGetInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetInventoryProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetInventoryResponseProto {
            success?: (boolean|null);
            inventory_delta?: (POGOProtos.Rpc.IInternalInventoryDeltaProto|null);
        }

        class InternalGetInventoryResponseProto implements IInternalGetInventoryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetInventoryResponseProto);
            public success: boolean;
            public inventory_delta?: (POGOProtos.Rpc.IInternalInventoryDeltaProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetInventoryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetInventoryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetInventoryResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetInventoryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetMyAccountRequest {
        }

        class InternalGetMyAccountRequest implements IInternalGetMyAccountRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetMyAccountRequest);
            public static encode(message: POGOProtos.Rpc.IInternalGetMyAccountRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetMyAccountRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetMyAccountRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetMyAccountRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetMyAccountResponse {
            status?: (POGOProtos.Rpc.InternalGetMyAccountResponse.Status|null);
            contact?: (POGOProtos.Rpc.InternalGetMyAccountResponse.IContactProto[]|null);
            full_name?: (string|null);
            contact_import_discoverability_consent?: (POGOProtos.Rpc.InternalAccountContactSettings.ConsentStatus|null);
        }

        class InternalGetMyAccountResponse implements IInternalGetMyAccountResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetMyAccountResponse);
            public status: POGOProtos.Rpc.InternalGetMyAccountResponse.Status;
            public contact: POGOProtos.Rpc.InternalGetMyAccountResponse.IContactProto[];
            public full_name: string;
            public contact_import_discoverability_consent: POGOProtos.Rpc.InternalAccountContactSettings.ConsentStatus;
            public static encode(message: POGOProtos.Rpc.IInternalGetMyAccountResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetMyAccountResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetMyAccountResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetMyAccountResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetMyAccountResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FOUND = 3
            }

            interface IContactProto {
                contact_id?: (string|null);
                type?: (POGOProtos.Rpc.InternalGetMyAccountResponse.ContactProto.Type|null);
                contact?: (string|null);
            }

            class ContactProto implements IContactProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetMyAccountResponse.IContactProto);
                public contact_id: string;
                public type: POGOProtos.Rpc.InternalGetMyAccountResponse.ContactProto.Type;
                public contact: string;
                public static encode(message: POGOProtos.Rpc.InternalGetMyAccountResponse.IContactProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetMyAccountResponse.ContactProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetMyAccountResponse.ContactProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetMyAccountResponse.ContactProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ContactProto {

                enum Type {
                    UNSET = 0,
                    MASKED_PHONE_NUMBER = 1
                }
            }
        }

        interface IInternalGetNotificationInboxOutProto {
            result?: (POGOProtos.Rpc.InternalGetNotificationInboxOutProto.Result|null);
            inbox?: (POGOProtos.Rpc.IInternalClientInbox|null);
        }

        class InternalGetNotificationInboxOutProto implements IInternalGetNotificationInboxOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetNotificationInboxOutProto);
            public result: POGOProtos.Rpc.InternalGetNotificationInboxOutProto.Result;
            public inbox?: (POGOProtos.Rpc.IInternalClientInbox|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetNotificationInboxOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetNotificationInboxOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetNotificationInboxOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetNotificationInboxOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetNotificationInboxOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IInternalGetOutgoingBlocksOutProto {
            blockee_nia_account_ids?: (string[]|null);
        }

        class InternalGetOutgoingBlocksOutProto implements IInternalGetOutgoingBlocksOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetOutgoingBlocksOutProto);
            public blockee_nia_account_ids: string[];
            public static encode(message: POGOProtos.Rpc.IInternalGetOutgoingBlocksOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutgoingBlocksOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutgoingBlocksOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetOutgoingBlocksOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetOutgoingBlocksProto {
        }

        class InternalGetOutgoingBlocksProto implements IInternalGetOutgoingBlocksProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetOutgoingBlocksProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetOutgoingBlocksProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutgoingBlocksProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutgoingBlocksProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetOutgoingBlocksProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetOutgoingFriendInvitesOutProto {
            result?: (POGOProtos.Rpc.InternalGetOutgoingFriendInvitesOutProto.Result|null);
            invites?: (POGOProtos.Rpc.IInternalOutgoingFriendInviteDisplayProto[]|null);
        }

        class InternalGetOutgoingFriendInvitesOutProto implements IInternalGetOutgoingFriendInvitesOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesOutProto);
            public result: POGOProtos.Rpc.InternalGetOutgoingFriendInvitesOutProto.Result;
            public invites: POGOProtos.Rpc.IInternalOutgoingFriendInviteDisplayProto[];
            public static encode(message: POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutgoingFriendInvitesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutgoingFriendInvitesOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetOutgoingFriendInvitesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetOutgoingFriendInvitesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetOutgoingFriendInvitesProto {
        }

        class InternalGetOutgoingFriendInvitesProto implements IInternalGetOutgoingFriendInvitesProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetOutgoingFriendInvitesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutgoingFriendInvitesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutgoingFriendInvitesProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetOutgoingFriendInvitesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetOutstandingWarningsRequestProto {
        }

        class InternalGetOutstandingWarningsRequestProto implements IInternalGetOutstandingWarningsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetOutstandingWarningsRequestProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetOutstandingWarningsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutstandingWarningsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutstandingWarningsRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetOutstandingWarningsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetOutstandingWarningsResponseProto {
            outstanding_warning?: (POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.IWarningInfo[]|null);
        }

        class InternalGetOutstandingWarningsResponseProto implements IInternalGetOutstandingWarningsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetOutstandingWarningsResponseProto);
            public outstanding_warning: POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.IWarningInfo[];
            public static encode(message: POGOProtos.Rpc.IInternalGetOutstandingWarningsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetOutstandingWarningsResponseProto {

            interface IWarningInfo {
                type?: (POGOProtos.Rpc.InternalPlatformWarningType|null);
                source?: (POGOProtos.Rpc.InternalSource|null);
                start_timestamp_ms?: (number|Long|null);
                end_timestamp_ms?: (number|Long|null);
                reason_statements?: (POGOProtos.Rpc.IStatementOfReason[]|null);
            }

            class WarningInfo implements IWarningInfo {
                constructor(properties?: POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.IWarningInfo);
                public type: POGOProtos.Rpc.InternalPlatformWarningType;
                public source: POGOProtos.Rpc.InternalSource;
                public start_timestamp_ms: (number|Long);
                public end_timestamp_ms: (number|Long);
                public reason_statements: POGOProtos.Rpc.IStatementOfReason[];
                public static encode(message: POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.IWarningInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.WarningInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.WarningInfo;
                public static toObject(message: POGOProtos.Rpc.InternalGetOutstandingWarningsResponseProto.WarningInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalGetPhotosOutProto {
            result?: (POGOProtos.Rpc.InternalGetPhotosOutProto.Result|null);
            photos?: (POGOProtos.Rpc.IInternalPhotoRecord[]|null);
        }

        class InternalGetPhotosOutProto implements IInternalGetPhotosOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetPhotosOutProto);
            public result: POGOProtos.Rpc.InternalGetPhotosOutProto.Result;
            public photos: POGOProtos.Rpc.IInternalPhotoRecord[];
            public static encode(message: POGOProtos.Rpc.IInternalGetPhotosOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetPhotosOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetPhotosOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetPhotosOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetPhotosOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetPhotosProto {
            photo_ids?: (string[]|null);
            photo_specs?: (POGOProtos.Rpc.InternalGetPhotosProto.IPhotoSpec[]|null);
        }

        class InternalGetPhotosProto implements IInternalGetPhotosProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetPhotosProto);
            public photo_ids: string[];
            public photo_specs: POGOProtos.Rpc.InternalGetPhotosProto.IPhotoSpec[];
            public static encode(message: POGOProtos.Rpc.IInternalGetPhotosProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetPhotosProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetPhotosProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetPhotosProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetPhotosProto {

            interface IPhotoSpec {
                photo_id?: (string|null);
                mode?: (POGOProtos.Rpc.InternalGetPhotosProto.PhotoSpec.GetPhotosMode|null);
            }

            class PhotoSpec implements IPhotoSpec {
                constructor(properties?: POGOProtos.Rpc.InternalGetPhotosProto.IPhotoSpec);
                public photo_id: string;
                public mode: POGOProtos.Rpc.InternalGetPhotosProto.PhotoSpec.GetPhotosMode;
                public static encode(message: POGOProtos.Rpc.InternalGetPhotosProto.IPhotoSpec, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetPhotosProto.PhotoSpec;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetPhotosProto.PhotoSpec;
                public static toObject(message: POGOProtos.Rpc.InternalGetPhotosProto.PhotoSpec, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PhotoSpec {

                enum GetPhotosMode {
                    ORIGINAL = 0,
                    SIZE_64 = 1,
                    SIZE_256 = 2,
                    SIZE_1080 = 3,
                    MIN_SIZE_64 = 4,
                    MIN_SIZE_256 = 5,
                    MIN_SIZE_1080 = 6
                }
            }
        }

        interface IInternalGetPlayerSettingsOutProto {
            result?: (POGOProtos.Rpc.InternalGetPlayerSettingsOutProto.Result|null);
            settings?: (POGOProtos.Rpc.IInternalPlayerSettingsProto|null);
        }

        class InternalGetPlayerSettingsOutProto implements IInternalGetPlayerSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetPlayerSettingsOutProto);
            public result: POGOProtos.Rpc.InternalGetPlayerSettingsOutProto.Result;
            public settings?: (POGOProtos.Rpc.IInternalPlayerSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalGetPlayerSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetPlayerSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetPlayerSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetPlayerSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetPlayerSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IInternalGetPlayerSettingsProto {
        }

        class InternalGetPlayerSettingsProto implements IInternalGetPlayerSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetPlayerSettingsProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetPlayerSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetPlayerSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetPlayerSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetPlayerSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetProfileRequest {
            player_id?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalGetProfileRequest implements IInternalGetProfileRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalGetProfileRequest);
            public player_id: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetProfileRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetProfileRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetProfileRequest;
            public static toObject(message: POGOProtos.Rpc.InternalGetProfileRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetProfileResponse {
            result?: (POGOProtos.Rpc.InternalGetProfileResponse.Result|null);
            profile_details?: (POGOProtos.Rpc.IInternalProfileDetailsProto|null);
            player_profile_details?: (POGOProtos.Rpc.InternalGetProfileResponse.IPlayerProfileDetailsProto[]|null);
        }

        class InternalGetProfileResponse implements IInternalGetProfileResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalGetProfileResponse);
            public result: POGOProtos.Rpc.InternalGetProfileResponse.Result;
            public profile_details?: (POGOProtos.Rpc.IInternalProfileDetailsProto|null);
            public player_profile_details: POGOProtos.Rpc.InternalGetProfileResponse.IPlayerProfileDetailsProto[];
            public static encode(message: POGOProtos.Rpc.IInternalGetProfileResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetProfileResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetProfileResponse;
            public static toObject(message: POGOProtos.Rpc.InternalGetProfileResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetProfileResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FRIEND = 3
            }

            interface IPlayerProfileDetailsProto {
                app_key?: (string|null);
                codename?: (string|null);
                faction?: (string|null);
                level?: (number|null);
                experience?: (number|Long|null);
                signed_up_timestamp_ms?: (number|Long|null);
                last_played_timestamp_ms?: (number|Long|null);
                player_total_walk_km?: (number|null);
                display_name?: (string|null);
            }

            class PlayerProfileDetailsProto implements IPlayerProfileDetailsProto {
                constructor(properties?: POGOProtos.Rpc.InternalGetProfileResponse.IPlayerProfileDetailsProto);
                public app_key: string;
                public codename: string;
                public faction: string;
                public level: number;
                public experience: (number|Long);
                public signed_up_timestamp_ms: (number|Long);
                public last_played_timestamp_ms: (number|Long);
                public player_total_walk_km: number;
                public display_name: string;
                public static encode(message: POGOProtos.Rpc.InternalGetProfileResponse.IPlayerProfileDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetProfileResponse.PlayerProfileDetailsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetProfileResponse.PlayerProfileDetailsProto;
                public static toObject(message: POGOProtos.Rpc.InternalGetProfileResponse.PlayerProfileDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalGetSignedUrlOutProto {
            result?: (POGOProtos.Rpc.InternalGetSignedUrlOutProto.Result|null);
            signed_url?: (string|null);
            photo_id?: (string|null);
        }

        class InternalGetSignedUrlOutProto implements IInternalGetSignedUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetSignedUrlOutProto);
            public result: POGOProtos.Rpc.InternalGetSignedUrlOutProto.Result;
            public signed_url: string;
            public photo_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetSignedUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetSignedUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetSignedUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetSignedUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetSignedUrlOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetSignedUrlProto {
        }

        class InternalGetSignedUrlProto implements IInternalGetSignedUrlProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetSignedUrlProto);
            public static encode(message: POGOProtos.Rpc.IInternalGetSignedUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetSignedUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetSignedUrlProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetSignedUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetUploadUrlOutProto {
            status?: (POGOProtos.Rpc.InternalGetUploadUrlOutProto.Status|null);
            signed_url?: (string|null);
            supporting_image_signed_url?: (string|null);
        }

        class InternalGetUploadUrlOutProto implements IInternalGetUploadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetUploadUrlOutProto);
            public status: POGOProtos.Rpc.InternalGetUploadUrlOutProto.Status;
            public signed_url: string;
            public supporting_image_signed_url: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetUploadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetUploadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetUploadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetUploadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetUploadUrlOutProto {

            enum Status {
                UNSET = 0,
                FAILURES = 1,
                SUCCESS = 2
            }
        }

        interface IInternalGetUploadUrlProto {
            user_id?: (string|null);
            game_unique_id?: (string|null);
        }

        class InternalGetUploadUrlProto implements IInternalGetUploadUrlProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetUploadUrlProto);
            public user_id: string;
            public game_unique_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetUploadUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetUploadUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetUploadUrlProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetUploadUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGetWebTokenActionOutProto {
            status?: (POGOProtos.Rpc.InternalGetWebTokenActionOutProto.Status|null);
            access_token?: (string|null);
        }

        class InternalGetWebTokenActionOutProto implements IInternalGetWebTokenActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetWebTokenActionOutProto);
            public status: POGOProtos.Rpc.InternalGetWebTokenActionOutProto.Status;
            public access_token: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetWebTokenActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetWebTokenActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetWebTokenActionOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetWebTokenActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalGetWebTokenActionOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalGetWebTokenActionProto {
            client_id?: (string|null);
        }

        class InternalGetWebTokenActionProto implements IInternalGetWebTokenActionProto {
            constructor(properties?: POGOProtos.Rpc.IInternalGetWebTokenActionProto);
            public client_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalGetWebTokenActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGetWebTokenActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGetWebTokenActionProto;
            public static toObject(message: POGOProtos.Rpc.InternalGetWebTokenActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGuestLoginAuthToken {
            secret?: (Uint8Array|null);
            api_key?: (string|null);
            device_id?: (string|null);
        }

        class InternalGuestLoginAuthToken implements IInternalGuestLoginAuthToken {
            constructor(properties?: POGOProtos.Rpc.IInternalGuestLoginAuthToken);
            public secret: Uint8Array;
            public api_key: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalGuestLoginAuthToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGuestLoginAuthToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGuestLoginAuthToken;
            public static toObject(message: POGOProtos.Rpc.InternalGuestLoginAuthToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalGuestLoginSecretToken {
            token_contents?: (Uint8Array|null);
            signature?: (Uint8Array|null);
            iv?: (Uint8Array|null);
        }

        class InternalGuestLoginSecretToken implements IInternalGuestLoginSecretToken {
            constructor(properties?: POGOProtos.Rpc.IInternalGuestLoginSecretToken);
            public token_contents: Uint8Array;
            public signature: Uint8Array;
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalGuestLoginSecretToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalGuestLoginSecretToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalGuestLoginSecretToken;
            public static toObject(message: POGOProtos.Rpc.InternalGuestLoginSecretToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalImageLogReportData {
            image_id?: (string|null);
            category?: (POGOProtos.Rpc.InternalFlagCategory.Category[]|null);
            reporter_name?: (string[]|null);
        }

        class InternalImageLogReportData implements IInternalImageLogReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalImageLogReportData);
            public image_id: string;
            public category: POGOProtos.Rpc.InternalFlagCategory.Category[];
            public reporter_name: string[];
            public static encode(message: POGOProtos.Rpc.IInternalImageLogReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalImageLogReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalImageLogReportData;
            public static toObject(message: POGOProtos.Rpc.InternalImageLogReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalImageModerationAttributes {
        }

        class InternalImageModerationAttributes implements IInternalImageModerationAttributes {
            constructor(properties?: POGOProtos.Rpc.IInternalImageModerationAttributes);
            public static encode(message: POGOProtos.Rpc.IInternalImageModerationAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalImageModerationAttributes;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalImageModerationAttributes;
            public static toObject(message: POGOProtos.Rpc.InternalImageModerationAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalImageModerationAttributes {

            enum DetectionLikelihood {
                UNKNOWN = 0,
                VERY_UNLIKELY = 1,
                UNLIKELY = 2,
                POSSIBLE = 3,
                LIKELY = 4,
                VERY_LIKELY = 5
            }
        }

        interface IInternalImageProfanityReportData {
            flag_category?: (POGOProtos.Rpc.InternalFlagCategory.Category[]|null);
            image_id?: (string|null);
            reporter_name?: (string[]|null);
            safer_ticket_id?: (string|null);
        }

        class InternalImageProfanityReportData implements IInternalImageProfanityReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalImageProfanityReportData);
            public flag_category: POGOProtos.Rpc.InternalFlagCategory.Category[];
            public image_id: string;
            public reporter_name: string[];
            public safer_ticket_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalImageProfanityReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalImageProfanityReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalImageProfanityReportData;
            public static toObject(message: POGOProtos.Rpc.InternalImageProfanityReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalInAppPurchaseBalanceProto {
            currency_type?: (string|null);
            purchased_balance?: (number|null);
            last_modified_timestamp_ms?: (number|Long|null);
            fiat_purchased_balance?: (number|null);
            fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
        }

        class InternalInAppPurchaseBalanceProto implements IInternalInAppPurchaseBalanceProto {
            constructor(properties?: POGOProtos.Rpc.IInternalInAppPurchaseBalanceProto);
            public currency_type: string;
            public purchased_balance: number;
            public last_modified_timestamp_ms: (number|Long);
            public fiat_purchased_balance: number;
            public fiat_currency_cost_e6_per_in_game_unit: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalInAppPurchaseBalanceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInAppPurchaseBalanceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInAppPurchaseBalanceProto;
            public static toObject(message: POGOProtos.Rpc.InternalInAppPurchaseBalanceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalIncomingFriendInviteDisplayProto {
            invite?: (POGOProtos.Rpc.IInternalIncomingFriendInviteProto|null);
            player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
        }

        class InternalIncomingFriendInviteDisplayProto implements IInternalIncomingFriendInviteDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IInternalIncomingFriendInviteDisplayProto);
            public invite?: (POGOProtos.Rpc.IInternalIncomingFriendInviteProto|null);
            public player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalIncomingFriendInviteDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIncomingFriendInviteDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIncomingFriendInviteDisplayProto;
            public static toObject(message: POGOProtos.Rpc.InternalIncomingFriendInviteDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalIncomingFriendInviteProto {
            status?: (POGOProtos.Rpc.InternalIncomingFriendInviteProto.Status|null);
            player_id?: (string|null);
            created_ms?: (number|Long|null);
            invitation_type?: (POGOProtos.Rpc.InternalInvitationType|null);
            full_name?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalIncomingFriendInviteProto implements IInternalIncomingFriendInviteProto {
            constructor(properties?: POGOProtos.Rpc.IInternalIncomingFriendInviteProto);
            public status: POGOProtos.Rpc.InternalIncomingFriendInviteProto.Status;
            public player_id: string;
            public created_ms: (number|Long);
            public invitation_type: POGOProtos.Rpc.InternalInvitationType;
            public full_name: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalIncomingFriendInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIncomingFriendInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIncomingFriendInviteProto;
            public static toObject(message: POGOProtos.Rpc.InternalIncomingFriendInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalIncomingFriendInviteProto {

            enum Status {
                UNSET = 0,
                PENDING = 1,
                DECLINED = 2,
                CANCELLED = 3
            }
        }

        interface IInternalInventoryDeltaProto {
            original_timestamp?: (number|Long|null);
            new_timestamp?: (number|Long|null);
            inventory_item?: (POGOProtos.Rpc.IInternalInventoryItemProto[]|null);
        }

        class InternalInventoryDeltaProto implements IInternalInventoryDeltaProto {
            constructor(properties?: POGOProtos.Rpc.IInternalInventoryDeltaProto);
            public original_timestamp: (number|Long);
            public new_timestamp: (number|Long);
            public inventory_item: POGOProtos.Rpc.IInternalInventoryItemProto[];
            public static encode(message: POGOProtos.Rpc.IInternalInventoryDeltaProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInventoryDeltaProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInventoryDeltaProto;
            public static toObject(message: POGOProtos.Rpc.InternalInventoryDeltaProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalInventoryItemProto {
            deleted_item_key?: (POGOProtos.Rpc.IHoloInventoryKeyProto|null);
            inventory_item_data?: (POGOProtos.Rpc.IHoloInventoryItemProto|null);
            modified_timestamp?: (number|Long|null);
        }

        class InternalInventoryItemProto implements IInternalInventoryItemProto {
            constructor(properties?: POGOProtos.Rpc.IInternalInventoryItemProto);
            public deleted_item_key?: (POGOProtos.Rpc.IHoloInventoryKeyProto|null);
            public inventory_item_data?: (POGOProtos.Rpc.IHoloInventoryItemProto|null);
            public modified_timestamp: (number|Long);
            public InventoryItem?: ("deleted_item_key"|"inventory_item_data");
            public static encode(message: POGOProtos.Rpc.IInternalInventoryItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInventoryItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInventoryItemProto;
            public static toObject(message: POGOProtos.Rpc.InternalInventoryItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalInventoryProto {
            inventory_item?: (POGOProtos.Rpc.IInternalInventoryItemProto[]|null);
            diff_inventory?: (POGOProtos.Rpc.InternalInventoryProto.IDiffInventoryProto|null);
            inventory_type?: (POGOProtos.Rpc.InternalInventoryProto.InventoryType|null);
        }

        class InternalInventoryProto implements IInternalInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IInternalInventoryProto);
            public inventory_item: POGOProtos.Rpc.IInternalInventoryItemProto[];
            public diff_inventory?: (POGOProtos.Rpc.InternalInventoryProto.IDiffInventoryProto|null);
            public inventory_type: POGOProtos.Rpc.InternalInventoryProto.InventoryType;
            public static encode(message: POGOProtos.Rpc.IInternalInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInventoryProto;
            public static toObject(message: POGOProtos.Rpc.InternalInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalInventoryProto {

            enum InventoryType {
                BINARY_BLOB = 0,
                DIFF = 1,
                COMPOSITE = 2
            }

            interface IDiffInventoryProto {
                item_changelog?: (POGOProtos.Rpc.IInternalInventoryItemProto[]|null);
                diff_inventory_entity_last_compaction_ms?: (number|Long|null);
            }

            class DiffInventoryProto implements IDiffInventoryProto {
                constructor(properties?: POGOProtos.Rpc.InternalInventoryProto.IDiffInventoryProto);
                public item_changelog: POGOProtos.Rpc.IInternalInventoryItemProto[];
                public diff_inventory_entity_last_compaction_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.InternalInventoryProto.IDiffInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInventoryProto.DiffInventoryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInventoryProto.DiffInventoryProto;
                public static toObject(message: POGOProtos.Rpc.InternalInventoryProto.DiffInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalInviteFacebookFriendOutProto {
            result?: (POGOProtos.Rpc.InternalInviteFacebookFriendOutProto.Result|null);
            new_friendship_formed?: (boolean|null);
        }

        class InternalInviteFacebookFriendOutProto implements IInternalInviteFacebookFriendOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalInviteFacebookFriendOutProto);
            public result: POGOProtos.Rpc.InternalInviteFacebookFriendOutProto.Result;
            public new_friendship_formed: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalInviteFacebookFriendOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInviteFacebookFriendOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInviteFacebookFriendOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalInviteFacebookFriendOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalInviteFacebookFriendOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3,
                ERROR_PLAYER_OUTBOX_FULL = 4,
                ERROR_PLAYER_INBOX_FULL = 5,
                ERROR_SENDER_HAS_MAX_FRIENDS = 6,
                ERROR_RECEIVER_HAS_MAX_FRIENDS = 7,
                ERROR_ALREADY_A_FRIEND = 8,
                ERROR_INVITE_ALREADY_SENT = 9,
                ERROR_INVITE_ALREADY_RECEIVED = 10,
                ERROR_CANNOT_SEND_INVITES_TO_YOURSELF = 11,
                ERROR_FRIEND_CACHE_EXPIRED = 12,
                ERROR_FRIEND_NOT_CACHED = 13,
                ERROR_INVALID_SENDER_FACEBOOK_ID = 14,
                ERROR_SEND_TO_BLOCKED_USER = 15
            }
        }

        interface IInternalInviteFacebookFriendProto {
            fb_access_token?: (string|null);
            friend_fb_user_id?: (string|null);
        }

        class InternalInviteFacebookFriendProto implements IInternalInviteFacebookFriendProto {
            constructor(properties?: POGOProtos.Rpc.IInternalInviteFacebookFriendProto);
            public fb_access_token: string;
            public friend_fb_user_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalInviteFacebookFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInviteFacebookFriendProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInviteFacebookFriendProto;
            public static toObject(message: POGOProtos.Rpc.InternalInviteFacebookFriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalInviteGameRequest {
            friend_id?: (string|null);
            friend_nia_account_id?: (string|null);
            app_key?: (string|null);
            referral?: (POGOProtos.Rpc.IInternalReferralProto|null);
        }

        class InternalInviteGameRequest implements IInternalInviteGameRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalInviteGameRequest);
            public friend_id: string;
            public friend_nia_account_id: string;
            public app_key: string;
            public referral?: (POGOProtos.Rpc.IInternalReferralProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalInviteGameRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInviteGameRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInviteGameRequest;
            public static toObject(message: POGOProtos.Rpc.InternalInviteGameRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalInviteGameResponse {
            status?: (POGOProtos.Rpc.InternalInviteGameResponse.Status|null);
        }

        class InternalInviteGameResponse implements IInternalInviteGameResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalInviteGameResponse);
            public status: POGOProtos.Rpc.InternalInviteGameResponse.Status;
            public static encode(message: POGOProtos.Rpc.IInternalInviteGameResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalInviteGameResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalInviteGameResponse;
            public static toObject(message: POGOProtos.Rpc.InternalInviteGameResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalInviteGameResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FRIEND = 3,
                ERROR_EXCEED_LIMIT = 4,
                ERROR_ALREADY_SIGNED_UP = 5,
                ERROR_EMAIL_FAILED = 6
            }
        }

        interface IInternalIosDevice {
            name?: (string|null);
            manufacturer?: (string|null);
            model?: (string|null);
            hardware?: (string|null);
            software?: (string|null);
        }

        class InternalIosDevice implements IInternalIosDevice {
            constructor(properties?: POGOProtos.Rpc.IInternalIosDevice);
            public name: string;
            public manufacturer: string;
            public model: string;
            public hardware: string;
            public software: string;
            public static encode(message: POGOProtos.Rpc.IInternalIosDevice, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIosDevice;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIosDevice;
            public static toObject(message: POGOProtos.Rpc.InternalIosDevice, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalIosSourceRevision {
            name?: (string|null);
            bundle?: (string|null);
            version?: (string|null);
            product?: (string|null);
            os?: (string|null);
        }

        class InternalIosSourceRevision implements IInternalIosSourceRevision {
            constructor(properties?: POGOProtos.Rpc.IInternalIosSourceRevision);
            public name: string;
            public bundle: string;
            public version: string;
            public product: string;
            public os: string;
            public static encode(message: POGOProtos.Rpc.IInternalIosSourceRevision, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIosSourceRevision;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIosSourceRevision;
            public static toObject(message: POGOProtos.Rpc.InternalIosSourceRevision, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalIsAccountBlockedOutProto {
            is_blocked?: (boolean|null);
        }

        class InternalIsAccountBlockedOutProto implements IInternalIsAccountBlockedOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalIsAccountBlockedOutProto);
            public is_blocked: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalIsAccountBlockedOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIsAccountBlockedOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIsAccountBlockedOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalIsAccountBlockedOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalIsAccountBlockedProto {
            blockee_nia_account_id?: (string|null);
        }

        class InternalIsAccountBlockedProto implements IInternalIsAccountBlockedProto {
            constructor(properties?: POGOProtos.Rpc.IInternalIsAccountBlockedProto);
            public blockee_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalIsAccountBlockedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIsAccountBlockedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIsAccountBlockedProto;
            public static toObject(message: POGOProtos.Rpc.InternalIsAccountBlockedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalIsMyFriendOutProto {
            result?: (POGOProtos.Rpc.InternalIsMyFriendOutProto.Result|null);
            is_friend?: (boolean|null);
        }

        class InternalIsMyFriendOutProto implements IInternalIsMyFriendOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalIsMyFriendOutProto);
            public result: POGOProtos.Rpc.InternalIsMyFriendOutProto.Result;
            public is_friend: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalIsMyFriendOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIsMyFriendOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIsMyFriendOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalIsMyFriendOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalIsMyFriendOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND_DELETED = 3
            }
        }

        interface IInternalIsMyFriendProto {
            player_id?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalIsMyFriendProto implements IInternalIsMyFriendProto {
            constructor(properties?: POGOProtos.Rpc.IInternalIsMyFriendProto);
            public player_id: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalIsMyFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalIsMyFriendProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalIsMyFriendProto;
            public static toObject(message: POGOProtos.Rpc.InternalIsMyFriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalItemProto {
            text?: (string|null);
            image_url?: (string|null);
            video_url?: (string|null);
            text_language?: (POGOProtos.Rpc.IInternalLanguageData|null);
            item_status?: (POGOProtos.Rpc.InternalItemProto.ItemStatus|null);
            image_csam_violation?: (boolean|null);
            flag_category?: (POGOProtos.Rpc.InternalFlagCategory.Category[]|null);
            reporter_name?: (string[]|null);
            moderation_eligible?: (boolean|null);
        }

        class InternalItemProto implements IInternalItemProto {
            constructor(properties?: POGOProtos.Rpc.IInternalItemProto);
            public text?: (string|null);
            public image_url?: (string|null);
            public video_url?: (string|null);
            public text_language?: (POGOProtos.Rpc.IInternalLanguageData|null);
            public item_status: POGOProtos.Rpc.InternalItemProto.ItemStatus;
            public image_csam_violation: boolean;
            public flag_category: POGOProtos.Rpc.InternalFlagCategory.Category[];
            public reporter_name: string[];
            public moderation_eligible: boolean;
            public Data?: ("text"|"image_url"|"video_url");
            public static encode(message: POGOProtos.Rpc.IInternalItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalItemProto;
            public static toObject(message: POGOProtos.Rpc.InternalItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalItemProto {

            enum ItemStatus {
                UNSET = 0,
                ALLOW = 1,
                REJECT = 2,
                PENDING = 3
            }
        }

        interface IInternalLanguageData {
            code?: (string|null);
            name?: (string|null);
        }

        class InternalLanguageData implements IInternalLanguageData {
            constructor(properties?: POGOProtos.Rpc.IInternalLanguageData);
            public code: string;
            public name: string;
            public static encode(message: POGOProtos.Rpc.IInternalLanguageData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLanguageData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLanguageData;
            public static toObject(message: POGOProtos.Rpc.InternalLanguageData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalLegalHold {
            legal_hold_value?: (boolean|null);
            starting_timestamp_ms?: (number|Long|null);
            ending_timestamp_ms?: (number|Long|null);
            reason?: (string|null);
        }

        class InternalLegalHold implements IInternalLegalHold {
            constructor(properties?: POGOProtos.Rpc.IInternalLegalHold);
            public legal_hold_value: boolean;
            public starting_timestamp_ms: (number|Long);
            public ending_timestamp_ms: (number|Long);
            public reason: string;
            public static encode(message: POGOProtos.Rpc.IInternalLegalHold, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLegalHold;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLegalHold;
            public static toObject(message: POGOProtos.Rpc.InternalLegalHold, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalLinkToAccountLoginRequestProto {
            new_auth_token?: (Uint8Array|null);
            new_auth_provider_id?: (string|null);
        }

        class InternalLinkToAccountLoginRequestProto implements IInternalLinkToAccountLoginRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalLinkToAccountLoginRequestProto);
            public new_auth_token: Uint8Array;
            public new_auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalLinkToAccountLoginRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLinkToAccountLoginRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLinkToAccountLoginRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalLinkToAccountLoginRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalLinkToAccountLoginResponseProto {
            success?: (boolean|null);
            status?: (POGOProtos.Rpc.InternalLinkToAccountLoginResponseProto.Status|null);
        }

        class InternalLinkToAccountLoginResponseProto implements IInternalLinkToAccountLoginResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalLinkToAccountLoginResponseProto);
            public success: boolean;
            public status: POGOProtos.Rpc.InternalLinkToAccountLoginResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalLinkToAccountLoginResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLinkToAccountLoginResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLinkToAccountLoginResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalLinkToAccountLoginResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalLinkToAccountLoginResponseProto {

            enum Status {
                UNSET = 0,
                UNKNOWN_ERROR = 1,
                AUTH_FAILURE = 2,
                LOGIN_TAKEN = 3,
                GUEST_LOGIN_DISABLED = 4,
                SUCCESS_ALREADY_LINKED = 5
            }
        }

        interface IInternalListFriendsRequest {
            feature?: (POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.FeatureType|null);
            list_option?: (POGOProtos.Rpc.InternalSocialSettings.ListOption|null);
        }

        class InternalListFriendsRequest implements IInternalListFriendsRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalListFriendsRequest);
            public feature: POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.FeatureType;
            public list_option: POGOProtos.Rpc.InternalSocialSettings.ListOption;
            public static encode(message: POGOProtos.Rpc.IInternalListFriendsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListFriendsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListFriendsRequest;
            public static toObject(message: POGOProtos.Rpc.InternalListFriendsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalListFriendsResponse {
            result?: (POGOProtos.Rpc.InternalListFriendsResponse.Result|null);
            friend_summary?: (POGOProtos.Rpc.InternalListFriendsResponse.IFriendSummaryProto[]|null);
        }

        class InternalListFriendsResponse implements IInternalListFriendsResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalListFriendsResponse);
            public result: POGOProtos.Rpc.InternalListFriendsResponse.Result;
            public friend_summary: POGOProtos.Rpc.InternalListFriendsResponse.IFriendSummaryProto[];
            public static encode(message: POGOProtos.Rpc.IInternalListFriendsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListFriendsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListFriendsResponse;
            public static toObject(message: POGOProtos.Rpc.InternalListFriendsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalListFriendsResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FEATURE_DISABLED = 3
            }

            interface IFriendSummaryProto {
                player_id?: (string|null);
                is_calling_app_friend?: (boolean|null);
                calling_game_data?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.IFriendProto|null);
                profile?: (POGOProtos.Rpc.InternalListFriendsResponse.IProfileSummaryProto|null);
                player_status?: (POGOProtos.Rpc.InternalListFriendsResponse.IPlayerStatusSummaryProto|null);
                invitation_status?: (POGOProtos.Rpc.InternalSocialV2Enum.InvitationStatus|null);
                nia_account_id?: (string|null);
                gar_account_info?: (POGOProtos.Rpc.IInternalGarAccountInfoProto|null);
            }

            class FriendSummaryProto implements IFriendSummaryProto {
                constructor(properties?: POGOProtos.Rpc.InternalListFriendsResponse.IFriendSummaryProto);
                public player_id: string;
                public is_calling_app_friend: boolean;
                public calling_game_data?: (POGOProtos.Rpc.InternalGetFriendsListOutProto.IFriendProto|null);
                public profile?: (POGOProtos.Rpc.InternalListFriendsResponse.IProfileSummaryProto|null);
                public player_status?: (POGOProtos.Rpc.InternalListFriendsResponse.IPlayerStatusSummaryProto|null);
                public invitation_status: POGOProtos.Rpc.InternalSocialV2Enum.InvitationStatus;
                public nia_account_id: string;
                public gar_account_info?: (POGOProtos.Rpc.IInternalGarAccountInfoProto|null);
                public static encode(message: POGOProtos.Rpc.InternalListFriendsResponse.IFriendSummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListFriendsResponse.FriendSummaryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListFriendsResponse.FriendSummaryProto;
                public static toObject(message: POGOProtos.Rpc.InternalListFriendsResponse.FriendSummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerStatusSummaryProto {
                result?: (POGOProtos.Rpc.InternalListFriendsResponse.PlayerStatusSummaryProto.PlayerStatusResult|null);
                online_status?: (POGOProtos.Rpc.InternalSocialV2Enum.OnlineStatus|null);
                last_played_app_key?: (string|null);
            }

            class PlayerStatusSummaryProto implements IPlayerStatusSummaryProto {
                constructor(properties?: POGOProtos.Rpc.InternalListFriendsResponse.IPlayerStatusSummaryProto);
                public result: POGOProtos.Rpc.InternalListFriendsResponse.PlayerStatusSummaryProto.PlayerStatusResult;
                public online_status: POGOProtos.Rpc.InternalSocialV2Enum.OnlineStatus;
                public last_played_app_key: string;
                public static encode(message: POGOProtos.Rpc.InternalListFriendsResponse.IPlayerStatusSummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListFriendsResponse.PlayerStatusSummaryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListFriendsResponse.PlayerStatusSummaryProto;
                public static toObject(message: POGOProtos.Rpc.InternalListFriendsResponse.PlayerStatusSummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PlayerStatusSummaryProto {

                enum PlayerStatusResult {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_UNKNOWN = 2,
                    ERROR_STATUS_UNKNOWN = 3,
                    ERROR_STALE_DATA = 4
                }
            }

            interface IProfileSummaryProto {
                name?: (string|null);
                nickname?: (string|null);
            }

            class ProfileSummaryProto implements IProfileSummaryProto {
                constructor(properties?: POGOProtos.Rpc.InternalListFriendsResponse.IProfileSummaryProto);
                public name: string;
                public nickname: string;
                public static encode(message: POGOProtos.Rpc.InternalListFriendsResponse.IProfileSummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListFriendsResponse.ProfileSummaryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListFriendsResponse.ProfileSummaryProto;
                public static toObject(message: POGOProtos.Rpc.InternalListFriendsResponse.ProfileSummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalListLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.IInternalLoginDetail[]|null);
        }

        class InternalListLoginActionOutProto implements IInternalListLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalListLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.IInternalLoginDetail[];
            public static encode(message: POGOProtos.Rpc.IInternalListLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalListLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalListOptOutNotificationCategoriesRequestProto {
        }

        class InternalListOptOutNotificationCategoriesRequestProto implements IInternalListOptOutNotificationCategoriesRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesRequestProto);
            public static encode(message: POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListOptOutNotificationCategoriesRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListOptOutNotificationCategoriesRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalListOptOutNotificationCategoriesRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalListOptOutNotificationCategoriesResponseProto {
            result?: (POGOProtos.Rpc.InternalListOptOutNotificationCategoriesResponseProto.Result|null);
        }

        class InternalListOptOutNotificationCategoriesResponseProto implements IInternalListOptOutNotificationCategoriesResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesResponseProto);
            public result: POGOProtos.Rpc.InternalListOptOutNotificationCategoriesResponseProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalListOptOutNotificationCategoriesResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalListOptOutNotificationCategoriesResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalListOptOutNotificationCategoriesResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalListOptOutNotificationCategoriesResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalListOptOutNotificationCategoriesResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IInternalLocationPingOutProto {
        }

        class InternalLocationPingOutProto implements IInternalLocationPingOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalLocationPingOutProto);
            public static encode(message: POGOProtos.Rpc.IInternalLocationPingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLocationPingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLocationPingOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalLocationPingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalLocationPingProto {
            geofence_identifier?: (string|null);
        }

        class InternalLocationPingProto implements IInternalLocationPingProto {
            constructor(properties?: POGOProtos.Rpc.IInternalLocationPingProto);
            public geofence_identifier: string;
            public static encode(message: POGOProtos.Rpc.IInternalLocationPingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLocationPingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLocationPingProto;
            public static toObject(message: POGOProtos.Rpc.InternalLocationPingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalLocationPingProto {

            enum PingReason {
                UNSET = 0,
                ENTRANCE_EVENT = 1,
                EXIT_EVENT = 2,
                DWELL_EVENT = 3,
                VISIT_EVENT = 4,
                FITNESS_WAKEUP = 5,
                OTHER_WAKEUP = 6
            }
        }

        interface IInternalLocationPingUpdateProto {
            geofence_identifier?: (string|null);
            reason?: (POGOProtos.Rpc.InternalLocationPingUpdateProto.PingReason|null);
            timestamp_ms?: (number|Long|null);
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
            app_is_foregrounded?: (boolean|null);
            time_zone?: (string|null);
            time_zone_offset_min?: (number|null);
            accuracy_m?: (number|null);
        }

        class InternalLocationPingUpdateProto implements IInternalLocationPingUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IInternalLocationPingUpdateProto);
            public geofence_identifier: string;
            public reason: POGOProtos.Rpc.InternalLocationPingUpdateProto.PingReason;
            public timestamp_ms: (number|Long);
            public latitude_deg: number;
            public longitude_deg: number;
            public app_is_foregrounded: boolean;
            public time_zone: string;
            public time_zone_offset_min: number;
            public accuracy_m: number;
            public static encode(message: POGOProtos.Rpc.IInternalLocationPingUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLocationPingUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLocationPingUpdateProto;
            public static toObject(message: POGOProtos.Rpc.InternalLocationPingUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalLocationPingUpdateProto {

            enum PingReason {
                UNSET = 0,
                ENTRANCE_EVENT = 1,
                EXIT_EVENT = 2,
                DWELL_EVENT = 3,
                VISIT_EVENT = 4,
                FITNESS_WAKEUP = 5,
                OTHER_WAKEUP = 6
            }
        }

        interface IInternalLogReportData {
            text_content?: (POGOProtos.Rpc.IInternalMessageLogReportData|null);
            image_content?: (POGOProtos.Rpc.IInternalImageLogReportData|null);
        }

        class InternalLogReportData implements IInternalLogReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalLogReportData);
            public text_content?: (POGOProtos.Rpc.IInternalMessageLogReportData|null);
            public image_content?: (POGOProtos.Rpc.IInternalImageLogReportData|null);
            public ContentType?: ("text_content"|"image_content");
            public static encode(message: POGOProtos.Rpc.IInternalLogReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLogReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLogReportData;
            public static toObject(message: POGOProtos.Rpc.InternalLogReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalLoginDetail {
            identity_provider?: (POGOProtos.Rpc.InternalIdentityProvider|null);
            email?: (string|null);
            auth_provider_id?: (string|null);
            third_party_username?: (string|null);
        }

        class InternalLoginDetail implements IInternalLoginDetail {
            constructor(properties?: POGOProtos.Rpc.IInternalLoginDetail);
            public identity_provider: POGOProtos.Rpc.InternalIdentityProvider;
            public email: string;
            public auth_provider_id: string;
            public third_party_username: string;
            public static encode(message: POGOProtos.Rpc.IInternalLoginDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalLoginDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalLoginDetail;
            public static toObject(message: POGOProtos.Rpc.InternalLoginDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalManualReportData {
            description?: (string|null);
            link?: (string|null);
            origin?: (POGOProtos.Rpc.InternalReportAttributeData.Origin|null);
            severity?: (POGOProtos.Rpc.InternalReportAttributeData.Severity|null);
            category?: (POGOProtos.Rpc.InternalFlagCategory.Category|null);
        }

        class InternalManualReportData implements IInternalManualReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalManualReportData);
            public description: string;
            public link: string;
            public origin: POGOProtos.Rpc.InternalReportAttributeData.Origin;
            public severity: POGOProtos.Rpc.InternalReportAttributeData.Severity;
            public category: POGOProtos.Rpc.InternalFlagCategory.Category;
            public static encode(message: POGOProtos.Rpc.IInternalManualReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalManualReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalManualReportData;
            public static toObject(message: POGOProtos.Rpc.InternalManualReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMarketingTelemetry {
            newsfeed_event?: (POGOProtos.Rpc.IMarketingTelemetryNewsfeedEvent|null);
            push_notification_event?: (POGOProtos.Rpc.IMarketingTelemetryPushNotificationEvent|null);
            metadata?: (POGOProtos.Rpc.IInternalMarketingTelemetryMetadata|null);
            server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
        }

        class InternalMarketingTelemetry implements IInternalMarketingTelemetry {
            constructor(properties?: POGOProtos.Rpc.IInternalMarketingTelemetry);
            public newsfeed_event?: (POGOProtos.Rpc.IMarketingTelemetryNewsfeedEvent|null);
            public push_notification_event?: (POGOProtos.Rpc.IMarketingTelemetryPushNotificationEvent|null);
            public metadata?: (POGOProtos.Rpc.IInternalMarketingTelemetryMetadata|null);
            public server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            public common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
            public Event?: ("newsfeed_event"|"push_notification_event");
            public static encode(message: POGOProtos.Rpc.IInternalMarketingTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMarketingTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMarketingTelemetry;
            public static toObject(message: POGOProtos.Rpc.InternalMarketingTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMarketingTelemetryMetadata {
            common_metadata?: (POGOProtos.Rpc.ICommonMarketingTelemetryMetadata|null);
            user_id?: (string|null);
        }

        class InternalMarketingTelemetryMetadata implements IInternalMarketingTelemetryMetadata {
            constructor(properties?: POGOProtos.Rpc.IInternalMarketingTelemetryMetadata);
            public common_metadata?: (POGOProtos.Rpc.ICommonMarketingTelemetryMetadata|null);
            public user_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalMarketingTelemetryMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMarketingTelemetryMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMarketingTelemetryMetadata;
            public static toObject(message: POGOProtos.Rpc.InternalMarketingTelemetryMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMarketingTelemetryWrapper {
            internal_marketing_telemetry?: (POGOProtos.Rpc.IInternalMarketingTelemetry|null);
        }

        class InternalMarketingTelemetryWrapper implements IInternalMarketingTelemetryWrapper {
            constructor(properties?: POGOProtos.Rpc.IInternalMarketingTelemetryWrapper);
            public internal_marketing_telemetry?: (POGOProtos.Rpc.IInternalMarketingTelemetry|null);
            public static encode(message: POGOProtos.Rpc.IInternalMarketingTelemetryWrapper, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMarketingTelemetryWrapper;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMarketingTelemetryWrapper;
            public static toObject(message: POGOProtos.Rpc.InternalMarketingTelemetryWrapper, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMessageFlag {
            text?: (string|null);
            image_id?: (string|null);
            channel_url?: (string|null);
            message_id?: (number|Long|null);
            flag_category?: (POGOProtos.Rpc.InternalFlagCategory.Category|null);
        }

        class InternalMessageFlag implements IInternalMessageFlag {
            constructor(properties?: POGOProtos.Rpc.IInternalMessageFlag);
            public text?: (string|null);
            public image_id?: (string|null);
            public channel_url: string;
            public message_id: (number|Long);
            public flag_category: POGOProtos.Rpc.InternalFlagCategory.Category;
            public Content?: ("text"|"image_id");
            public static encode(message: POGOProtos.Rpc.IInternalMessageFlag, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMessageFlag;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMessageFlag;
            public static toObject(message: POGOProtos.Rpc.InternalMessageFlag, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMessageFlags {
            flag?: (POGOProtos.Rpc.IInternalMessageFlag|null);
            flagger_player_id?: (string|null);
        }

        class InternalMessageFlags implements IInternalMessageFlags {
            constructor(properties?: POGOProtos.Rpc.IInternalMessageFlags);
            public flag?: (POGOProtos.Rpc.IInternalMessageFlag|null);
            public flagger_player_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalMessageFlags, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMessageFlags;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMessageFlags;
            public static toObject(message: POGOProtos.Rpc.InternalMessageFlags, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMessageLogReportData {
            message?: (string|null);
            language_code?: (string|null);
            category?: (POGOProtos.Rpc.InternalFlagCategory.Category[]|null);
        }

        class InternalMessageLogReportData implements IInternalMessageLogReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalMessageLogReportData);
            public message: string;
            public language_code: string;
            public category: POGOProtos.Rpc.InternalFlagCategory.Category[];
            public static encode(message: POGOProtos.Rpc.IInternalMessageLogReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMessageLogReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMessageLogReportData;
            public static toObject(message: POGOProtos.Rpc.InternalMessageLogReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalMessageProfanityReportData {
            reported_message?: (string|null);
            language_code?: (string|null);
            category?: (POGOProtos.Rpc.InternalFlagCategory.Category[]|null);
        }

        class InternalMessageProfanityReportData implements IInternalMessageProfanityReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalMessageProfanityReportData);
            public reported_message: string;
            public language_code: string;
            public category: POGOProtos.Rpc.InternalFlagCategory.Category[];
            public static encode(message: POGOProtos.Rpc.IInternalMessageProfanityReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalMessageProfanityReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalMessageProfanityReportData;
            public static toObject(message: POGOProtos.Rpc.InternalMessageProfanityReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalNianticPublicSharedLoginTokenSettings {
            app_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IAppSettings[]|null);
            client_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IClientSettings|null);
        }

        class InternalNianticPublicSharedLoginTokenSettings implements IInternalNianticPublicSharedLoginTokenSettings {
            constructor(properties?: POGOProtos.Rpc.IInternalNianticPublicSharedLoginTokenSettings);
            public app_settings: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IAppSettings[];
            public client_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IClientSettings|null);
            public static encode(message: POGOProtos.Rpc.IInternalNianticPublicSharedLoginTokenSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings;
            public static toObject(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalNianticPublicSharedLoginTokenSettings {

            interface IAppSettings {
                app_key?: (string|null);
                token_producer_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenProducerSettings|null);
                token_consumer_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenConsumerSettings|null);
            }

            class AppSettings implements IAppSettings {
                constructor(properties?: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IAppSettings);
                public app_key: string;
                public token_producer_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenProducerSettings|null);
                public token_consumer_settings?: (POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenConsumerSettings|null);
                public static encode(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IAppSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings;
                public static toObject(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AppSettings {

                interface ITokenConsumerSettings {
                    enabled?: (boolean|null);
                    allow_originating_auth_provider_id?: (string[]|null);
                    allow_originating_app_key?: (string[]|null);
                }

                class TokenConsumerSettings implements ITokenConsumerSettings {
                    constructor(properties?: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenConsumerSettings);
                    public enabled: boolean;
                    public allow_originating_auth_provider_id: string[];
                    public allow_originating_app_key: string[];
                    public static encode(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenConsumerSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.TokenConsumerSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.TokenConsumerSettings;
                    public static toObject(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.TokenConsumerSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ITokenProducerSettings {
                    enabled?: (boolean|null);
                    allow_auth_provider_id?: (string[]|null);
                }

                class TokenProducerSettings implements ITokenProducerSettings {
                    constructor(properties?: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenProducerSettings);
                    public enabled: boolean;
                    public allow_auth_provider_id: string[];
                    public static encode(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.ITokenProducerSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.TokenProducerSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.TokenProducerSettings;
                    public static toObject(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.AppSettings.TokenProducerSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IClientSettings {
                android_provider_id?: (string[]|null);
            }

            class ClientSettings implements IClientSettings {
                constructor(properties?: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IClientSettings);
                public android_provider_id: string[];
                public static encode(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.IClientSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.ClientSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.ClientSettings;
                public static toObject(message: POGOProtos.Rpc.InternalNianticPublicSharedLoginTokenSettings.ClientSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalNotifyContactListFriendsRequest {
            notify_timestamp_ms?: (number|Long|null);
        }

        class InternalNotifyContactListFriendsRequest implements IInternalNotifyContactListFriendsRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalNotifyContactListFriendsRequest);
            public notify_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalNotifyContactListFriendsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNotifyContactListFriendsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNotifyContactListFriendsRequest;
            public static toObject(message: POGOProtos.Rpc.InternalNotifyContactListFriendsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalNotifyContactListFriendsResponse {
            result?: (POGOProtos.Rpc.InternalNotifyContactListFriendsResponse.Result|null);
        }

        class InternalNotifyContactListFriendsResponse implements IInternalNotifyContactListFriendsResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalNotifyContactListFriendsResponse);
            public result: POGOProtos.Rpc.InternalNotifyContactListFriendsResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalNotifyContactListFriendsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalNotifyContactListFriendsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalNotifyContactListFriendsResponse;
            public static toObject(message: POGOProtos.Rpc.InternalNotifyContactListFriendsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalNotifyContactListFriendsResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ALREADY_SENT = 3
            }
        }

        interface IInternalOfferRecord {
            offer_id?: (string|null);
            purchase_time_ms?: ((number|Long)[]|null);
            total_purchases?: (number|null);
            associated_sku_id?: (string[]|null);
        }

        class InternalOfferRecord implements IInternalOfferRecord {
            constructor(properties?: POGOProtos.Rpc.IInternalOfferRecord);
            public offer_id: string;
            public purchase_time_ms: (number|Long)[];
            public total_purchases: number;
            public associated_sku_id: string[];
            public static encode(message: POGOProtos.Rpc.IInternalOfferRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalOfferRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalOfferRecord;
            public static toObject(message: POGOProtos.Rpc.InternalOfferRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalOptOutProto {
            categories?: (string[]|null);
        }

        class InternalOptOutProto implements IInternalOptOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalOptOutProto);
            public categories: string[];
            public static encode(message: POGOProtos.Rpc.IInternalOptOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalOptOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalOptOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalOptOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalOutgoingFriendInviteDisplayProto {
            invite?: (POGOProtos.Rpc.IInternalOutgoingFriendInviteProto|null);
            player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
        }

        class InternalOutgoingFriendInviteDisplayProto implements IInternalOutgoingFriendInviteDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IInternalOutgoingFriendInviteDisplayProto);
            public invite?: (POGOProtos.Rpc.IInternalOutgoingFriendInviteProto|null);
            public player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalOutgoingFriendInviteDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalOutgoingFriendInviteDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalOutgoingFriendInviteDisplayProto;
            public static toObject(message: POGOProtos.Rpc.InternalOutgoingFriendInviteDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalOutgoingFriendInviteProto {
            status?: (POGOProtos.Rpc.InternalOutgoingFriendInviteProto.Status|null);
            player_id?: (string|null);
            created_ms?: (number|Long|null);
            invitation_type?: (POGOProtos.Rpc.InternalInvitationType|null);
            full_name?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalOutgoingFriendInviteProto implements IInternalOutgoingFriendInviteProto {
            constructor(properties?: POGOProtos.Rpc.IInternalOutgoingFriendInviteProto);
            public status: POGOProtos.Rpc.InternalOutgoingFriendInviteProto.Status;
            public player_id: string;
            public created_ms: (number|Long);
            public invitation_type: POGOProtos.Rpc.InternalInvitationType;
            public full_name: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalOutgoingFriendInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalOutgoingFriendInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalOutgoingFriendInviteProto;
            public static toObject(message: POGOProtos.Rpc.InternalOutgoingFriendInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalOutgoingFriendInviteProto {

            enum Status {
                UNSET = 0,
                PENDING = 1,
                CANCELLED = 2,
                DECLINED = 3
            }
        }

        interface IInternalPhoneNumberCountryProto {
            english_name?: (string|null);
            localized_name?: (string|null);
            country_code?: (string|null);
            calling_code?: (string|null);
        }

        class InternalPhoneNumberCountryProto implements IInternalPhoneNumberCountryProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPhoneNumberCountryProto);
            public english_name: string;
            public localized_name: string;
            public country_code: string;
            public calling_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalPhoneNumberCountryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPhoneNumberCountryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPhoneNumberCountryProto;
            public static toObject(message: POGOProtos.Rpc.InternalPhoneNumberCountryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPhotoRecord {
            creation_time_ms?: (number|Long|null);
            transient_photo_url?: (string|null);
            photo_id?: (string|null);
            status?: (POGOProtos.Rpc.InternalPhotoRecord.Status|null);
        }

        class InternalPhotoRecord implements IInternalPhotoRecord {
            constructor(properties?: POGOProtos.Rpc.IInternalPhotoRecord);
            public creation_time_ms: (number|Long);
            public transient_photo_url: string;
            public photo_id: string;
            public status: POGOProtos.Rpc.InternalPhotoRecord.Status;
            public static encode(message: POGOProtos.Rpc.IInternalPhotoRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPhotoRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPhotoRecord;
            public static toObject(message: POGOProtos.Rpc.InternalPhotoRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalPhotoRecord {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                PHOTO_FLAGGED = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface IInternalPingRequestProto {
            response_size_bytes?: (number|null);
            random_request_bytes?: (string|null);
            use_cache_for_random_request_bytes?: (boolean|null);
            return_value?: (string|null);
        }

        class InternalPingRequestProto implements IInternalPingRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPingRequestProto);
            public response_size_bytes: number;
            public random_request_bytes: string;
            public use_cache_for_random_request_bytes: boolean;
            public return_value: string;
            public static encode(message: POGOProtos.Rpc.IInternalPingRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPingRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPingRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalPingRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPingResponseProto {
            user_info?: (string|null);
            server_info?: (string|null);
            random_response_bytes?: (string|null);
            return_value?: (string|null);
        }

        class InternalPingResponseProto implements IInternalPingResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPingResponseProto);
            public user_info: string;
            public server_info: string;
            public random_response_bytes: string;
            public return_value: string;
            public static encode(message: POGOProtos.Rpc.IInternalPingResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPingResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPingResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalPingResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPlatformCommonFilterProto {
            application_identifier?: (string|null);
            operating_system_name?: (string|null);
            device_model?: (string|null);
            locale_country_code?: (string|null);
            locale_language_code?: (string|null);
            sampling_probability?: (number|null);
            quality_level?: (string|null);
            network_connectivity_type?: (string|null);
            game_context?: (string|null);
            language_code?: (string|null);
            timezone?: (string|null);
            ip_country_code?: (string|null);
            client_version?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
        }

        class InternalPlatformCommonFilterProto implements IInternalPlatformCommonFilterProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPlatformCommonFilterProto);
            public application_identifier: string;
            public operating_system_name: string;
            public device_model: string;
            public locale_country_code: string;
            public locale_language_code: string;
            public sampling_probability: number;
            public quality_level: string;
            public network_connectivity_type: string;
            public game_context: string;
            public language_code: string;
            public timezone: string;
            public ip_country_code: string;
            public client_version: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public static encode(message: POGOProtos.Rpc.IInternalPlatformCommonFilterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlatformCommonFilterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlatformCommonFilterProto;
            public static toObject(message: POGOProtos.Rpc.InternalPlatformCommonFilterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPlatformPlayerLocaleProto {
            country?: (string|null);
            language?: (string|null);
            timezone?: (string|null);
        }

        class InternalPlatformPlayerLocaleProto implements IInternalPlatformPlayerLocaleProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPlatformPlayerLocaleProto);
            public country: string;
            public language: string;
            public timezone: string;
            public static encode(message: POGOProtos.Rpc.IInternalPlatformPlayerLocaleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlatformPlayerLocaleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlatformPlayerLocaleProto;
            public static toObject(message: POGOProtos.Rpc.InternalPlatformPlayerLocaleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPlatformServerData {
            user_id?: (string|null);
            telemetry_id?: (string|null);
            session_id?: (string|null);
            experiment_ids?: (number[]|null);
            event_request_id?: (string|null);
            server_timestamp_ms?: (number|Long|null);
        }

        class InternalPlatformServerData implements IInternalPlatformServerData {
            constructor(properties?: POGOProtos.Rpc.IInternalPlatformServerData);
            public user_id: string;
            public telemetry_id: string;
            public session_id: string;
            public experiment_ids: number[];
            public event_request_id: string;
            public server_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalPlatformServerData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlatformServerData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlatformServerData;
            public static toObject(message: POGOProtos.Rpc.InternalPlatformServerData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPlayerReputationProto {
            account_age_ms?: (number|Long|null);
            player_level?: (number|Long|null);
            cheat_reputation?: (POGOProtos.Rpc.InternalPlayerReputationProto.CheatReputation[]|null);
            is_minor?: (boolean|null);
        }

        class InternalPlayerReputationProto implements IInternalPlayerReputationProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPlayerReputationProto);
            public account_age_ms: (number|Long);
            public player_level: (number|Long);
            public cheat_reputation: POGOProtos.Rpc.InternalPlayerReputationProto.CheatReputation[];
            public is_minor: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalPlayerReputationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlayerReputationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlayerReputationProto;
            public static toObject(message: POGOProtos.Rpc.InternalPlayerReputationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalPlayerReputationProto {

            enum CheatReputation {
                UNSET = 0,
                BOT = 1,
                SPOOFER = 2
            }
        }

        interface IInternalPlayerSettingsProto {
            opt_out_online_status?: (boolean|null);
            completed_tutorials?: (POGOProtos.Rpc.InternalSocialSettings.TutorialType[]|null);
        }

        class InternalPlayerSettingsProto implements IInternalPlayerSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPlayerSettingsProto);
            public opt_out_online_status: boolean;
            public completed_tutorials: POGOProtos.Rpc.InternalSocialSettings.TutorialType[];
            public static encode(message: POGOProtos.Rpc.IInternalPlayerSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlayerSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlayerSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalPlayerSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPlayerStatus {
        }

        class InternalPlayerStatus implements IInternalPlayerStatus {
            constructor(properties?: POGOProtos.Rpc.IInternalPlayerStatus);
            public static encode(message: POGOProtos.Rpc.IInternalPlayerStatus, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlayerStatus;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlayerStatus;
            public static toObject(message: POGOProtos.Rpc.InternalPlayerStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalPlayerStatus {

            enum Status {
                UNDEFINED_STATUS = 0,
                ACTIVE = 1,
                WARNED = 100,
                WARNED_TWICE = 101,
                SUSPENDED = 200,
                SUSPENDED_TWICE = 201,
                BANNED = 300
            }
        }

        interface IInternalPlayerSummaryProto {
            player_id?: (string|null);
            codename?: (string|null);
            public_data?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            team?: (string|null);
            fb_user_id?: (string|null);
            level?: (number|null);
            experience?: (number|Long|null);
            nia_account_id?: (string|null);
            display_name?: (string|null);
        }

        class InternalPlayerSummaryProto implements IInternalPlayerSummaryProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPlayerSummaryProto);
            public player_id: string;
            public codename: string;
            public public_data?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public team: string;
            public fb_user_id: string;
            public level: number;
            public experience: (number|Long);
            public nia_account_id: string;
            public display_name: string;
            public static encode(message: POGOProtos.Rpc.IInternalPlayerSummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPlayerSummaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPlayerSummaryProto;
            public static toObject(message: POGOProtos.Rpc.InternalPlayerSummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalPortalCurationImageResult {
        }

        class InternalPortalCurationImageResult implements IInternalPortalCurationImageResult {
            constructor(properties?: POGOProtos.Rpc.IInternalPortalCurationImageResult);
            public static encode(message: POGOProtos.Rpc.IInternalPortalCurationImageResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPortalCurationImageResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPortalCurationImageResult;
            public static toObject(message: POGOProtos.Rpc.InternalPortalCurationImageResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalPortalCurationImageResult {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FEATURE_DISABLED = 2,
                ALREADY_UPLOADED = 3,
                IMAGE_NOT_FOUND = 4,
                IMAGE_TOO_BIG = 5,
                IMAGE_NOT_SERVABLE = 6,
                PORTAL_NOT_FOUND = 7
            }
        }

        interface IInternalProfanityReportData {
            text_content?: (POGOProtos.Rpc.IInternalMessageProfanityReportData|null);
            image_content?: (POGOProtos.Rpc.IInternalImageProfanityReportData|null);
            channel_url?: (string|null);
            message_id?: (number|Long|null);
            origin?: (POGOProtos.Rpc.InternalReportAttributeData.Origin|null);
            message_context?: (POGOProtos.Rpc.IInternalChatMessageContext[]|null);
        }

        class InternalProfanityReportData implements IInternalProfanityReportData {
            constructor(properties?: POGOProtos.Rpc.IInternalProfanityReportData);
            public text_content?: (POGOProtos.Rpc.IInternalMessageProfanityReportData|null);
            public image_content?: (POGOProtos.Rpc.IInternalImageProfanityReportData|null);
            public channel_url: string;
            public message_id: (number|Long);
            public origin: POGOProtos.Rpc.InternalReportAttributeData.Origin;
            public message_context: POGOProtos.Rpc.IInternalChatMessageContext[];
            public ContentType?: ("text_content"|"image_content");
            public static encode(message: POGOProtos.Rpc.IInternalProfanityReportData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProfanityReportData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProfanityReportData;
            public static toObject(message: POGOProtos.Rpc.InternalProfanityReportData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalProfileDetailsProto {
            profile_name_app_key?: (string|null);
            nickname?: (string|null);
            profile_name?: (string|null);
        }

        class InternalProfileDetailsProto implements IInternalProfileDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalProfileDetailsProto);
            public profile_name_app_key: string;
            public nickname: string;
            public profile_name: string;
            public static encode(message: POGOProtos.Rpc.IInternalProfileDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProfileDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProfileDetailsProto;
            public static toObject(message: POGOProtos.Rpc.InternalProfileDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalProximityContact {
            proximity_token?: (POGOProtos.Rpc.IInternalProximityToken|null);
            timestamp_ms?: (number|Long|null);
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
        }

        class InternalProximityContact implements IInternalProximityContact {
            constructor(properties?: POGOProtos.Rpc.IInternalProximityContact);
            public proximity_token?: (POGOProtos.Rpc.IInternalProximityToken|null);
            public timestamp_ms: (number|Long);
            public latitude_deg: number;
            public longitude_deg: number;
            public static encode(message: POGOProtos.Rpc.IInternalProximityContact, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProximityContact;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProximityContact;
            public static toObject(message: POGOProtos.Rpc.InternalProximityContact, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalProximityToken {
            token?: (Uint8Array|null);
            start_time_ms?: (number|Long|null);
            expiration_time_ms?: (number|Long|null);
            iv?: (Uint8Array|null);
        }

        class InternalProximityToken implements IInternalProximityToken {
            constructor(properties?: POGOProtos.Rpc.IInternalProximityToken);
            public token: Uint8Array;
            public start_time_ms: (number|Long);
            public expiration_time_ms: (number|Long);
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalProximityToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProximityToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProximityToken;
            public static toObject(message: POGOProtos.Rpc.InternalProximityToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalProximityTokenInternal {
            player_id?: (string|null);
            start_time_ms?: (number|Long|null);
            expiration_time_ms?: (number|Long|null);
        }

        class InternalProximityTokenInternal implements IInternalProximityTokenInternal {
            constructor(properties?: POGOProtos.Rpc.IInternalProximityTokenInternal);
            public player_id: string;
            public start_time_ms: (number|Long);
            public expiration_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalProximityTokenInternal, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProximityTokenInternal;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProximityTokenInternal;
            public static toObject(message: POGOProtos.Rpc.InternalProximityTokenInternal, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalProxyRequestProto {
            action?: (number|null);
            host?: (string|null);
            payload?: (Uint8Array|null);
        }

        class InternalProxyRequestProto implements IInternalProxyRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalProxyRequestProto);
            public action: number;
            public host: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalProxyRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProxyRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProxyRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalProxyRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalProxyResponseProto {
            status?: (POGOProtos.Rpc.InternalProxyResponseProto.Status|null);
            assigned_host?: (string|null);
            payload?: (Uint8Array|null);
        }

        class InternalProxyResponseProto implements IInternalProxyResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalProxyResponseProto);
            public status: POGOProtos.Rpc.InternalProxyResponseProto.Status;
            public assigned_host: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalProxyResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalProxyResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalProxyResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalProxyResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalProxyResponseProto {

            enum Status {
                UNSET = 0,
                COMPLETED = 1,
                COMPLETED_AND_REASSIGNED = 2,
                ACTION_NOT_FOUND = 3,
                ASSIGNMENT_ERROR = 4,
                PROXY_UNAUTHORIZED_ERROR = 5,
                INTERNAL_ERROR = 6,
                BAD_REQUEST = 7,
                ACCESS_DENIED = 8,
                TIMEOUT_ERROR = 9,
                RATE_LIMITED = 10
            }
        }

        interface IInternalPushNotificationRegistryOutProto {
            result?: (POGOProtos.Rpc.InternalPushNotificationRegistryOutProto.Result|null);
        }

        class InternalPushNotificationRegistryOutProto implements IInternalPushNotificationRegistryOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPushNotificationRegistryOutProto);
            public result: POGOProtos.Rpc.InternalPushNotificationRegistryOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalPushNotificationRegistryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPushNotificationRegistryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPushNotificationRegistryOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalPushNotificationRegistryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalPushNotificationRegistryOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_CHANGE = 2
            }
        }

        interface IInternalPushNotificationRegistryProto {
            apn_token?: (POGOProtos.Rpc.IInternalApnToken|null);
            gcm_token?: (POGOProtos.Rpc.IInternalGcmToken|null);
        }

        class InternalPushNotificationRegistryProto implements IInternalPushNotificationRegistryProto {
            constructor(properties?: POGOProtos.Rpc.IInternalPushNotificationRegistryProto);
            public apn_token?: (POGOProtos.Rpc.IInternalApnToken|null);
            public gcm_token?: (POGOProtos.Rpc.IInternalGcmToken|null);
            public static encode(message: POGOProtos.Rpc.IInternalPushNotificationRegistryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalPushNotificationRegistryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalPushNotificationRegistryProto;
            public static toObject(message: POGOProtos.Rpc.InternalPushNotificationRegistryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRedeemPasscodeRequestProto {
            passcode?: (string|null);
        }

        class InternalRedeemPasscodeRequestProto implements IInternalRedeemPasscodeRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRedeemPasscodeRequestProto);
            public passcode: string;
            public static encode(message: POGOProtos.Rpc.IInternalRedeemPasscodeRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRedeemPasscodeRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRedeemPasscodeRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalRedeemPasscodeRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRedeemPasscodeResponseProto {
            result?: (POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.Result|null);
            acquired_item?: (POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.IAcquiredItem[]|null);
            acquired_items_proto?: (Uint8Array|null);
            passcode?: (string|null);
        }

        class InternalRedeemPasscodeResponseProto implements IInternalRedeemPasscodeResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRedeemPasscodeResponseProto);
            public result: POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.Result;
            public acquired_item: POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.IAcquiredItem[];
            public acquired_items_proto: Uint8Array;
            public passcode: string;
            public static encode(message: POGOProtos.Rpc.IInternalRedeemPasscodeResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRedeemPasscodeResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRedeemPasscodeResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalRedeemPasscodeResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalRedeemPasscodeResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NOT_AVAILABLE = 2,
                OVER_INVENTORY_LIMIT = 3,
                ALREADY_REDEEMED = 4,
                OVER_PLAYER_REDEMPTION_LIMIT = 5
            }

            interface IAcquiredItem {
                item?: (string|null);
                count?: (number|Long|null);
            }

            class AcquiredItem implements IAcquiredItem {
                constructor(properties?: POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.IAcquiredItem);
                public item: string;
                public count: (number|Long);
                public static encode(message: POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.IAcquiredItem, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.AcquiredItem;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.AcquiredItem;
                public static toObject(message: POGOProtos.Rpc.InternalRedeemPasscodeResponseProto.AcquiredItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalReferContactListFriendRequest {
            contact_method?: (POGOProtos.Rpc.InternalSocialV2Enum.ContactMethod|null);
            contact_info?: (string|null);
            contact_id?: (string|null);
            receiver_name?: (string|null);
            app_store_link?: (string|null);
            referral?: (POGOProtos.Rpc.InternalReferContactListFriendRequest.IReferralProto|null);
            country_code?: (string|null);
        }

        class InternalReferContactListFriendRequest implements IInternalReferContactListFriendRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalReferContactListFriendRequest);
            public contact_method: POGOProtos.Rpc.InternalSocialV2Enum.ContactMethod;
            public contact_info: string;
            public contact_id: string;
            public receiver_name: string;
            public app_store_link: string;
            public referral?: (POGOProtos.Rpc.InternalReferContactListFriendRequest.IReferralProto|null);
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalReferContactListFriendRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReferContactListFriendRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReferContactListFriendRequest;
            public static toObject(message: POGOProtos.Rpc.InternalReferContactListFriendRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalReferContactListFriendRequest {

            interface IReferralProto {
                referral_code?: (string|null);
                referral_link?: (string|null);
            }

            class ReferralProto implements IReferralProto {
                constructor(properties?: POGOProtos.Rpc.InternalReferContactListFriendRequest.IReferralProto);
                public referral_code: string;
                public referral_link: string;
                public static encode(message: POGOProtos.Rpc.InternalReferContactListFriendRequest.IReferralProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReferContactListFriendRequest.ReferralProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReferContactListFriendRequest.ReferralProto;
                public static toObject(message: POGOProtos.Rpc.InternalReferContactListFriendRequest.ReferralProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalReferContactListFriendResponse {
            result?: (POGOProtos.Rpc.InternalReferContactListFriendResponse.Result|null);
        }

        class InternalReferContactListFriendResponse implements IInternalReferContactListFriendResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalReferContactListFriendResponse);
            public result: POGOProtos.Rpc.InternalReferContactListFriendResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalReferContactListFriendResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReferContactListFriendResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReferContactListFriendResponse;
            public static toObject(message: POGOProtos.Rpc.InternalReferContactListFriendResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalReferContactListFriendResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_CONTACT_NOT_FOUND = 3,
                ERROR_FAILED_TO_SEND_EMAIL = 4,
                ERROR_EXCEED_LIMIT = 5,
                ERROR_NO_SENDER_NAME = 6,
                ERROR_INAPPROPRIATE_RECEIVER_NAME = 7,
                ERROR_ALREADY_SIGNED_UP = 8
            }
        }

        interface IInternalReferralProto {
            referral_code?: (string|null);
            referral_link?: (string|null);
        }

        class InternalReferralProto implements IInternalReferralProto {
            constructor(properties?: POGOProtos.Rpc.IInternalReferralProto);
            public referral_code: string;
            public referral_link: string;
            public static encode(message: POGOProtos.Rpc.IInternalReferralProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReferralProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReferralProto;
            public static toObject(message: POGOProtos.Rpc.InternalReferralProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRefreshProximityTokensRequestProto {
            first_token_start_time_ms?: (number|Long|null);
        }

        class InternalRefreshProximityTokensRequestProto implements IInternalRefreshProximityTokensRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRefreshProximityTokensRequestProto);
            public first_token_start_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalRefreshProximityTokensRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRefreshProximityTokensRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRefreshProximityTokensRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalRefreshProximityTokensRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRefreshProximityTokensResponseProto {
            proximity_token?: (POGOProtos.Rpc.IInternalProximityToken[]|null);
        }

        class InternalRefreshProximityTokensResponseProto implements IInternalRefreshProximityTokensResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRefreshProximityTokensResponseProto);
            public proximity_token: POGOProtos.Rpc.IInternalProximityToken[];
            public static encode(message: POGOProtos.Rpc.IInternalRefreshProximityTokensResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRefreshProximityTokensResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRefreshProximityTokensResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalRefreshProximityTokensResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRemoveFavoriteFriendRequest {
            friend_id?: (string|null);
            friend_nia_account_id?: (string|null);
        }

        class InternalRemoveFavoriteFriendRequest implements IInternalRemoveFavoriteFriendRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalRemoveFavoriteFriendRequest);
            public friend_id: string;
            public friend_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalRemoveFavoriteFriendRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRemoveFavoriteFriendRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRemoveFavoriteFriendRequest;
            public static toObject(message: POGOProtos.Rpc.InternalRemoveFavoriteFriendRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRemoveFavoriteFriendResponse {
            result?: (POGOProtos.Rpc.InternalRemoveFavoriteFriendResponse.Result|null);
        }

        class InternalRemoveFavoriteFriendResponse implements IInternalRemoveFavoriteFriendResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalRemoveFavoriteFriendResponse);
            public result: POGOProtos.Rpc.InternalRemoveFavoriteFriendResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalRemoveFavoriteFriendResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRemoveFavoriteFriendResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRemoveFavoriteFriendResponse;
            public static toObject(message: POGOProtos.Rpc.InternalRemoveFavoriteFriendResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalRemoveFavoriteFriendResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IInternalRemoveFriendOutProto {
            result?: (POGOProtos.Rpc.InternalRemoveFriendOutProto.Result|null);
        }

        class InternalRemoveFriendOutProto implements IInternalRemoveFriendOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRemoveFriendOutProto);
            public result: POGOProtos.Rpc.InternalRemoveFriendOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalRemoveFriendOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRemoveFriendOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRemoveFriendOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalRemoveFriendOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalRemoveFriendOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_DOES_NOT_EXIST_DELETED = 2,
                ERROR_PLAYER_NOT_A_FRIEND = 3
            }
        }

        interface IInternalRemoveFriendProto {
            player_id?: (string|null);
            nia_account_id?: (string|null);
        }

        class InternalRemoveFriendProto implements IInternalRemoveFriendProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRemoveFriendProto);
            public player_id: string;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalRemoveFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRemoveFriendProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRemoveFriendProto;
            public static toObject(message: POGOProtos.Rpc.InternalRemoveFriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRemoveLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.IInternalLoginDetail[]|null);
            status?: (POGOProtos.Rpc.InternalRemoveLoginActionOutProto.Status|null);
        }

        class InternalRemoveLoginActionOutProto implements IInternalRemoveLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRemoveLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.IInternalLoginDetail[];
            public status: POGOProtos.Rpc.InternalRemoveLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalRemoveLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRemoveLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRemoveLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalRemoveLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalRemoveLoginActionOutProto {

            enum Status {
                UNSET = 0,
                LOGIN_NOT_REMOVABLE = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalRemoveLoginActionProto {
            identity_provider?: (POGOProtos.Rpc.InternalIdentityProvider|null);
            auth_provider_id?: (string|null);
        }

        class InternalRemoveLoginActionProto implements IInternalRemoveLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRemoveLoginActionProto);
            public identity_provider: POGOProtos.Rpc.InternalIdentityProvider;
            public auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalRemoveLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRemoveLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRemoveLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.InternalRemoveLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalReplaceLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.IInternalLoginDetail[]|null);
            status?: (POGOProtos.Rpc.InternalReplaceLoginActionOutProto.Status|null);
        }

        class InternalReplaceLoginActionOutProto implements IInternalReplaceLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalReplaceLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.IInternalLoginDetail[];
            public status: POGOProtos.Rpc.InternalReplaceLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalReplaceLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReplaceLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReplaceLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalReplaceLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalReplaceLoginActionOutProto {

            enum Status {
                UNSET = 0,
                AUTH_FAILURE = 1,
                LOGIN_TAKEN = 2,
                LOGIN_ALREADY_HAVE = 3,
                LOGIN_NOT_REPLACEABLE = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IInternalReplaceLoginActionProto {
            existing_identity_provider?: (POGOProtos.Rpc.InternalIdentityProvider|null);
            new_login?: (POGOProtos.Rpc.IInternalAddLoginActionProto|null);
            auth_provider_id?: (string|null);
        }

        class InternalReplaceLoginActionProto implements IInternalReplaceLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IInternalReplaceLoginActionProto);
            public existing_identity_provider: POGOProtos.Rpc.InternalIdentityProvider;
            public new_login?: (POGOProtos.Rpc.IInternalAddLoginActionProto|null);
            public auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalReplaceLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReplaceLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReplaceLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.InternalReplaceLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalReportAttributeData {
        }

        class InternalReportAttributeData implements IInternalReportAttributeData {
            constructor(properties?: POGOProtos.Rpc.IInternalReportAttributeData);
            public static encode(message: POGOProtos.Rpc.IInternalReportAttributeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReportAttributeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReportAttributeData;
            public static toObject(message: POGOProtos.Rpc.InternalReportAttributeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalReportAttributeData {

            enum ContentType {
                UNDEFINED_CONTENT = 0,
                TEXT = 1,
                IMAGE = 2,
                GENERIC = 3
            }

            enum Origin {
                UNDEFINED_ORIGIN = 0,
                PUBLIC_CHAT = 1,
                PRIVATE_CHAT = 2,
                GENERAL_IMAGE = 3,
                CODENAME = 4,
                NAME = 5,
                POST = 6,
                PRIVATE_GROUP_CHAT = 7,
                FLARE_CHAT = 8,
                USER = 9,
                GROUP = 10,
                EVENT = 11,
                CHANNEL = 12
            }

            enum Severity {
                UNDEFINED_SEVERITY = 0,
                LOW = 1,
                MEDIUM = 2,
                HIGH = 3,
                EXTREME = 4,
                NONE = 5
            }

            enum Status {
                UNDEFINED_STATUS = 0,
                OPEN = 1,
                REVIEWED = 2,
                CLOSED = 3,
                ESCALATED = 4,
                OPEN_ASSIGNED = 5
            }

            enum Type {
                UNDEFINED_REPORT = 0,
                BLOCK_REPORT = 1,
                PROFANITY_REPORT = 2,
                FLAG_REPORT = 3,
                LOG_REPORT = 4,
                OPS_MANUAL = 5
            }
        }

        interface IInternalReportInfoWrapper {
            app_id?: (string|null);
            report_uuid?: (string|null);
            offender_id?: (string|null);
            severity?: (POGOProtos.Rpc.InternalReportAttributeData.Severity|null);
            type?: (POGOProtos.Rpc.InternalReportAttributeData.Type|null);
            offending_message?: (string|null);
            created_timestamp_ms?: (number|Long|null);
            language_code?: (string|null);
        }

        class InternalReportInfoWrapper implements IInternalReportInfoWrapper {
            constructor(properties?: POGOProtos.Rpc.IInternalReportInfoWrapper);
            public app_id: string;
            public report_uuid: string;
            public offender_id: string;
            public severity: POGOProtos.Rpc.InternalReportAttributeData.Severity;
            public type: POGOProtos.Rpc.InternalReportAttributeData.Type;
            public offending_message: string;
            public created_timestamp_ms: (number|Long);
            public language_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalReportInfoWrapper, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReportInfoWrapper;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReportInfoWrapper;
            public static toObject(message: POGOProtos.Rpc.InternalReportInfoWrapper, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalReportProximityContactsRequestProto {
            contacts?: (POGOProtos.Rpc.IInternalProximityContact[]|null);
        }

        class InternalReportProximityContactsRequestProto implements IInternalReportProximityContactsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalReportProximityContactsRequestProto);
            public contacts: POGOProtos.Rpc.IInternalProximityContact[];
            public static encode(message: POGOProtos.Rpc.IInternalReportProximityContactsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReportProximityContactsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReportProximityContactsRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalReportProximityContactsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalReportProximityContactsResponseProto {
        }

        class InternalReportProximityContactsResponseProto implements IInternalReportProximityContactsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalReportProximityContactsResponseProto);
            public static encode(message: POGOProtos.Rpc.IInternalReportProximityContactsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReportProximityContactsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReportProximityContactsResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalReportProximityContactsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalReputationSystemAttributes {
        }

        class InternalReputationSystemAttributes implements IInternalReputationSystemAttributes {
            constructor(properties?: POGOProtos.Rpc.IInternalReputationSystemAttributes);
            public static encode(message: POGOProtos.Rpc.IInternalReputationSystemAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalReputationSystemAttributes;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalReputationSystemAttributes;
            public static toObject(message: POGOProtos.Rpc.InternalReputationSystemAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalReputationSystemAttributes {

            enum SystemType {
                UNDEFINED_SYSTEM_TYPE = 0,
                CHAT = 1,
                IMAGE_ONLY = 2
            }
        }

        interface IInternalResponse {
        }

        class InternalResponse implements IInternalResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalResponse);
            public static encode(message: POGOProtos.Rpc.IInternalResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalResponse;
            public static toObject(message: POGOProtos.Rpc.InternalResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                APP_NOT_FOUND = 2,
                PLAYER_DATA_NOT_FOUND = 3,
                REPORT_NOT_FOUND = 4,
                FAILURE = 5
            }
        }

        interface IInternalRotateGuestLoginSecretTokenRequestProto {
            secret?: (Uint8Array|null);
            api_key?: (string|null);
            device_id?: (string|null);
        }

        class InternalRotateGuestLoginSecretTokenRequestProto implements IInternalRotateGuestLoginSecretTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRotateGuestLoginSecretTokenRequestProto);
            public secret: Uint8Array;
            public api_key: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalRotateGuestLoginSecretTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalRotateGuestLoginSecretTokenResponseProto {
            status?: (POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenResponseProto.Status|null);
            new_secret?: (Uint8Array|null);
        }

        class InternalRotateGuestLoginSecretTokenResponseProto implements IInternalRotateGuestLoginSecretTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalRotateGuestLoginSecretTokenResponseProto);
            public status: POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenResponseProto.Status;
            public new_secret: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalRotateGuestLoginSecretTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalRotateGuestLoginSecretTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalRotateGuestLoginSecretTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                UNKNOWN_ERROR = 2,
                UNAUTHORIZED = 3,
                INVALID_AUTH_TOKEN = 4
            }
        }

        interface IInternalSavePlayerSettingsOutProto {
            result?: (POGOProtos.Rpc.InternalSavePlayerSettingsOutProto.Result|null);
        }

        class InternalSavePlayerSettingsOutProto implements IInternalSavePlayerSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSavePlayerSettingsOutProto);
            public result: POGOProtos.Rpc.InternalSavePlayerSettingsOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalSavePlayerSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSavePlayerSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSavePlayerSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSavePlayerSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSavePlayerSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalSavePlayerSettingsProto {
            settings?: (POGOProtos.Rpc.IInternalPlayerSettingsProto|null);
        }

        class InternalSavePlayerSettingsProto implements IInternalSavePlayerSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSavePlayerSettingsProto);
            public settings?: (POGOProtos.Rpc.IInternalPlayerSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalSavePlayerSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSavePlayerSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSavePlayerSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalSavePlayerSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalScoreAdjustment {
            is_resolved?: (boolean|null);
            details?: (string|null);
            adjustment_timestamp_ms?: (number|Long|null);
            author?: (string|null);
            adjustment_value?: (number|null);
        }

        class InternalScoreAdjustment implements IInternalScoreAdjustment {
            constructor(properties?: POGOProtos.Rpc.IInternalScoreAdjustment);
            public is_resolved: boolean;
            public details: string;
            public adjustment_timestamp_ms: (number|Long);
            public author: string;
            public adjustment_value: number;
            public static encode(message: POGOProtos.Rpc.IInternalScoreAdjustment, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalScoreAdjustment;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalScoreAdjustment;
            public static toObject(message: POGOProtos.Rpc.InternalScoreAdjustment, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSearchPlayerOutProto {
            result?: (POGOProtos.Rpc.InternalSearchPlayerOutProto.Result|null);
            player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
        }

        class InternalSearchPlayerOutProto implements IInternalSearchPlayerOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSearchPlayerOutProto);
            public result: POGOProtos.Rpc.InternalSearchPlayerOutProto.Result;
            public player?: (POGOProtos.Rpc.IInternalPlayerSummaryProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalSearchPlayerOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSearchPlayerOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSearchPlayerOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSearchPlayerOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSearchPlayerOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IInternalSearchPlayerProto {
            friend_code?: (string|null);
        }

        class InternalSearchPlayerProto implements IInternalSearchPlayerProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSearchPlayerProto);
            public friend_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalSearchPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSearchPlayerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSearchPlayerProto;
            public static toObject(message: POGOProtos.Rpc.InternalSearchPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSendContactListFriendInviteRequest {
            emails?: (string[]|null);
            phone_numbers?: (string[]|null);
            country_code?: (string|null);
        }

        class InternalSendContactListFriendInviteRequest implements IInternalSendContactListFriendInviteRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalSendContactListFriendInviteRequest);
            public emails: string[];
            public phone_numbers: string[];
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalSendContactListFriendInviteRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSendContactListFriendInviteRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSendContactListFriendInviteRequest;
            public static toObject(message: POGOProtos.Rpc.InternalSendContactListFriendInviteRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSendContactListFriendInviteResponse {
            result?: (POGOProtos.Rpc.InternalSendContactListFriendInviteResponse.Result|null);
            new_friendship_formed?: (boolean|null);
        }

        class InternalSendContactListFriendInviteResponse implements IInternalSendContactListFriendInviteResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalSendContactListFriendInviteResponse);
            public result: POGOProtos.Rpc.InternalSendContactListFriendInviteResponse.Result;
            public new_friendship_formed: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalSendContactListFriendInviteResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSendContactListFriendInviteResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSendContactListFriendInviteResponse;
            public static toObject(message: POGOProtos.Rpc.InternalSendContactListFriendInviteResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSendContactListFriendInviteResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_OUTBOX_FULL = 3,
                ERROR_PLAYER_INBOX_FULL = 4,
                ERROR_SENDER_HAS_MAX_FRIENDS = 5,
                ERROR_RECEIVER_HAS_MAX_FRIENDS = 6,
                ERROR_ALREADY_A_FRIEND = 7,
                ERROR_INVITE_ALREADY_SENT = 8,
                ERROR_INVITE_ALREADY_RECEIVED = 9,
                ERROR_CANNOT_SEND_INVITES_TO_YOURSELF = 10,
                ERROR_CONTACT_NOT_FOUND = 11,
                ERROR_RECEIVER_NOT_FOUND = 12,
                ERROR_NO_SENDER_NAME = 13,
                ERROR_SEND_TO_BLOCKED_USER = 14
            }
        }

        interface IInternalSendFriendInviteOutProto {
            result?: (POGOProtos.Rpc.InternalSendFriendInviteOutProto.Result|null);
            new_friendship_formed?: (boolean|null);
        }

        class InternalSendFriendInviteOutProto implements IInternalSendFriendInviteOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSendFriendInviteOutProto);
            public result: POGOProtos.Rpc.InternalSendFriendInviteOutProto.Result;
            public new_friendship_formed: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalSendFriendInviteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSendFriendInviteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSendFriendInviteOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSendFriendInviteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSendFriendInviteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ALREADY_A_FRIEND = 3,
                ERROR_PLAYER_DOES_NOT_EXIST_DELETED = 4,
                ERROR_PLAYER_INBOX_FULL = 5,
                ERROR_PLAYER_OUTBOX_FULL = 6,
                ERROR_SENDER_HAS_MAX_FRIENDS = 7,
                ERROR_INVITE_ALREADY_SENT = 8,
                ERROR_CANNOT_SEND_INVITES_TO_YOURSELF = 9,
                ERROR_INVITE_ALREADY_RECEIVED = 10,
                ERROR_RECEIVER_HAS_MAX_FRIENDS = 11,
                ERROR_SEND_TO_BLOCKED_USER = 12
            }
        }

        interface IInternalSendFriendInviteProto {
            player_id?: (string|null);
            friend_code?: (string|null);
            read_only?: (boolean|null);
            nia_account_id?: (string|null);
        }

        class InternalSendFriendInviteProto implements IInternalSendFriendInviteProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSendFriendInviteProto);
            public player_id: string;
            public friend_code: string;
            public read_only: boolean;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalSendFriendInviteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSendFriendInviteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSendFriendInviteProto;
            public static toObject(message: POGOProtos.Rpc.InternalSendFriendInviteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSendSmsVerificationCodeRequest {
            phone_number?: (string|null);
            country_code?: (string|null);
        }

        class InternalSendSmsVerificationCodeRequest implements IInternalSendSmsVerificationCodeRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalSendSmsVerificationCodeRequest);
            public phone_number: string;
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalSendSmsVerificationCodeRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSendSmsVerificationCodeRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSendSmsVerificationCodeRequest;
            public static toObject(message: POGOProtos.Rpc.InternalSendSmsVerificationCodeRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSendSmsVerificationCodeResponse {
            status?: (POGOProtos.Rpc.InternalSendSmsVerificationCodeResponse.Status|null);
            error_message?: (string|null);
        }

        class InternalSendSmsVerificationCodeResponse implements IInternalSendSmsVerificationCodeResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalSendSmsVerificationCodeResponse);
            public status: POGOProtos.Rpc.InternalSendSmsVerificationCodeResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IInternalSendSmsVerificationCodeResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSendSmsVerificationCodeResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSendSmsVerificationCodeResponse;
            public static toObject(message: POGOProtos.Rpc.InternalSendSmsVerificationCodeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSendSmsVerificationCodeResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_TOO_FREQUENT_ATTEMPTS = 3,
                ERROR_TOO_MANY_ATTEMPTS = 4,
                ERROR_INVALID_PHONE_NUMBER = 5
            }
        }

        interface IInternalSetAccountContactSettingsRequest {
            full_name?: (string|null);
            contact_import_discoverability_consent?: (POGOProtos.Rpc.InternalAccountContactSettings.ConsentStatus|null);
            update_field_mask?: (POGOProtos.Rpc.IFieldMask|null);
        }

        class InternalSetAccountContactSettingsRequest implements IInternalSetAccountContactSettingsRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalSetAccountContactSettingsRequest);
            public full_name: string;
            public contact_import_discoverability_consent: POGOProtos.Rpc.InternalAccountContactSettings.ConsentStatus;
            public update_field_mask?: (POGOProtos.Rpc.IFieldMask|null);
            public static encode(message: POGOProtos.Rpc.IInternalSetAccountContactSettingsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetAccountContactSettingsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetAccountContactSettingsRequest;
            public static toObject(message: POGOProtos.Rpc.InternalSetAccountContactSettingsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSetAccountContactSettingsResponse {
            status?: (POGOProtos.Rpc.InternalSetAccountContactSettingsResponse.Status|null);
            error_message?: (string|null);
        }

        class InternalSetAccountContactSettingsResponse implements IInternalSetAccountContactSettingsResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalSetAccountContactSettingsResponse);
            public status: POGOProtos.Rpc.InternalSetAccountContactSettingsResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IInternalSetAccountContactSettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetAccountContactSettingsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetAccountContactSettingsResponse;
            public static toObject(message: POGOProtos.Rpc.InternalSetAccountContactSettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSetAccountContactSettingsResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                NAME_NOT_ALLOWED = 3,
                NAME_ABUSIVE = 4,
                NAME_INVALID = 5
            }
        }

        interface IInternalSetAccountSettingsOutProto {
            result?: (POGOProtos.Rpc.InternalSetAccountSettingsOutProto.Result|null);
        }

        class InternalSetAccountSettingsOutProto implements IInternalSetAccountSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetAccountSettingsOutProto);
            public result: POGOProtos.Rpc.InternalSetAccountSettingsOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalSetAccountSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetAccountSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetAccountSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetAccountSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSetAccountSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INAPPROPRIATE_NAME = 3
            }
        }

        interface IInternalSetAccountSettingsProto {
            settings?: (POGOProtos.Rpc.IInternalAccountSettingsProto|null);
        }

        class InternalSetAccountSettingsProto implements IInternalSetAccountSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetAccountSettingsProto);
            public settings?: (POGOProtos.Rpc.IInternalAccountSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalSetAccountSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetAccountSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetAccountSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetAccountSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSetBirthdayRequestProto {
            birthday?: (string|null);
        }

        class InternalSetBirthdayRequestProto implements IInternalSetBirthdayRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetBirthdayRequestProto);
            public birthday: string;
            public static encode(message: POGOProtos.Rpc.IInternalSetBirthdayRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetBirthdayRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetBirthdayRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetBirthdayRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSetBirthdayResponseProto {
            status?: (POGOProtos.Rpc.InternalSetBirthdayResponseProto.Status|null);
        }

        class InternalSetBirthdayResponseProto implements IInternalSetBirthdayResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetBirthdayResponseProto);
            public status: POGOProtos.Rpc.InternalSetBirthdayResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalSetBirthdayResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetBirthdayResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetBirthdayResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetBirthdayResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSetBirthdayResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                INVALID_BIRTHDAY = 3
            }
        }

        interface IInternalSetInGameCurrencyExchangeRateOutProto {
            status?: (POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateOutProto.Status|null);
        }

        class InternalSetInGameCurrencyExchangeRateOutProto implements IInternalSetInGameCurrencyExchangeRateOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateOutProto);
            public status: POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSetInGameCurrencyExchangeRateOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IInternalSetInGameCurrencyExchangeRateProto {
            in_game_currency?: (string|null);
            fiat_currency?: (string|null);
            fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
        }

        class InternalSetInGameCurrencyExchangeRateProto implements IInternalSetInGameCurrencyExchangeRateProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateProto);
            public in_game_currency: string;
            public fiat_currency: string;
            public fiat_currency_cost_e6_per_in_game_unit: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSetInGameCurrencyExchangeRateTrackingProto {
            in_game_currency?: (string|null);
            fiat_currency?: (string|null);
            fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
            status?: (string|null);
        }

        class InternalSetInGameCurrencyExchangeRateTrackingProto implements IInternalSetInGameCurrencyExchangeRateTrackingProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateTrackingProto);
            public in_game_currency: string;
            public fiat_currency: string;
            public fiat_currency_cost_e6_per_in_game_unit: (number|Long);
            public status: string;
            public static encode(message: POGOProtos.Rpc.IInternalSetInGameCurrencyExchangeRateTrackingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateTrackingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateTrackingProto;
            public static toObject(message: POGOProtos.Rpc.InternalSetInGameCurrencyExchangeRateTrackingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSkuContentProto {
            item_type?: (string|null);
            quantity?: (number|null);
        }

        class InternalSkuContentProto implements IInternalSkuContentProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSkuContentProto);
            public item_type: string;
            public quantity: number;
            public static encode(message: POGOProtos.Rpc.IInternalSkuContentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuContentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuContentProto;
            public static toObject(message: POGOProtos.Rpc.InternalSkuContentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSkuDataProto {
            id?: (string|null);
            is_enabled?: (boolean|null);
            content?: (POGOProtos.Rpc.IInternalSkuContentProto[]|null);
            price?: (POGOProtos.Rpc.IInternalSkuPriceProto[]|null);
            payment_type?: (POGOProtos.Rpc.InternalSkuDataProto.SkuPaymentType|null);
            last_modified_timestamp_ms?: (number|Long|null);
            presentation_data?: (POGOProtos.Rpc.IInternalSkuPresentationDataProto[]|null);
            enabled_window_start_ms?: (number|Long|null);
            enabled_window_end_ms?: (number|Long|null);
            subscription_id?: (string|null);
            sku_limit?: (POGOProtos.Rpc.IInternalSkuLimitProto[]|null);
            is_offer_only?: (boolean|null);
            subscription_group_id?: (string|null);
            subscription_level?: (number|null);
            store_filter?: (string|null);
            rewarded_spend_points?: (number|null);
        }

        class InternalSkuDataProto implements IInternalSkuDataProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSkuDataProto);
            public id: string;
            public is_enabled: boolean;
            public content: POGOProtos.Rpc.IInternalSkuContentProto[];
            public price: POGOProtos.Rpc.IInternalSkuPriceProto[];
            public payment_type: POGOProtos.Rpc.InternalSkuDataProto.SkuPaymentType;
            public last_modified_timestamp_ms: (number|Long);
            public presentation_data: POGOProtos.Rpc.IInternalSkuPresentationDataProto[];
            public enabled_window_start_ms: (number|Long);
            public enabled_window_end_ms: (number|Long);
            public subscription_id: string;
            public sku_limit: POGOProtos.Rpc.IInternalSkuLimitProto[];
            public is_offer_only: boolean;
            public subscription_group_id: string;
            public subscription_level: number;
            public store_filter: string;
            public rewarded_spend_points: number;
            public static encode(message: POGOProtos.Rpc.IInternalSkuDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuDataProto;
            public static toObject(message: POGOProtos.Rpc.InternalSkuDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSkuDataProto {

            enum SkuPaymentType {
                UNSET = 0,
                THIRD_PARTY = 1,
                IN_GAME = 2,
                WEB = 3
            }
        }

        interface IInternalSkuLimitProto {
            name?: (string|null);
            params?: ({ [k: string]: string }|null);
        }

        class InternalSkuLimitProto implements IInternalSkuLimitProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSkuLimitProto);
            public name: string;
            public params: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IInternalSkuLimitProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuLimitProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuLimitProto;
            public static toObject(message: POGOProtos.Rpc.InternalSkuLimitProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSkuPresentationDataProto {
            key?: (string|null);
            value?: (string|null);
        }

        class InternalSkuPresentationDataProto implements IInternalSkuPresentationDataProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSkuPresentationDataProto);
            public key: string;
            public value: string;
            public static encode(message: POGOProtos.Rpc.IInternalSkuPresentationDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuPresentationDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuPresentationDataProto;
            public static toObject(message: POGOProtos.Rpc.InternalSkuPresentationDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSkuPriceProto {
            currency_type?: (string|null);
            price?: (number|null);
        }

        class InternalSkuPriceProto implements IInternalSkuPriceProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSkuPriceProto);
            public currency_type: string;
            public price: number;
            public static encode(message: POGOProtos.Rpc.IInternalSkuPriceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuPriceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuPriceProto;
            public static toObject(message: POGOProtos.Rpc.InternalSkuPriceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSkuRecord {
            sku_id?: (string|null);
            purchase_time_ms?: ((number|Long)[]|null);
            total_purchases?: (number|null);
            offer_records?: ({ [k: string]: POGOProtos.Rpc.InternalSkuRecord.ISkuOfferRecord }|null);
        }

        class InternalSkuRecord implements IInternalSkuRecord {
            constructor(properties?: POGOProtos.Rpc.IInternalSkuRecord);
            public sku_id: string;
            public purchase_time_ms: (number|Long)[];
            public total_purchases: number;
            public offer_records: { [k: string]: POGOProtos.Rpc.InternalSkuRecord.ISkuOfferRecord };
            public static encode(message: POGOProtos.Rpc.IInternalSkuRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuRecord;
            public static toObject(message: POGOProtos.Rpc.InternalSkuRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSkuRecord {

            interface ISkuOfferRecord {
                purchase_time_ms?: ((number|Long)[]|null);
                total_purchases?: (number|null);
            }

            class SkuOfferRecord implements ISkuOfferRecord {
                constructor(properties?: POGOProtos.Rpc.InternalSkuRecord.ISkuOfferRecord);
                public purchase_time_ms: (number|Long)[];
                public total_purchases: number;
                public static encode(message: POGOProtos.Rpc.InternalSkuRecord.ISkuOfferRecord, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSkuRecord.SkuOfferRecord;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSkuRecord.SkuOfferRecord;
                public static toObject(message: POGOProtos.Rpc.InternalSkuRecord.SkuOfferRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalSocialClientFeatures {
            cross_game_social_settings?: (POGOProtos.Rpc.InternalSocialClientFeatures.ICrossGameSocialClientSettingsProto|null);
        }

        class InternalSocialClientFeatures implements IInternalSocialClientFeatures {
            constructor(properties?: POGOProtos.Rpc.IInternalSocialClientFeatures);
            public cross_game_social_settings?: (POGOProtos.Rpc.InternalSocialClientFeatures.ICrossGameSocialClientSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalSocialClientFeatures, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialClientFeatures;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialClientFeatures;
            public static toObject(message: POGOProtos.Rpc.InternalSocialClientFeatures, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSocialClientFeatures {

            interface ICrossGameSocialClientSettingsProto {
                disabled_features?: (POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.FeatureType[]|null);
                app_link?: (POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.AppLinkType|null);
            }

            class CrossGameSocialClientSettingsProto implements ICrossGameSocialClientSettingsProto {
                constructor(properties?: POGOProtos.Rpc.InternalSocialClientFeatures.ICrossGameSocialClientSettingsProto);
                public disabled_features: POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.FeatureType[];
                public app_link: POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto.AppLinkType;
                public static encode(message: POGOProtos.Rpc.InternalSocialClientFeatures.ICrossGameSocialClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto;
                public static toObject(message: POGOProtos.Rpc.InternalSocialClientFeatures.CrossGameSocialClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CrossGameSocialClientSettingsProto {

                enum AppLinkType {
                    NO_LINK = 0,
                    WEB_LINK = 1,
                    APP_STORE_LINK = 2
                }

                enum FeatureType {
                    UNSET = 0,
                    NIANTIC_PROFILE = 1,
                    ONLINE_STATUS = 2,
                    CROSS_GAME_FRIEND_LIST = 3,
                    GAME_INVITE_SENDER = 4,
                    SHARED_FRIEND_GRAPH = 5,
                    NICKNAME = 6,
                    CROSS_GAME_ONLINE_STATUS = 7,
                    GAME_INVITE_RECEIVER = 8,
                    ADDRESS_BOOK_IMPORT = 9
                }
            }
        }

        interface IInternalSocialClientGlobalSettings {
            cross_game_social_settings?: (POGOProtos.Rpc.InternalSocialClientGlobalSettings.ICrossGameSocialSettingsProto|null);
        }

        class InternalSocialClientGlobalSettings implements IInternalSocialClientGlobalSettings {
            constructor(properties?: POGOProtos.Rpc.IInternalSocialClientGlobalSettings);
            public cross_game_social_settings?: (POGOProtos.Rpc.InternalSocialClientGlobalSettings.ICrossGameSocialSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalSocialClientGlobalSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialClientGlobalSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialClientGlobalSettings;
            public static toObject(message: POGOProtos.Rpc.InternalSocialClientGlobalSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSocialClientGlobalSettings {

            interface ICrossGameSocialSettingsProto {
                niantic_profile_codename_opt_out_enabled?: (boolean|null);
                disabled_outgoing_game_invite_app_key?: (string[]|null);
                unreleased_app_key?: (string[]|null);
                contact_list_sync_page_size?: (number|null);
                contact_list_sync_interval_ms?: (number|Long|null);
                max_friends?: (number|null);
                contact_list_concurrent_rpc_size?: (number|null);
            }

            class CrossGameSocialSettingsProto implements ICrossGameSocialSettingsProto {
                constructor(properties?: POGOProtos.Rpc.InternalSocialClientGlobalSettings.ICrossGameSocialSettingsProto);
                public niantic_profile_codename_opt_out_enabled: boolean;
                public disabled_outgoing_game_invite_app_key: string[];
                public unreleased_app_key: string[];
                public contact_list_sync_page_size: number;
                public contact_list_sync_interval_ms: (number|Long);
                public max_friends: number;
                public contact_list_concurrent_rpc_size: number;
                public static encode(message: POGOProtos.Rpc.InternalSocialClientGlobalSettings.ICrossGameSocialSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialClientGlobalSettings.CrossGameSocialSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialClientGlobalSettings.CrossGameSocialSettingsProto;
                public static toObject(message: POGOProtos.Rpc.InternalSocialClientGlobalSettings.CrossGameSocialSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalSocialProto {
        }

        class InternalSocialProto implements IInternalSocialProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSocialProto);
            public static encode(message: POGOProtos.Rpc.IInternalSocialProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialProto;
            public static toObject(message: POGOProtos.Rpc.InternalSocialProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSocialProto {

            enum AppKey {
                INVALID = 0,
                INGRESS_DELETED = 1,
                HOLOHOLO_DELETED = 2,
                LEXICON_DELETED = 3
            }
        }

        interface IInternalSocialSettings {
        }

        class InternalSocialSettings implements IInternalSocialSettings {
            constructor(properties?: POGOProtos.Rpc.IInternalSocialSettings);
            public static encode(message: POGOProtos.Rpc.IInternalSocialSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialSettings;
            public static toObject(message: POGOProtos.Rpc.InternalSocialSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSocialSettings {

            enum ConsentStatus {
                UNKNOWN = 0,
                OPT_IN = 1,
                OPT_OUT = 2
            }

            enum ListOption {
                UNSET_OPTION = 0,
                RETURN_ALL = 1
            }

            enum TutorialType {
                UNSET = 0,
                PROFILE = 1,
                CROSS_GAME_FRIEND_LIST = 2,
                ONLINE_STATUS_OVERVIEW = 3,
                ONLINE_STATUS_TOGGLE = 4,
                ADDRESS_BOOK_IMPORT = 5,
                ADDRESS_BOOK_DISCOVERABILITY = 6,
                ADDRESS_BOOK_PHONE_NUMBER_REGISTRATION = 7
            }
        }

        interface IInternalSocialV2Enum {
        }

        class InternalSocialV2Enum implements IInternalSocialV2Enum {
            constructor(properties?: POGOProtos.Rpc.IInternalSocialV2Enum);
            public static encode(message: POGOProtos.Rpc.IInternalSocialV2Enum, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSocialV2Enum;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSocialV2Enum;
            public static toObject(message: POGOProtos.Rpc.InternalSocialV2Enum, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSocialV2Enum {

            enum ContactMethod {
                CONTACT_METHOD_UNSET = 0,
                EMAIL = 1,
                SMS = 2
            }

            enum InvitationStatus {
                INVITATION_STATUS_UNSET = 0,
                INVITED = 1
            }

            enum OnlineStatus {
                STATUS_UNSET = 0,
                STATUS_UNKNOWN = 1,
                STATUS_ONLINE = 2,
                STATUS_OFFLINE = 3
            }
        }

        interface IInternalSubmitImageOutProto {
            result?: (POGOProtos.Rpc.InternalSubmitImageOutProto.Result|null);
            transient_photo_url?: (string|null);
            photo_id?: (string|null);
        }

        class InternalSubmitImageOutProto implements IInternalSubmitImageOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSubmitImageOutProto);
            public result: POGOProtos.Rpc.InternalSubmitImageOutProto.Result;
            public transient_photo_url: string;
            public photo_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalSubmitImageOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSubmitImageOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSubmitImageOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSubmitImageOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSubmitImageOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                IMAGE_DOES_NOT_EXIST = 2,
                INAPPROPRIATE_CONTENT = 3,
                ERROR_UNKNOWN = 4,
                PHOTO_ID_ALREADY_SUBMITTED = 5,
                MATCHING_IMAGE_FLAGGED = 6
            }
        }

        interface IInternalSubmitImageProto {
            photo_id?: (string|null);
            metadata?: ({ [k: string]: string }|null);
        }

        class InternalSubmitImageProto implements IInternalSubmitImageProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSubmitImageProto);
            public photo_id: string;
            public metadata: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.IInternalSubmitImageProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSubmitImageProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSubmitImageProto;
            public static toObject(message: POGOProtos.Rpc.InternalSubmitImageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSubmitNewPoiOutProto {
            status?: (POGOProtos.Rpc.InternalSubmitNewPoiOutProto.Status|null);
        }

        class InternalSubmitNewPoiOutProto implements IInternalSubmitNewPoiOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSubmitNewPoiOutProto);
            public status: POGOProtos.Rpc.InternalSubmitNewPoiOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalSubmitNewPoiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSubmitNewPoiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSubmitNewPoiOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalSubmitNewPoiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSubmitNewPoiOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                INTERNAL_ERROR = 3,
                TOO_MANY_RECENT_SUBMISSIONS = 4,
                INVALID_INPUT = 5,
                MINOR = 6,
                NOT_AVAILABLE = 7
            }
        }

        interface IInternalSubmitNewPoiProto {
            title?: (string|null);
            long_description?: (string|null);
            lat_e6?: (number|null);
            lng_e6?: (number|null);
            supporting_statement?: (string|null);
        }

        class InternalSubmitNewPoiProto implements IInternalSubmitNewPoiProto {
            constructor(properties?: POGOProtos.Rpc.IInternalSubmitNewPoiProto);
            public title: string;
            public long_description: string;
            public lat_e6: number;
            public lng_e6: number;
            public supporting_statement: string;
            public static encode(message: POGOProtos.Rpc.IInternalSubmitNewPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSubmitNewPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSubmitNewPoiProto;
            public static toObject(message: POGOProtos.Rpc.InternalSubmitNewPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalSyncContactListRequest {
            contact?: (POGOProtos.Rpc.InternalSyncContactListRequest.IContactProto[]|null);
            country_code?: (string|null);
        }

        class InternalSyncContactListRequest implements IInternalSyncContactListRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalSyncContactListRequest);
            public contact: POGOProtos.Rpc.InternalSyncContactListRequest.IContactProto[];
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IInternalSyncContactListRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSyncContactListRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSyncContactListRequest;
            public static toObject(message: POGOProtos.Rpc.InternalSyncContactListRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSyncContactListRequest {

            interface IContactProto {
                contact_id?: (string|null);
                email?: (string[]|null);
                phone_number?: (string[]|null);
            }

            class ContactProto implements IContactProto {
                constructor(properties?: POGOProtos.Rpc.InternalSyncContactListRequest.IContactProto);
                public contact_id: string;
                public email: string[];
                public phone_number: string[];
                public static encode(message: POGOProtos.Rpc.InternalSyncContactListRequest.IContactProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSyncContactListRequest.ContactProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSyncContactListRequest.ContactProto;
                public static toObject(message: POGOProtos.Rpc.InternalSyncContactListRequest.ContactProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalSyncContactListResponse {
            result?: (POGOProtos.Rpc.InternalSyncContactListResponse.Result|null);
            contact_player?: (POGOProtos.Rpc.InternalSyncContactListResponse.IContactPlayerProto[]|null);
        }

        class InternalSyncContactListResponse implements IInternalSyncContactListResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalSyncContactListResponse);
            public result: POGOProtos.Rpc.InternalSyncContactListResponse.Result;
            public contact_player: POGOProtos.Rpc.InternalSyncContactListResponse.IContactPlayerProto[];
            public static encode(message: POGOProtos.Rpc.IInternalSyncContactListResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSyncContactListResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSyncContactListResponse;
            public static toObject(message: POGOProtos.Rpc.InternalSyncContactListResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalSyncContactListResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3,
                ERROR_EXCEEDS_MAX_CONTACTS_PER_QUERY = 4
            }

            interface IContactPlayerProto {
                contact_id?: (string|null);
                player?: (POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.IPlayerProto[]|null);
                status?: (POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.ContactStatus|null);
            }

            class ContactPlayerProto implements IContactPlayerProto {
                constructor(properties?: POGOProtos.Rpc.InternalSyncContactListResponse.IContactPlayerProto);
                public contact_id: string;
                public player: POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.IPlayerProto[];
                public status: POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.ContactStatus;
                public static encode(message: POGOProtos.Rpc.InternalSyncContactListResponse.IContactPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto;
                public static toObject(message: POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ContactPlayerProto {

                enum ContactStatus {
                    UNSET = 0,
                    INVITED = 1,
                    REMOVED = 2
                }

                interface IPlayerProto {
                    is_calling_game_player?: (boolean|null);
                    is_newly_signed_up_player?: (boolean|null);
                    is_self?: (boolean|null);
                    is_friend?: (boolean|null);
                }

                class PlayerProto implements IPlayerProto {
                    constructor(properties?: POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.IPlayerProto);
                    public is_calling_game_player: boolean;
                    public is_newly_signed_up_player: boolean;
                    public is_self: boolean;
                    public is_friend: boolean;
                    public static encode(message: POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.IPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.PlayerProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.PlayerProto;
                    public static toObject(message: POGOProtos.Rpc.InternalSyncContactListResponse.ContactPlayerProto.PlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IInternalTemplateVariable {
            name?: (string|null);
            literal?: (string|null);
            key?: (string|null);
            lookup_table?: (string|null);
            byte_value?: (Uint8Array|null);
        }

        class InternalTemplateVariable implements IInternalTemplateVariable {
            constructor(properties?: POGOProtos.Rpc.IInternalTemplateVariable);
            public name: string;
            public literal: string;
            public key: string;
            public lookup_table: string;
            public byte_value: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalTemplateVariable, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalTemplateVariable;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalTemplateVariable;
            public static toObject(message: POGOProtos.Rpc.InternalTemplateVariable, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUnblockAccountOutProto {
            result?: (POGOProtos.Rpc.InternalUnblockAccountOutProto.Result|null);
        }

        class InternalUnblockAccountOutProto implements IInternalUnblockAccountOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUnblockAccountOutProto);
            public result: POGOProtos.Rpc.InternalUnblockAccountOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalUnblockAccountOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUnblockAccountOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUnblockAccountOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalUnblockAccountOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUnblockAccountOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_BLOCKED = 2,
                ERROR_PLAYER_DOES_NOT_EXIST = 3
            }
        }

        interface IInternalUnblockAccountProto {
            blockee_nia_account_id?: (string|null);
        }

        class InternalUnblockAccountProto implements IInternalUnblockAccountProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUnblockAccountProto);
            public blockee_nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalUnblockAccountProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUnblockAccountProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUnblockAccountProto;
            public static toObject(message: POGOProtos.Rpc.InternalUnblockAccountProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUntombstoneCodenameResult {
            codename?: (string|null);
            status?: (POGOProtos.Rpc.InternalUntombstoneCodenameResult.Status|null);
            nia_account_id?: (string|null);
            app_id?: (string|null);
        }

        class InternalUntombstoneCodenameResult implements IInternalUntombstoneCodenameResult {
            constructor(properties?: POGOProtos.Rpc.IInternalUntombstoneCodenameResult);
            public codename: string;
            public status: POGOProtos.Rpc.InternalUntombstoneCodenameResult.Status;
            public nia_account_id: string;
            public app_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalUntombstoneCodenameResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUntombstoneCodenameResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUntombstoneCodenameResult;
            public static toObject(message: POGOProtos.Rpc.InternalUntombstoneCodenameResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUntombstoneCodenameResult {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                CODENAME_NOT_FOUND = 2
            }
        }

        interface IInternalUntombstoneResult {
            username?: (string|null);
            status?: (POGOProtos.Rpc.InternalUntombstoneResult.Status|null);
            nia_account_id?: (string|null);
        }

        class InternalUntombstoneResult implements IInternalUntombstoneResult {
            constructor(properties?: POGOProtos.Rpc.IInternalUntombstoneResult);
            public username: string;
            public status: POGOProtos.Rpc.InternalUntombstoneResult.Status;
            public nia_account_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalUntombstoneResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUntombstoneResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUntombstoneResult;
            public static toObject(message: POGOProtos.Rpc.InternalUntombstoneResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUntombstoneResult {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                USERNAME_NOT_FOUND = 2
            }
        }

        interface IInternalUpdateAdventureSyncFitnessRequestProto {
            fitness_samples?: (POGOProtos.Rpc.IInternalFitnessSample[]|null);
        }

        class InternalUpdateAdventureSyncFitnessRequestProto implements IInternalUpdateAdventureSyncFitnessRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateAdventureSyncFitnessRequestProto);
            public fitness_samples: POGOProtos.Rpc.IInternalFitnessSample[];
            public static encode(message: POGOProtos.Rpc.IInternalUpdateAdventureSyncFitnessRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdateAdventureSyncFitnessResponseProto {
            status?: (POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessResponseProto.Status|null);
        }

        class InternalUpdateAdventureSyncFitnessResponseProto implements IInternalUpdateAdventureSyncFitnessResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateAdventureSyncFitnessResponseProto);
            public status: POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateAdventureSyncFitnessResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateAdventureSyncFitnessResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateAdventureSyncFitnessResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IInternalUpdateAdventureSyncSettingsRequestProto {
            adventure_sync_settings?: (POGOProtos.Rpc.IInternalAdventureSyncSettingsProto|null);
        }

        class InternalUpdateAdventureSyncSettingsRequestProto implements IInternalUpdateAdventureSyncSettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateAdventureSyncSettingsRequestProto);
            public adventure_sync_settings?: (POGOProtos.Rpc.IInternalAdventureSyncSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalUpdateAdventureSyncSettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdateAdventureSyncSettingsResponseProto {
            status?: (POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsResponseProto.Status|null);
        }

        class InternalUpdateAdventureSyncSettingsResponseProto implements IInternalUpdateAdventureSyncSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateAdventureSyncSettingsResponseProto);
            public status: POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateAdventureSyncSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateAdventureSyncSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateAdventureSyncSettingsResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IInternalUpdateAvatarImageRequest {
            image_spec?: (POGOProtos.Rpc.InternalAvatarImageMetadata.ImageSpec|null);
            avatar_image?: (POGOProtos.Rpc.InternalUpdateAvatarImageRequest.IAvatarImageProto|null);
        }

        class InternalUpdateAvatarImageRequest implements IInternalUpdateAvatarImageRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateAvatarImageRequest);
            public image_spec: POGOProtos.Rpc.InternalAvatarImageMetadata.ImageSpec;
            public avatar_image?: (POGOProtos.Rpc.InternalUpdateAvatarImageRequest.IAvatarImageProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalUpdateAvatarImageRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAvatarImageRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAvatarImageRequest;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateAvatarImageRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateAvatarImageRequest {

            interface IAvatarImageProto {
                avatar_hash?: (string|null);
                photo_id?: (string|null);
            }

            class AvatarImageProto implements IAvatarImageProto {
                constructor(properties?: POGOProtos.Rpc.InternalUpdateAvatarImageRequest.IAvatarImageProto);
                public avatar_hash: string;
                public photo_id: string;
                public static encode(message: POGOProtos.Rpc.InternalUpdateAvatarImageRequest.IAvatarImageProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAvatarImageRequest.AvatarImageProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAvatarImageRequest.AvatarImageProto;
                public static toObject(message: POGOProtos.Rpc.InternalUpdateAvatarImageRequest.AvatarImageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalUpdateAvatarImageResponse {
            status?: (POGOProtos.Rpc.InternalUpdateAvatarImageResponse.Status|null);
        }

        class InternalUpdateAvatarImageResponse implements IInternalUpdateAvatarImageResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateAvatarImageResponse);
            public status: POGOProtos.Rpc.InternalUpdateAvatarImageResponse.Status;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateAvatarImageResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateAvatarImageResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateAvatarImageResponse;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateAvatarImageResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateAvatarImageResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                UNKNOWN_ERROR = 2
            }
        }

        interface IInternalUpdateBreadcrumbHistoryRequestProto {
            session_context?: (string|null);
            breadcrumb_history?: (POGOProtos.Rpc.IInternalBreadcrumbRecordProto[]|null);
            initial_update?: (boolean|null);
        }

        class InternalUpdateBreadcrumbHistoryRequestProto implements IInternalUpdateBreadcrumbHistoryRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateBreadcrumbHistoryRequestProto);
            public session_context: string;
            public breadcrumb_history: POGOProtos.Rpc.IInternalBreadcrumbRecordProto[];
            public initial_update: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateBreadcrumbHistoryRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdateBreadcrumbHistoryResponseProto {
            status?: (POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryResponseProto.Status|null);
        }

        class InternalUpdateBreadcrumbHistoryResponseProto implements IInternalUpdateBreadcrumbHistoryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateBreadcrumbHistoryResponseProto);
            public status: POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateBreadcrumbHistoryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateBreadcrumbHistoryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateBreadcrumbHistoryResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IInternalUpdateBulkPlayerLocationRequestProto {
            location_ping_update?: (POGOProtos.Rpc.IInternalLocationPingUpdateProto[]|null);
        }

        class InternalUpdateBulkPlayerLocationRequestProto implements IInternalUpdateBulkPlayerLocationRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateBulkPlayerLocationRequestProto);
            public location_ping_update: POGOProtos.Rpc.IInternalLocationPingUpdateProto[];
            public static encode(message: POGOProtos.Rpc.IInternalUpdateBulkPlayerLocationRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateBulkPlayerLocationRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateBulkPlayerLocationRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateBulkPlayerLocationRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdateBulkPlayerLocationResponseProto {
            status?: (POGOProtos.Rpc.InternalUpdateBulkPlayerLocationResponseProto.Status|null);
        }

        class InternalUpdateBulkPlayerLocationResponseProto implements IInternalUpdateBulkPlayerLocationResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateBulkPlayerLocationResponseProto);
            public status: POGOProtos.Rpc.InternalUpdateBulkPlayerLocationResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateBulkPlayerLocationResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateBulkPlayerLocationResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateBulkPlayerLocationResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateBulkPlayerLocationResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateBulkPlayerLocationResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IInternalUpdateFacebookStatusOutProto {
            result?: (POGOProtos.Rpc.InternalUpdateFacebookStatusOutProto.Result|null);
        }

        class InternalUpdateFacebookStatusOutProto implements IInternalUpdateFacebookStatusOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateFacebookStatusOutProto);
            public result: POGOProtos.Rpc.InternalUpdateFacebookStatusOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateFacebookStatusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateFacebookStatusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateFacebookStatusOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateFacebookStatusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateFacebookStatusOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3,
                ERROR_FACEBOOK_API = 4,
                ERROR_ALREADY_EXISTS = 5
            }
        }

        interface IInternalUpdateFacebookStatusProto {
            fb_access_token?: (string|null);
            force_update?: (boolean|null);
        }

        class InternalUpdateFacebookStatusProto implements IInternalUpdateFacebookStatusProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateFacebookStatusProto);
            public fb_access_token: string;
            public force_update: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateFacebookStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateFacebookStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateFacebookStatusProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateFacebookStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdateFriendshipRequest {
            friend_id?: (string|null);
            friend_nia_account_id?: (string|null);
            friend_profile?: (POGOProtos.Rpc.InternalUpdateFriendshipRequest.IFriendProfileProto|null);
        }

        class InternalUpdateFriendshipRequest implements IInternalUpdateFriendshipRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateFriendshipRequest);
            public friend_id: string;
            public friend_nia_account_id: string;
            public friend_profile?: (POGOProtos.Rpc.InternalUpdateFriendshipRequest.IFriendProfileProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalUpdateFriendshipRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateFriendshipRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateFriendshipRequest;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateFriendshipRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateFriendshipRequest {

            interface IFriendProfileProto {
                nickname?: (string|null);
            }

            class FriendProfileProto implements IFriendProfileProto {
                constructor(properties?: POGOProtos.Rpc.InternalUpdateFriendshipRequest.IFriendProfileProto);
                public nickname: string;
                public static encode(message: POGOProtos.Rpc.InternalUpdateFriendshipRequest.IFriendProfileProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateFriendshipRequest.FriendProfileProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateFriendshipRequest.FriendProfileProto;
                public static toObject(message: POGOProtos.Rpc.InternalUpdateFriendshipRequest.FriendProfileProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalUpdateFriendshipResponse {
            result?: (POGOProtos.Rpc.InternalUpdateFriendshipResponse.Result|null);
        }

        class InternalUpdateFriendshipResponse implements IInternalUpdateFriendshipResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateFriendshipResponse);
            public result: POGOProtos.Rpc.InternalUpdateFriendshipResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateFriendshipResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateFriendshipResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateFriendshipResponse;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateFriendshipResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateFriendshipResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FRIEND = 3,
                ERROR_NICKNAME_WRONG_FORMAT = 4,
                ERROR_FILTERED_NICKNAME = 5,
                ERROR_EXCEEDED_CHANGE_LIMIT = 6
            }
        }

        interface IInternalUpdateIncomingGameInviteRequest {
            app_key?: (string|null);
            new_status?: (POGOProtos.Rpc.InternalUpdateIncomingGameInviteRequest.NewStatus|null);
        }

        class InternalUpdateIncomingGameInviteRequest implements IInternalUpdateIncomingGameInviteRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateIncomingGameInviteRequest);
            public app_key: string;
            public new_status: POGOProtos.Rpc.InternalUpdateIncomingGameInviteRequest.NewStatus;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateIncomingGameInviteRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateIncomingGameInviteRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateIncomingGameInviteRequest;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateIncomingGameInviteRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateIncomingGameInviteRequest {

            enum NewStatus {
                UNSET = 0,
                SEEN = 1,
                READ = 2
            }
        }

        interface IInternalUpdateIncomingGameInviteResponse {
            result?: (POGOProtos.Rpc.InternalUpdateIncomingGameInviteResponse.Result|null);
        }

        class InternalUpdateIncomingGameInviteResponse implements IInternalUpdateIncomingGameInviteResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateIncomingGameInviteResponse);
            public result: POGOProtos.Rpc.InternalUpdateIncomingGameInviteResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateIncomingGameInviteResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateIncomingGameInviteResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateIncomingGameInviteResponse;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateIncomingGameInviteResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateIncomingGameInviteResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IInternalUpdateNotificationOutProto {
            state?: (POGOProtos.Rpc.InternalNotificationState|null);
        }

        class InternalUpdateNotificationOutProto implements IInternalUpdateNotificationOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateNotificationOutProto);
            public state: POGOProtos.Rpc.InternalNotificationState;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateNotificationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateNotificationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateNotificationOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateNotificationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdateNotificationProto {
            notification_ids?: (string[]|null);
            create_timestamp_ms?: ((number|Long)[]|null);
            state?: (POGOProtos.Rpc.InternalNotificationState|null);
        }

        class InternalUpdateNotificationProto implements IInternalUpdateNotificationProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateNotificationProto);
            public notification_ids: string[];
            public create_timestamp_ms: (number|Long)[];
            public state: POGOProtos.Rpc.InternalNotificationState;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateNotificationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateNotificationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateNotificationProto;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateNotificationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdatePhoneNumberRequest {
            phone_number?: (string|null);
            verification_code?: (string|null);
            country_code?: (string|null);
            contact_id?: (string|null);
        }

        class InternalUpdatePhoneNumberRequest implements IInternalUpdatePhoneNumberRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdatePhoneNumberRequest);
            public phone_number: string;
            public verification_code: string;
            public country_code: string;
            public contact_id: string;
            public static encode(message: POGOProtos.Rpc.IInternalUpdatePhoneNumberRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdatePhoneNumberRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdatePhoneNumberRequest;
            public static toObject(message: POGOProtos.Rpc.InternalUpdatePhoneNumberRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUpdatePhoneNumberResponse {
            status?: (POGOProtos.Rpc.InternalUpdatePhoneNumberResponse.Status|null);
            error_message?: (string|null);
        }

        class InternalUpdatePhoneNumberResponse implements IInternalUpdatePhoneNumberResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdatePhoneNumberResponse);
            public status: POGOProtos.Rpc.InternalUpdatePhoneNumberResponse.Status;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IInternalUpdatePhoneNumberResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdatePhoneNumberResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdatePhoneNumberResponse;
            public static toObject(message: POGOProtos.Rpc.InternalUpdatePhoneNumberResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdatePhoneNumberResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_WRONG_VERIFICATION_CODE = 2,
                ERROR_UNKNOWN = 3,
                ERROR_CONTACT_NOT_FOUND = 4,
                ERROR_TOO_FREQUENT_ATTEMPTS = 5,
                ERROR_TOO_MANY_ATTEMPTS = 6
            }
        }

        interface IInternalUpdateProfileRequest {
            profile?: (POGOProtos.Rpc.InternalUpdateProfileRequest.IProfileProto|null);
        }

        class InternalUpdateProfileRequest implements IInternalUpdateProfileRequest {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateProfileRequest);
            public profile?: (POGOProtos.Rpc.InternalUpdateProfileRequest.IProfileProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalUpdateProfileRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateProfileRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateProfileRequest;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateProfileRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateProfileRequest {

            interface IProfileProto {
                profile_name_app_key?: (string|null);
            }

            class ProfileProto implements IProfileProto {
                constructor(properties?: POGOProtos.Rpc.InternalUpdateProfileRequest.IProfileProto);
                public profile_name_app_key: string;
                public static encode(message: POGOProtos.Rpc.InternalUpdateProfileRequest.IProfileProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateProfileRequest.ProfileProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateProfileRequest.ProfileProto;
                public static toObject(message: POGOProtos.Rpc.InternalUpdateProfileRequest.ProfileProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInternalUpdateProfileResponse {
            result?: (POGOProtos.Rpc.InternalUpdateProfileResponse.Result|null);
        }

        class InternalUpdateProfileResponse implements IInternalUpdateProfileResponse {
            constructor(properties?: POGOProtos.Rpc.IInternalUpdateProfileResponse);
            public result: POGOProtos.Rpc.InternalUpdateProfileResponse.Result;
            public static encode(message: POGOProtos.Rpc.IInternalUpdateProfileResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUpdateProfileResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUpdateProfileResponse;
            public static toObject(message: POGOProtos.Rpc.InternalUpdateProfileResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalUpdateProfileResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_EMPTY_PROFILE_NAME = 3
            }
        }

        interface IInternalUploadPoiPhotoByUrlOutProto {
            status?: (POGOProtos.Rpc.InternalPortalCurationImageResult.Result|null);
        }

        class InternalUploadPoiPhotoByUrlOutProto implements IInternalUploadPoiPhotoByUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUploadPoiPhotoByUrlOutProto);
            public status: POGOProtos.Rpc.InternalPortalCurationImageResult.Result;
            public static encode(message: POGOProtos.Rpc.IInternalUploadPoiPhotoByUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUploadPoiPhotoByUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUploadPoiPhotoByUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.InternalUploadPoiPhotoByUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalUploadPoiPhotoByUrlProto {
            request_id?: (string|null);
            image_url?: (string|null);
        }

        class InternalUploadPoiPhotoByUrlProto implements IInternalUploadPoiPhotoByUrlProto {
            constructor(properties?: POGOProtos.Rpc.IInternalUploadPoiPhotoByUrlProto);
            public request_id: string;
            public image_url: string;
            public static encode(message: POGOProtos.Rpc.IInternalUploadPoiPhotoByUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalUploadPoiPhotoByUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalUploadPoiPhotoByUrlProto;
            public static toObject(message: POGOProtos.Rpc.InternalUploadPoiPhotoByUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalValidateNiaAppleAuthTokenRequestProto {
            nia_apple_auth_token?: (Uint8Array|null);
        }

        class InternalValidateNiaAppleAuthTokenRequestProto implements IInternalValidateNiaAppleAuthTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.IInternalValidateNiaAppleAuthTokenRequestProto);
            public nia_apple_auth_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IInternalValidateNiaAppleAuthTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInternalValidateNiaAppleAuthTokenResponseProto {
            status?: (POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenResponseProto.Status|null);
        }

        class InternalValidateNiaAppleAuthTokenResponseProto implements IInternalValidateNiaAppleAuthTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.IInternalValidateNiaAppleAuthTokenResponseProto);
            public status: POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IInternalValidateNiaAppleAuthTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.InternalValidateNiaAppleAuthTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalValidateNiaAppleAuthTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_AUTH = 2,
                EXPIRED_AUTH = 3,
                SERVER_ERROR = 4
            }
        }

        interface IInternalWeatherAlertProto {
            severity?: (POGOProtos.Rpc.InternalWeatherAlertProto.Severity|null);
            warn_weather?: (boolean|null);
        }

        class InternalWeatherAlertProto implements IInternalWeatherAlertProto {
            constructor(properties?: POGOProtos.Rpc.IInternalWeatherAlertProto);
            public severity: POGOProtos.Rpc.InternalWeatherAlertProto.Severity;
            public warn_weather: boolean;
            public static encode(message: POGOProtos.Rpc.IInternalWeatherAlertProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherAlertProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherAlertProto;
            public static toObject(message: POGOProtos.Rpc.InternalWeatherAlertProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalWeatherAlertProto {

            enum Severity {
                NONE = 0,
                MODERATE = 1,
                EXTREME = 2
            }
        }

        interface IInternalWeatherAlertSettingsProto {
            warn_weather?: (boolean|null);
            default_severity?: (POGOProtos.Rpc.InternalWeatherAlertProto.Severity|null);
            ignores?: (POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertIgnoreSettings[]|null);
            enforces?: (POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertEnforceSettings[]|null);
        }

        class InternalWeatherAlertSettingsProto implements IInternalWeatherAlertSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalWeatherAlertSettingsProto);
            public warn_weather: boolean;
            public default_severity: POGOProtos.Rpc.InternalWeatherAlertProto.Severity;
            public ignores: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertIgnoreSettings[];
            public enforces: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertEnforceSettings[];
            public static encode(message: POGOProtos.Rpc.IInternalWeatherAlertSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherAlertSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherAlertSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalWeatherAlertSettingsProto {

            interface IAlertEnforceSettings {
                country_code?: (string|null);
                when?: (POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition|null);
            }

            class AlertEnforceSettings implements IAlertEnforceSettings {
                constructor(properties?: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertEnforceSettings);
                public country_code: string;
                public when?: (POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition|null);
                public static encode(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertEnforceSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings;
                public static toObject(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AlertEnforceSettings {

                interface IEnforceCondition {
                    color?: (string[]|null);
                    type?: (string[]|null);
                    category?: (string[]|null);
                }

                class EnforceCondition implements IEnforceCondition {
                    constructor(properties?: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition);
                    public color: string[];
                    public type: string[];
                    public category: string[];
                    public static encode(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.EnforceCondition;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.EnforceCondition;
                    public static toObject(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertEnforceSettings.EnforceCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IAlertIgnoreSettings {
                country_code?: (string|null);
                when?: (POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition|null);
            }

            class AlertIgnoreSettings implements IAlertIgnoreSettings {
                constructor(properties?: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertIgnoreSettings);
                public country_code: string;
                public when?: (POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition|null);
                public static encode(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.IAlertIgnoreSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings;
                public static toObject(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AlertIgnoreSettings {

                interface IOverrideCondition {
                    color?: (string[]|null);
                    type?: (string[]|null);
                }

                class OverrideCondition implements IOverrideCondition {
                    constructor(properties?: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition);
                    public color: string[];
                    public type: string[];
                    public static encode(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.OverrideCondition;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.OverrideCondition;
                    public static toObject(message: POGOProtos.Rpc.InternalWeatherAlertSettingsProto.AlertIgnoreSettings.OverrideCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IInternalWeatherSettingsProto {
            gameplay_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.IGameplayWeatherSettingsProto|null);
            display_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.IDisplayWeatherSettingsProto|null);
            alert_settings?: (POGOProtos.Rpc.IInternalWeatherAlertSettingsProto|null);
            stale_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.IStaleWeatherSettingsProto|null);
        }

        class InternalWeatherSettingsProto implements IInternalWeatherSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInternalWeatherSettingsProto);
            public gameplay_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.IGameplayWeatherSettingsProto|null);
            public display_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.IDisplayWeatherSettingsProto|null);
            public alert_settings?: (POGOProtos.Rpc.IInternalWeatherAlertSettingsProto|null);
            public stale_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.IStaleWeatherSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IInternalWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto;
            public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InternalWeatherSettingsProto {

            interface IDisplayWeatherSettingsProto {
                display_level_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings[]|null);
                wind_level_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings|null);
            }

            class DisplayWeatherSettingsProto implements IDisplayWeatherSettingsProto {
                constructor(properties?: POGOProtos.Rpc.InternalWeatherSettingsProto.IDisplayWeatherSettingsProto);
                public display_level_settings: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings[];
                public wind_level_settings?: (POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings|null);
                public static encode(message: POGOProtos.Rpc.InternalWeatherSettingsProto.IDisplayWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto;
                public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DisplayWeatherSettingsProto {

                interface IDisplayLevelSettings {
                    condition_enums?: (string[]|null);
                    cloud_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
                    rain_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
                    snow_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
                    fog_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
                    special_effect_level?: (POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel|null);
                }

                class DisplayLevelSettings implements IDisplayLevelSettings {
                    constructor(properties?: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings);
                    public condition_enums: string[];
                    public cloud_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
                    public rain_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
                    public snow_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
                    public fog_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
                    public special_effect_level: POGOProtos.Rpc.InternalDisplayWeatherProto.DisplayLevel;
                    public static encode(message: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.DisplayLevelSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.DisplayLevelSettings;
                    public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.DisplayLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWindLevelSettings {
                    wind_level1_speed?: (number|null);
                    wind_level2_speed?: (number|null);
                    wind_level3_speed?: (number|null);
                }

                class WindLevelSettings implements IWindLevelSettings {
                    constructor(properties?: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings);
                    public wind_level1_speed: number;
                    public wind_level2_speed: number;
                    public wind_level3_speed: number;
                    public static encode(message: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.WindLevelSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.WindLevelSettings;
                    public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto.DisplayWeatherSettingsProto.WindLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IGameplayWeatherSettingsProto {
                condition_map?: (POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings[]|null);
                min_speed_for_windy?: (number|null);
                conditions_for_windy?: (string[]|null);
            }

            class GameplayWeatherSettingsProto implements IGameplayWeatherSettingsProto {
                constructor(properties?: POGOProtos.Rpc.InternalWeatherSettingsProto.IGameplayWeatherSettingsProto);
                public condition_map: POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings[];
                public min_speed_for_windy: number;
                public conditions_for_windy: string[];
                public static encode(message: POGOProtos.Rpc.InternalWeatherSettingsProto.IGameplayWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto;
                public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GameplayWeatherSettingsProto {

                interface IConditionMapSettings {
                    gameplay_condition?: (POGOProtos.Rpc.InternalGameplayWeatherProto.WeatherCondition|null);
                    provider_enums?: (string[]|null);
                }

                class ConditionMapSettings implements IConditionMapSettings {
                    constructor(properties?: POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings);
                    public gameplay_condition: POGOProtos.Rpc.InternalGameplayWeatherProto.WeatherCondition;
                    public provider_enums: string[];
                    public static encode(message: POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.ConditionMapSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.ConditionMapSettings;
                    public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto.GameplayWeatherSettingsProto.ConditionMapSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IStaleWeatherSettingsProto {
                max_stale_weather_threshold_in_hrs?: (number|null);
                default_weather_condition_code?: (number|null);
            }

            class StaleWeatherSettingsProto implements IStaleWeatherSettingsProto {
                constructor(properties?: POGOProtos.Rpc.InternalWeatherSettingsProto.IStaleWeatherSettingsProto);
                public max_stale_weather_threshold_in_hrs: number;
                public default_weather_condition_code: number;
                public static encode(message: POGOProtos.Rpc.InternalWeatherSettingsProto.IStaleWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InternalWeatherSettingsProto.StaleWeatherSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InternalWeatherSettingsProto.StaleWeatherSettingsProto;
                public static toObject(message: POGOProtos.Rpc.InternalWeatherSettingsProto.StaleWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInvasionAvailabilitySettingsProto {
            availability_start_minute?: (number|Long|null);
            availability_end_minute?: (number|Long|null);
        }

        class InvasionAvailabilitySettingsProto implements IInvasionAvailabilitySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInvasionAvailabilitySettingsProto);
            public availability_start_minute: (number|Long);
            public availability_end_minute: (number|Long);
            public static encode(message: POGOProtos.Rpc.IInvasionAvailabilitySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionAvailabilitySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionAvailabilitySettingsProto;
            public static toObject(message: POGOProtos.Rpc.InvasionAvailabilitySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InvasionAvailabilitySettingsProto {

            enum InvasionAvailabilitySettingsId {
                INVASION_AVAILABILITY_SETTINGS_UNSET = 0,
                INVASION_AVAILABILITY_SETTINGS_MONDAY = 1,
                INVASION_AVAILABILITY_SETTINGS_TUESDAY = 2,
                INVASION_AVAILABILITY_SETTINGS_WEDNESDAY = 3,
                INVASION_AVAILABILITY_SETTINGS_THURSDAY = 4,
                INVASION_AVAILABILITY_SETTINGS_FRIDAY = 5,
                INVASION_AVAILABILITY_SETTINGS_SATURDAY = 6,
                INVASION_AVAILABILITY_SETTINGS_SUNDAY = 7
            }
        }

        interface IInvasionBattleResponseUpdate {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            status?: (POGOProtos.Rpc.InvasionStatus.Status|null);
        }

        class InvasionBattleResponseUpdate implements IInvasionBattleResponseUpdate {
            constructor(properties?: POGOProtos.Rpc.IInvasionBattleResponseUpdate);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public status: POGOProtos.Rpc.InvasionStatus.Status;
            public static encode(message: POGOProtos.Rpc.IInvasionBattleResponseUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionBattleResponseUpdate;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionBattleResponseUpdate;
            public static toObject(message: POGOProtos.Rpc.InvasionBattleResponseUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionBattleUpdate {
            rpc_id?: (number|null);
            step?: (number|null);
            complete_battle?: (boolean|null);
            update_type?: (POGOProtos.Rpc.UpdateInvasionBattleProto.UpdateType|null);
            lobby_join_time_offset_ms?: (number|null);
        }

        class InvasionBattleUpdate implements IInvasionBattleUpdate {
            constructor(properties?: POGOProtos.Rpc.IInvasionBattleUpdate);
            public rpc_id: number;
            public step: number;
            public complete_battle: boolean;
            public update_type: POGOProtos.Rpc.UpdateInvasionBattleProto.UpdateType;
            public lobby_join_time_offset_ms: number;
            public static encode(message: POGOProtos.Rpc.IInvasionBattleUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionBattleUpdate;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionBattleUpdate;
            public static toObject(message: POGOProtos.Rpc.InvasionBattleUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionCreateDetail {
            origin?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
        }

        class InvasionCreateDetail implements IInvasionCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IInvasionCreateDetail);
            public origin: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public static encode(message: POGOProtos.Rpc.IInvasionCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionCreateDetail;
            public static toObject(message: POGOProtos.Rpc.InvasionCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionEncounterOutProto {
            status?: (POGOProtos.Rpc.InvasionStatus.Status|null);
            encounter_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            throws_remaining?: (number|null);
            encounter_id?: (number|Long|null);
            spawn_point_guid?: (string|null);
            balls_display?: (POGOProtos.Rpc.InvasionEncounterOutProto.IPremierBallsDisplayProto|null);
            invasion_ball?: (POGOProtos.Rpc.Item|null);
            applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto|null);
        }

        class InvasionEncounterOutProto implements IInvasionEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IInvasionEncounterOutProto);
            public status: POGOProtos.Rpc.InvasionStatus.Status;
            public encounter_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public throws_remaining: number;
            public encounter_id: (number|Long);
            public spawn_point_guid: string;
            public balls_display?: (POGOProtos.Rpc.InvasionEncounterOutProto.IPremierBallsDisplayProto|null);
            public invasion_ball: POGOProtos.Rpc.Item;
            public applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto|null);
            public static encode(message: POGOProtos.Rpc.IInvasionEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.InvasionEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InvasionEncounterOutProto {

            interface IPremierBallsDisplayProto {
                base_num_balls?: (number|null);
                pokemon_purified_num_balls?: (number|null);
                grunts_defeated_num_balls?: (number|null);
                pokemon_remaining_num_balls?: (number|null);
            }

            class PremierBallsDisplayProto implements IPremierBallsDisplayProto {
                constructor(properties?: POGOProtos.Rpc.InvasionEncounterOutProto.IPremierBallsDisplayProto);
                public base_num_balls: number;
                public pokemon_purified_num_balls: number;
                public grunts_defeated_num_balls: number;
                public pokemon_remaining_num_balls: number;
                public static encode(message: POGOProtos.Rpc.InvasionEncounterOutProto.IPremierBallsDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionEncounterOutProto.PremierBallsDisplayProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionEncounterOutProto.PremierBallsDisplayProto;
                public static toObject(message: POGOProtos.Rpc.InvasionEncounterOutProto.PremierBallsDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInvasionEncounterProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            step?: (number|null);
        }

        class InvasionEncounterProto implements IInvasionEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IInvasionEncounterProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public step: number;
            public static encode(message: POGOProtos.Rpc.IInvasionEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionEncounterProto;
            public static toObject(message: POGOProtos.Rpc.InvasionEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionFinishedDisplayProto {
            style?: (POGOProtos.Rpc.EnumWrapper.PokestopStyle|null);
        }

        class InvasionFinishedDisplayProto implements IInvasionFinishedDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IInvasionFinishedDisplayProto);
            public style: POGOProtos.Rpc.EnumWrapper.PokestopStyle;
            public static encode(message: POGOProtos.Rpc.IInvasionFinishedDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionFinishedDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionFinishedDisplayProto;
            public static toObject(message: POGOProtos.Rpc.InvasionFinishedDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionNpcDisplaySettingsProto {
            trainer_name?: (string|null);
            avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            trainer_title?: (string|null);
            trainer_quote?: (string|null);
            icon_url?: (string|null);
            backdrop_image_bundle?: (string|null);
            model_name?: (string|null);
            tutorial_on_loss_string?: (string|null);
            is_male?: (boolean|null);
            custom_incident_music?: (string|null);
            custom_combat_music?: (string|null);
            tips_type?: (POGOProtos.Rpc.HoloPokemonType|null);
        }

        class InvasionNpcDisplaySettingsProto implements IInvasionNpcDisplaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInvasionNpcDisplaySettingsProto);
            public trainer_name: string;
            public avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public trainer_title: string;
            public trainer_quote: string;
            public icon_url: string;
            public backdrop_image_bundle: string;
            public model_name: string;
            public tutorial_on_loss_string: string;
            public is_male: boolean;
            public custom_incident_music: string;
            public custom_combat_music: string;
            public tips_type: POGOProtos.Rpc.HoloPokemonType;
            public static encode(message: POGOProtos.Rpc.IInvasionNpcDisplaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionNpcDisplaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionNpcDisplaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.InvasionNpcDisplaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionOpenCombatSessionData {
            rpc_id?: (number|null);
            type?: (POGOProtos.Rpc.CombatType|null);
            attacking_pokemon_indexes?: (number[]|null);
            lobby_join_time_offset_ms?: (number|null);
            step?: (number|null);
        }

        class InvasionOpenCombatSessionData implements IInvasionOpenCombatSessionData {
            constructor(properties?: POGOProtos.Rpc.IInvasionOpenCombatSessionData);
            public rpc_id: number;
            public type: POGOProtos.Rpc.CombatType;
            public attacking_pokemon_indexes: number[];
            public lobby_join_time_offset_ms: number;
            public step: number;
            public static encode(message: POGOProtos.Rpc.IInvasionOpenCombatSessionData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionOpenCombatSessionData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionOpenCombatSessionData;
            public static toObject(message: POGOProtos.Rpc.InvasionOpenCombatSessionData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionOpenCombatSessionResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.InvasionStatus.Status|null);
            combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
        }

        class InvasionOpenCombatSessionResponseData implements IInvasionOpenCombatSessionResponseData {
            constructor(properties?: POGOProtos.Rpc.IInvasionOpenCombatSessionResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.InvasionStatus.Status;
            public combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
            public static encode(message: POGOProtos.Rpc.IInvasionOpenCombatSessionResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionOpenCombatSessionResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionOpenCombatSessionResponseData;
            public static toObject(message: POGOProtos.Rpc.InvasionOpenCombatSessionResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionStatus {
            status?: (POGOProtos.Rpc.InvasionStatus.Status|null);
        }

        class InvasionStatus implements IInvasionStatus {
            constructor(properties?: POGOProtos.Rpc.IInvasionStatus);
            public status: POGOProtos.Rpc.InvasionStatus.Status;
            public static encode(message: POGOProtos.Rpc.IInvasionStatus, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionStatus;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionStatus;
            public static toObject(message: POGOProtos.Rpc.InvasionStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InvasionStatus {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_FORT_NOT_FOUND = 3,
                ERROR_INCIDENT_NOT_FOUND = 4,
                ERROR_STEP_ALREADY_COMPLETED = 5,
                ERROR_WRONG_STEP = 6,
                ERROR_PLAYER_BELOW_MIN_LEVEL = 7,
                ERROR_INCIDENT_EXPIRED = 8,
                ERROR_MISSING_INCIDENT_TICKET = 9,
                ERROR_ENCOUNTER_POKEMON_INVENTORY_FULL = 10,
                ERROR_PLAYER_BELOW_V2_MIN_LEVEL = 11,
                ERROR_RETRY = 12,
                ERROR_INVALID_HEALTH_UPDATES = 20,
                ERROR_ATTACKING_POKEMON_INVALID = 30
            }
        }

        interface IInvasionTelemetry {
            invasion_telemetry_id?: (POGOProtos.Rpc.InvasionTelemetryIds|null);
            npc_id?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
            battle_success?: (boolean|null);
            post_battle_friendly_remaining?: (number|null);
            post_battle_enemy_remaining?: (number|null);
            encounter_pokemon?: (number|null);
            encounter_success?: (boolean|null);
            invasion_id?: (string|null);
            player_tapped_npc?: (boolean|null);
            radar?: (string|null);
            curfew?: (boolean|null);
            duration?: (number|null);
            distance?: (number|null);
            invasion_context?: (POGOProtos.Rpc.EnumWrapper.InvasionContext|null);
            balloon_type?: (POGOProtos.Rpc.RocketBalloonDisplayProto.BalloonType|null);
        }

        class InvasionTelemetry implements IInvasionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IInvasionTelemetry);
            public invasion_telemetry_id: POGOProtos.Rpc.InvasionTelemetryIds;
            public npc_id: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public battle_success: boolean;
            public post_battle_friendly_remaining: number;
            public post_battle_enemy_remaining: number;
            public encounter_pokemon: number;
            public encounter_success: boolean;
            public invasion_id: string;
            public player_tapped_npc: boolean;
            public radar: string;
            public curfew: boolean;
            public duration: number;
            public distance: number;
            public invasion_context: POGOProtos.Rpc.EnumWrapper.InvasionContext;
            public balloon_type: POGOProtos.Rpc.RocketBalloonDisplayProto.BalloonType;
            public static encode(message: POGOProtos.Rpc.IInvasionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionTelemetry;
            public static toObject(message: POGOProtos.Rpc.InvasionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInvasionVictoryLogEntry {
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            invasion_npc?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
        }

        class InvasionVictoryLogEntry implements IInvasionVictoryLogEntry {
            constructor(properties?: POGOProtos.Rpc.IInvasionVictoryLogEntry);
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public invasion_npc: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public static encode(message: POGOProtos.Rpc.IInvasionVictoryLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InvasionVictoryLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InvasionVictoryLogEntry;
            public static toObject(message: POGOProtos.Rpc.InvasionVictoryLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryDeltaProto {
            original_timestamp?: (number|Long|null);
            new_timestamp?: (number|Long|null);
            inventory_item?: (POGOProtos.Rpc.IInventoryItemProto[]|null);
        }

        class InventoryDeltaProto implements IInventoryDeltaProto {
            constructor(properties?: POGOProtos.Rpc.IInventoryDeltaProto);
            public original_timestamp: (number|Long);
            public new_timestamp: (number|Long);
            public inventory_item: POGOProtos.Rpc.IInventoryItemProto[];
            public static encode(message: POGOProtos.Rpc.IInventoryDeltaProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryDeltaProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryDeltaProto;
            public static toObject(message: POGOProtos.Rpc.InventoryDeltaProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryItemProto {
            deleted_item_key?: (POGOProtos.Rpc.IHoloInventoryKeyProto|null);
            inventory_item_data?: (POGOProtos.Rpc.IHoloInventoryItemProto|null);
            modified_timestamp?: (number|Long|null);
        }

        class InventoryItemProto implements IInventoryItemProto {
            constructor(properties?: POGOProtos.Rpc.IInventoryItemProto);
            public deleted_item_key?: (POGOProtos.Rpc.IHoloInventoryKeyProto|null);
            public inventory_item_data?: (POGOProtos.Rpc.IHoloInventoryItemProto|null);
            public modified_timestamp: (number|Long);
            public InventoryItem?: ("deleted_item_key"|"inventory_item_data");
            public static encode(message: POGOProtos.Rpc.IInventoryItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryItemProto;
            public static toObject(message: POGOProtos.Rpc.InventoryItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryProto {
            inventory_item?: (POGOProtos.Rpc.IInventoryItemProto[]|null);
            diff_inventory?: (POGOProtos.Rpc.InventoryProto.IDiffInventoryProto|null);
            inventory_type?: (POGOProtos.Rpc.InventoryProto.InventoryType|null);
        }

        class InventoryProto implements IInventoryProto {
            constructor(properties?: POGOProtos.Rpc.IInventoryProto);
            public inventory_item: POGOProtos.Rpc.IInventoryItemProto[];
            public diff_inventory?: (POGOProtos.Rpc.InventoryProto.IDiffInventoryProto|null);
            public inventory_type: POGOProtos.Rpc.InventoryProto.InventoryType;
            public static encode(message: POGOProtos.Rpc.IInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryProto;
            public static toObject(message: POGOProtos.Rpc.InventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InventoryProto {

            enum InventoryType {
                BINARY_BLOB = 0,
                DIFF = 1,
                COMPOSITE = 2
            }

            interface IDiffInventoryProto {
                item_changelog?: (POGOProtos.Rpc.IInventoryItemProto[]|null);
                diff_inventory_entity_last_compaction_ms?: (number|Long|null);
            }

            class DiffInventoryProto implements IDiffInventoryProto {
                constructor(properties?: POGOProtos.Rpc.InventoryProto.IDiffInventoryProto);
                public item_changelog: POGOProtos.Rpc.IInventoryItemProto[];
                public diff_inventory_entity_last_compaction_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.InventoryProto.IDiffInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryProto.DiffInventoryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryProto.DiffInventoryProto;
                public static toObject(message: POGOProtos.Rpc.InventoryProto.DiffInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInventorySettingsProto {
            max_pokemon?: (number|null);
            max_bag_items?: (number|null);
            base_pokemon?: (number|null);
            base_bag_items?: (number|null);
            base_eggs?: (number|null);
            max_team_changes?: (number|null);
            team_change_item_reset_period_in_days?: (number|Long|null);
            max_item_boost_duration_ms?: (number|Long|null);
            default_sticker_max_count?: (number|null);
            enable_eggs_not_inventory?: (boolean|null);
            special_egg_overflow_spots?: (number|null);
            enable_overflow_spot_sliding?: (boolean|null);
            can_raid_pass_overflow_bag_space?: (boolean|null);
            base_postcards?: (number|null);
            max_postcards?: (number|null);
            max_stone_acount?: (number|null);
            lucky_friend_applicator_settings_toggle_enabled?: (boolean|null);
            bag_upgrade_banner_enabled?: (boolean|null);
            bag_upgrade_timer_stages?: (POGOProtos.Rpc.InventorySettingsProto.IBagUpgradeStageProto[]|null);
            bag_upgrade_banner_contexts?: (POGOProtos.Rpc.InventoryGuiContext[]|null);
            easy_incubator_buy_enabled?: (boolean|null);
            default_enable_sticker_iap_overfill?: (boolean|null);
        }

        class InventorySettingsProto implements IInventorySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IInventorySettingsProto);
            public max_pokemon: number;
            public max_bag_items: number;
            public base_pokemon: number;
            public base_bag_items: number;
            public base_eggs: number;
            public max_team_changes: number;
            public team_change_item_reset_period_in_days: (number|Long);
            public max_item_boost_duration_ms: (number|Long);
            public default_sticker_max_count: number;
            public enable_eggs_not_inventory: boolean;
            public special_egg_overflow_spots: number;
            public enable_overflow_spot_sliding: boolean;
            public can_raid_pass_overflow_bag_space: boolean;
            public base_postcards: number;
            public max_postcards: number;
            public max_stone_acount: number;
            public lucky_friend_applicator_settings_toggle_enabled: boolean;
            public bag_upgrade_banner_enabled: boolean;
            public bag_upgrade_timer_stages: POGOProtos.Rpc.InventorySettingsProto.IBagUpgradeStageProto[];
            public bag_upgrade_banner_contexts: POGOProtos.Rpc.InventoryGuiContext[];
            public easy_incubator_buy_enabled: boolean;
            public default_enable_sticker_iap_overfill: boolean;
            public static encode(message: POGOProtos.Rpc.IInventorySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventorySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventorySettingsProto;
            public static toObject(message: POGOProtos.Rpc.InventorySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InventorySettingsProto {

            interface IBagUpgradeStageProto {
                dismiss_stage_secs?: (number|null);
            }

            class BagUpgradeStageProto implements IBagUpgradeStageProto {
                constructor(properties?: POGOProtos.Rpc.InventorySettingsProto.IBagUpgradeStageProto);
                public dismiss_stage_secs: number;
                public static encode(message: POGOProtos.Rpc.InventorySettingsProto.IBagUpgradeStageProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventorySettingsProto.BagUpgradeStageProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventorySettingsProto.BagUpgradeStageProto;
                public static toObject(message: POGOProtos.Rpc.InventorySettingsProto.BagUpgradeStageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IInventoryUpgradeAttributesProto {
            additional_storage?: (number|null);
            upgrade_type?: (POGOProtos.Rpc.InventoryUpgradeType|null);
        }

        class InventoryUpgradeAttributesProto implements IInventoryUpgradeAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IInventoryUpgradeAttributesProto);
            public additional_storage: number;
            public upgrade_type: POGOProtos.Rpc.InventoryUpgradeType;
            public static encode(message: POGOProtos.Rpc.IInventoryUpgradeAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryUpgradeAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryUpgradeAttributesProto;
            public static toObject(message: POGOProtos.Rpc.InventoryUpgradeAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryUpgradeProto {
            item?: (POGOProtos.Rpc.Item|null);
            upgrade_type?: (POGOProtos.Rpc.InventoryUpgradeType|null);
            additional_storage?: (number|null);
        }

        class InventoryUpgradeProto implements IInventoryUpgradeProto {
            constructor(properties?: POGOProtos.Rpc.IInventoryUpgradeProto);
            public item: POGOProtos.Rpc.Item;
            public upgrade_type: POGOProtos.Rpc.InventoryUpgradeType;
            public additional_storage: number;
            public static encode(message: POGOProtos.Rpc.IInventoryUpgradeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryUpgradeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryUpgradeProto;
            public static toObject(message: POGOProtos.Rpc.InventoryUpgradeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryUpgradesProto {
            inventory_upgrade?: (POGOProtos.Rpc.IInventoryUpgradeProto[]|null);
        }

        class InventoryUpgradesProto implements IInventoryUpgradesProto {
            constructor(properties?: POGOProtos.Rpc.IInventoryUpgradesProto);
            public inventory_upgrade: POGOProtos.Rpc.IInventoryUpgradeProto[];
            public static encode(message: POGOProtos.Rpc.IInventoryUpgradesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.InventoryUpgradesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.InventoryUpgradesProto;
            public static toObject(message: POGOProtos.Rpc.InventoryUpgradesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIosDevice {
            name?: (string|null);
            manufacturer?: (string|null);
            model?: (string|null);
            hardware?: (string|null);
            software?: (string|null);
        }

        class IosDevice implements IIosDevice {
            constructor(properties?: POGOProtos.Rpc.IIosDevice);
            public name: string;
            public manufacturer: string;
            public model: string;
            public hardware: string;
            public software: string;
            public static encode(message: POGOProtos.Rpc.IIosDevice, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IosDevice;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IosDevice;
            public static toObject(message: POGOProtos.Rpc.IosDevice, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIosSourceRevision {
            name?: (string|null);
            bundle?: (string|null);
            version?: (string|null);
            product?: (string|null);
            os?: (string|null);
        }

        class IosSourceRevision implements IIosSourceRevision {
            constructor(properties?: POGOProtos.Rpc.IIosSourceRevision);
            public name: string;
            public bundle: string;
            public version: string;
            public product: string;
            public os: string;
            public static encode(message: POGOProtos.Rpc.IIosSourceRevision, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IosSourceRevision;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IosSourceRevision;
            public static toObject(message: POGOProtos.Rpc.IosSourceRevision, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIrisPlayerPublicProfileInfo {
            profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            player_id?: (string|null);
        }

        class IrisPlayerPublicProfileInfo implements IIrisPlayerPublicProfileInfo {
            constructor(properties?: POGOProtos.Rpc.IIrisPlayerPublicProfileInfo);
            public profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.IIrisPlayerPublicProfileInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisPlayerPublicProfileInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisPlayerPublicProfileInfo;
            public static toObject(message: POGOProtos.Rpc.IrisPlayerPublicProfileInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIrisPokemonObjectProto {
            object_id?: (string|null);
            display_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            location?: (POGOProtos.Rpc.IGameObjectLocationData|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            pokeball_type?: (number|null);
            pokemon_size?: (number|null);
            deployed_timestamp_ms?: (number|Long|null);
            player_id?: (string|null);
            unique_pokemon_id?: (number|Long|null);
            pokedex_entry_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            is_ambassador?: (boolean|null);
        }

        class IrisPokemonObjectProto implements IIrisPokemonObjectProto {
            constructor(properties?: POGOProtos.Rpc.IIrisPokemonObjectProto);
            public object_id: string;
            public display_id: POGOProtos.Rpc.HoloPokemonId;
            public location?: (POGOProtos.Rpc.IGameObjectLocationData|null);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public pokeball_type: number;
            public pokemon_size: number;
            public deployed_timestamp_ms: (number|Long);
            public player_id: string;
            public unique_pokemon_id: (number|Long);
            public pokedex_entry_id: POGOProtos.Rpc.HoloPokemonId;
            public is_ambassador: boolean;
            public static encode(message: POGOProtos.Rpc.IIrisPokemonObjectProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisPokemonObjectProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisPokemonObjectProto;
            public static toObject(message: POGOProtos.Rpc.IrisPokemonObjectProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIrisSocialDeploymentProto {
            deployed_fort_id?: (string|null);
            pokemon_deployed_since_ms?: (number|Long|null);
            pokemon_returned_at_ms?: (number|Long|null);
        }

        class IrisSocialDeploymentProto implements IIrisSocialDeploymentProto {
            constructor(properties?: POGOProtos.Rpc.IIrisSocialDeploymentProto);
            public deployed_fort_id: string;
            public pokemon_deployed_since_ms: (number|Long);
            public pokemon_returned_at_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IIrisSocialDeploymentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialDeploymentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialDeploymentProto;
            public static toObject(message: POGOProtos.Rpc.IrisSocialDeploymentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIrisSocialEventTelemetry {
            ux_funnel_version?: (number|null);
            iris_social_event?: (POGOProtos.Rpc.IrisSocialEvent|null);
            funnel_step_number?: (number|null);
            vps_session_id?: (string|null);
            iris_session_id?: (string|null);
            performance_metrics?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialPerformanceMetrics|null);
            metadata?: ({ [k: string]: string }|null);
            camera_metadata?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialCameraMetadata|null);
            fort_id?: (string|null);
            client_timestamp_ms?: (number|Long|null);
            player_lat?: (number|null);
            player_lng?: (number|null);
            player_heading?: (number|null);
        }

        class IrisSocialEventTelemetry implements IIrisSocialEventTelemetry {
            constructor(properties?: POGOProtos.Rpc.IIrisSocialEventTelemetry);
            public ux_funnel_version: number;
            public iris_social_event: POGOProtos.Rpc.IrisSocialEvent;
            public funnel_step_number: number;
            public vps_session_id: string;
            public iris_session_id: string;
            public performance_metrics?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialPerformanceMetrics|null);
            public metadata: { [k: string]: string };
            public camera_metadata?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialCameraMetadata|null);
            public fort_id: string;
            public client_timestamp_ms: (number|Long);
            public player_lat: number;
            public player_lng: number;
            public player_heading: number;
            public static encode(message: POGOProtos.Rpc.IIrisSocialEventTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialEventTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialEventTelemetry;
            public static toObject(message: POGOProtos.Rpc.IrisSocialEventTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IrisSocialEventTelemetry {

            interface IIrisSocialPerformanceMetrics {
                frames_per_seconds?: (number|null);
                event_processing_time_ms?: (number|null);
                battery_life?: (number|null);
                active_memory_in_bytes?: (number|null);
            }

            class IrisSocialPerformanceMetrics implements IIrisSocialPerformanceMetrics {
                constructor(properties?: POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialPerformanceMetrics);
                public frames_per_seconds: number;
                public event_processing_time_ms: number;
                public battery_life: number;
                public active_memory_in_bytes: number;
                public static encode(message: POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialPerformanceMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialEventTelemetry.IrisSocialPerformanceMetrics;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialEventTelemetry.IrisSocialPerformanceMetrics;
                public static toObject(message: POGOProtos.Rpc.IrisSocialEventTelemetry.IrisSocialPerformanceMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IIrisSocialCameraMetadata {
                position?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition|null);
                rotation?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IRotation|null);
            }

            class IrisSocialCameraMetadata implements IIrisSocialCameraMetadata {
                constructor(properties?: POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialCameraMetadata);
                public position?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition|null);
                public rotation?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IRotation|null);
                public static encode(message: POGOProtos.Rpc.IrisSocialEventTelemetry.IIrisSocialCameraMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialEventTelemetry.IrisSocialCameraMetadata;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialEventTelemetry.IrisSocialCameraMetadata;
                public static toObject(message: POGOProtos.Rpc.IrisSocialEventTelemetry.IrisSocialCameraMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPosition {
                x?: (number|null);
                y?: (number|null);
                z?: (number|null);
            }

            class Position implements IPosition {
                constructor(properties?: POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition);
                public x: number;
                public y: number;
                public z: number;
                public static encode(message: POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialEventTelemetry.Position;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialEventTelemetry.Position;
                public static toObject(message: POGOProtos.Rpc.IrisSocialEventTelemetry.Position, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRotation {
                x?: (number|null);
                y?: (number|null);
                z?: (number|null);
                w?: (number|null);
            }

            class Rotation implements IRotation {
                constructor(properties?: POGOProtos.Rpc.IrisSocialEventTelemetry.IRotation);
                public x: number;
                public y: number;
                public z: number;
                public w: number;
                public static encode(message: POGOProtos.Rpc.IrisSocialEventTelemetry.IRotation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialEventTelemetry.Rotation;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialEventTelemetry.Rotation;
                public static toObject(message: POGOProtos.Rpc.IrisSocialEventTelemetry.Rotation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIrisSocialGlobalSettingsProto {
            push_gateway_namespace?: (string|null);
        }

        class IrisSocialGlobalSettingsProto implements IIrisSocialGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIrisSocialGlobalSettingsProto);
            public push_gateway_namespace: string;
            public static encode(message: POGOProtos.Rpc.IIrisSocialGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.IrisSocialGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIrisSocialInteractionLogEntry {
            result?: (POGOProtos.Rpc.IrisSocialInteractionLogEntry.Result|null);
            pokemon_id?: (number|Long|null);
            pokemon_nickname?: (string|null);
            pokemon_image_lookups?: (POGOProtos.Rpc.IrisSocialInteractionLogEntry.IIrisSocialImageLookup[]|null);
            fort_id?: (string|null);
        }

        class IrisSocialInteractionLogEntry implements IIrisSocialInteractionLogEntry {
            constructor(properties?: POGOProtos.Rpc.IIrisSocialInteractionLogEntry);
            public result: POGOProtos.Rpc.IrisSocialInteractionLogEntry.Result;
            public pokemon_id: (number|Long);
            public pokemon_nickname: string;
            public pokemon_image_lookups: POGOProtos.Rpc.IrisSocialInteractionLogEntry.IIrisSocialImageLookup[];
            public fort_id: string;
            public static encode(message: POGOProtos.Rpc.IIrisSocialInteractionLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialInteractionLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialInteractionLogEntry;
            public static toObject(message: POGOProtos.Rpc.IrisSocialInteractionLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IrisSocialInteractionLogEntry {

            enum Result {
                UNSET = 0,
                POKEMON_REMOVED = 1
            }

            interface IIrisSocialImageLookup {
                pokedex_entry_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            }

            class IrisSocialImageLookup implements IIrisSocialImageLookup {
                constructor(properties?: POGOProtos.Rpc.IrisSocialInteractionLogEntry.IIrisSocialImageLookup);
                public pokedex_entry_id: POGOProtos.Rpc.HoloPokemonId;
                public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public static encode(message: POGOProtos.Rpc.IrisSocialInteractionLogEntry.IIrisSocialImageLookup, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialInteractionLogEntry.IrisSocialImageLookup;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialInteractionLogEntry.IrisSocialImageLookup;
                public static toObject(message: POGOProtos.Rpc.IrisSocialInteractionLogEntry.IrisSocialImageLookup, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIrisSocialSettingsProto {
            max_num_pokemon_per_player?: (number|null);
            max_num_pokemon_per_scene?: (number|null);
            pokemon_expire_after_ms?: (number|Long|null);
            banned_pokedex_ids?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            enable_hint_image_fallback_to_default?: (boolean|null);
            allow_admin_vps_wayspots?: (boolean|null);
            min_boundary_area_sq_meters?: (number|null);
            max_boundary_area_sq_meters?: (number|null);
            push_gateway_enabled?: (boolean|null);
            use_boundary_vertices_from_data_flow?: (boolean|null);
            iris_social_enabled?: (boolean|null);
            max_time_bg_mode_before_expulsion_ms?: (number|Long|null);
            max_distance_allow_localization_meters?: (number|Long|null);
            max_time_no_activity_player_inactive_ms?: (number|Long|null);
            limited_pokedex_ids?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            players_recent_activity_timeout_ms?: (number|Long|null);
            pokemon_spawn_stagger_duration_ms?: (number|Long|null);
            enable_survey_and_reporting?: (boolean|null);
            use_vps_enabled_status?: (boolean|null);
            sun_threshold_check_enabled?: (boolean|null);
            sunrise_threshold_offset_ms?: (number|Long|null);
            sunset_threshold_offset_ms?: (number|Long|null);
            hint_image_boundary_fallback_enabled?: (boolean|null);
            static_boundary_area_sq_meters?: (number|null);
            iris_social_poi_deactivation_cooldown_ms?: (number|Long|null);
            combined_shadows_enabled?: (boolean|null);
            use_continuous_localization?: (boolean|null);
            ftue_version?: (POGOProtos.Rpc.IrisFtueVersion|null);
            expression_update_broadcast_method?: (POGOProtos.Rpc.ExpressionUpdateBroadcastMethod|null);
            show_production_wayspots?: (boolean|null);
            disable_vps_ingestion?: (boolean|null);
            localization_guidance_path_enabled?: (boolean|null);
            ground_focus_guardrail_enabled?: (boolean|null);
            ground_focus_guardrail_enter_angle?: (number|null);
            ground_focus_guardrail_exit_angle?: (number|null);
            ground_focus_guardrail_duration_seconds?: (number|null);
            localization_timeout_duration_ms?: (number|Long|null);
            limited_localization_timeout_duration_ms?: (number|Long|null);
            localization_max_attempts?: (number|Long|null);
            limited_localization_boundary_offset_enabled?: (boolean|null);
            pokeball_ping_time_delay_ms?: (number|null);
            add_pokemon_modal_delay_ms?: (number|null);
            guidance_path_nearby_finish_delay_ms?: (number|null);
            guidance_path_nearby_finish_distance_meters?: (number|null);
            guidance_in_car_threshold?: (number|null);
            location_manager_jpeg_compression_quality?: (number|null);
            remove_all_vps_pgo_bans?: (boolean|null);
            min_vps_score?: (number|null);
            gameplay_reports_active?: (boolean|null);
            transparency_on_dist?: (number|null);
            transparency_off_dist?: (number|null);
            weak_connection_ms_threshold?: (number|null);
            weak_connection_ejection_threshold?: (number|null);
            asset_loading_failure_ejection_threshold?: (number|null);
            server_response_error_ejection_threshold?: (number|null);
            enable_nameplates?: (boolean|null);
            enable_magic_moments?: (boolean|null);
            enable_ambassador_pokemon?: (boolean|null);
            enable_weather_warning?: (boolean|null);
            enable_sqc_guidance?: (boolean|null);
            enable_mesh_placing?: (boolean|null);
            ambassador_pokemon_timeout_ms?: (number|Long|null);
        }

        class IrisSocialSettingsProto implements IIrisSocialSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIrisSocialSettingsProto);
            public max_num_pokemon_per_player: number;
            public max_num_pokemon_per_scene: number;
            public pokemon_expire_after_ms: (number|Long);
            public banned_pokedex_ids: POGOProtos.Rpc.HoloPokemonId[];
            public enable_hint_image_fallback_to_default: boolean;
            public allow_admin_vps_wayspots: boolean;
            public min_boundary_area_sq_meters: number;
            public max_boundary_area_sq_meters: number;
            public push_gateway_enabled: boolean;
            public use_boundary_vertices_from_data_flow: boolean;
            public iris_social_enabled: boolean;
            public max_time_bg_mode_before_expulsion_ms: (number|Long);
            public max_distance_allow_localization_meters: (number|Long);
            public max_time_no_activity_player_inactive_ms: (number|Long);
            public limited_pokedex_ids: POGOProtos.Rpc.HoloPokemonId[];
            public players_recent_activity_timeout_ms: (number|Long);
            public pokemon_spawn_stagger_duration_ms: (number|Long);
            public enable_survey_and_reporting: boolean;
            public use_vps_enabled_status: boolean;
            public sun_threshold_check_enabled: boolean;
            public sunrise_threshold_offset_ms: (number|Long);
            public sunset_threshold_offset_ms: (number|Long);
            public hint_image_boundary_fallback_enabled: boolean;
            public static_boundary_area_sq_meters: number;
            public iris_social_poi_deactivation_cooldown_ms: (number|Long);
            public combined_shadows_enabled: boolean;
            public use_continuous_localization: boolean;
            public ftue_version: POGOProtos.Rpc.IrisFtueVersion;
            public expression_update_broadcast_method: POGOProtos.Rpc.ExpressionUpdateBroadcastMethod;
            public show_production_wayspots: boolean;
            public disable_vps_ingestion: boolean;
            public localization_guidance_path_enabled: boolean;
            public ground_focus_guardrail_enabled: boolean;
            public ground_focus_guardrail_enter_angle: number;
            public ground_focus_guardrail_exit_angle: number;
            public ground_focus_guardrail_duration_seconds: number;
            public localization_timeout_duration_ms: (number|Long);
            public limited_localization_timeout_duration_ms: (number|Long);
            public localization_max_attempts: (number|Long);
            public limited_localization_boundary_offset_enabled: boolean;
            public pokeball_ping_time_delay_ms: number;
            public add_pokemon_modal_delay_ms: number;
            public guidance_path_nearby_finish_delay_ms: number;
            public guidance_path_nearby_finish_distance_meters: number;
            public guidance_in_car_threshold: number;
            public location_manager_jpeg_compression_quality: number;
            public remove_all_vps_pgo_bans: boolean;
            public min_vps_score: number;
            public gameplay_reports_active: boolean;
            public transparency_on_dist: number;
            public transparency_off_dist: number;
            public weak_connection_ms_threshold: number;
            public weak_connection_ejection_threshold: number;
            public asset_loading_failure_ejection_threshold: number;
            public server_response_error_ejection_threshold: number;
            public enable_nameplates: boolean;
            public enable_magic_moments: boolean;
            public enable_ambassador_pokemon: boolean;
            public enable_weather_warning: boolean;
            public enable_sqc_guidance: boolean;
            public enable_mesh_placing: boolean;
            public ambassador_pokemon_timeout_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IIrisSocialSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialSettingsProto;
            public static toObject(message: POGOProtos.Rpc.IrisSocialSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIrisSocialUserExperienceFunnelSettingsProto {
            ux_funnel_version?: (number|null);
            event_step?: (POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IIrisSocialEventStepProto[]|null);
        }

        class IrisSocialUserExperienceFunnelSettingsProto implements IIrisSocialUserExperienceFunnelSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IIrisSocialUserExperienceFunnelSettingsProto);
            public ux_funnel_version: number;
            public event_step: POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IIrisSocialEventStepProto[];
            public static encode(message: POGOProtos.Rpc.IIrisSocialUserExperienceFunnelSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto;
            public static toObject(message: POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace IrisSocialUserExperienceFunnelSettingsProto {

            interface IIrisSocialEventStepProto {
                step_number?: (number|null);
                event?: (POGOProtos.Rpc.IrisSocialEvent|null);
            }

            class IrisSocialEventStepProto implements IIrisSocialEventStepProto {
                constructor(properties?: POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IIrisSocialEventStepProto);
                public step_number: number;
                public event: POGOProtos.Rpc.IrisSocialEvent;
                public static encode(message: POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IIrisSocialEventStepProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IrisSocialEventStepProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IrisSocialEventStepProto;
                public static toObject(message: POGOProtos.Rpc.IrisSocialUserExperienceFunnelSettingsProto.IrisSocialEventStepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IIsSkuAvailableOutProto {
            is_sku_available?: (boolean|null);
        }

        class IsSkuAvailableOutProto implements IIsSkuAvailableOutProto {
            constructor(properties?: POGOProtos.Rpc.IIsSkuAvailableOutProto);
            public is_sku_available: boolean;
            public static encode(message: POGOProtos.Rpc.IIsSkuAvailableOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IsSkuAvailableOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IsSkuAvailableOutProto;
            public static toObject(message: POGOProtos.Rpc.IsSkuAvailableOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IIsSkuAvailableProto {
            sku_id?: (string|null);
            verify_price?: (boolean|null);
            coin_cost?: (number|null);
        }

        class IsSkuAvailableProto implements IIsSkuAvailableProto {
            constructor(properties?: POGOProtos.Rpc.IIsSkuAvailableProto);
            public sku_id: string;
            public verify_price: boolean;
            public coin_cost: number;
            public static encode(message: POGOProtos.Rpc.IIsSkuAvailableProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.IsSkuAvailableProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.IsSkuAvailableProto;
            public static toObject(message: POGOProtos.Rpc.IsSkuAvailableProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemExpirationSettingsProto {
            item?: (POGOProtos.Rpc.Item|null);
            expiration_time?: (string|null);
            emergency_expiration_enabled?: (boolean|null);
            emergency_expiration_time?: (string|null);
        }

        class ItemExpirationSettingsProto implements IItemExpirationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IItemExpirationSettingsProto);
            public item: POGOProtos.Rpc.Item;
            public expiration_time: string;
            public emergency_expiration_enabled: boolean;
            public emergency_expiration_time: string;
            public static encode(message: POGOProtos.Rpc.IItemExpirationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemExpirationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemExpirationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ItemExpirationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemInventoryUpdateSettingsProto {
            feature_enabled?: (boolean|null);
            category_proto?: (POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.ICategoryProto[]|null);
        }

        class ItemInventoryUpdateSettingsProto implements IItemInventoryUpdateSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IItemInventoryUpdateSettingsProto);
            public feature_enabled: boolean;
            public category_proto: POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.ICategoryProto[];
            public static encode(message: POGOProtos.Rpc.IItemInventoryUpdateSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemInventoryUpdateSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemInventoryUpdateSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ItemInventoryUpdateSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ItemInventoryUpdateSettingsProto {

            interface ICategoryProto {
                category?: (POGOProtos.Rpc.HoloItemCategory[]|null);
                category_name?: (string|null);
                sort_order?: (number|null);
            }

            class CategoryProto implements ICategoryProto {
                constructor(properties?: POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.ICategoryProto);
                public category: POGOProtos.Rpc.HoloItemCategory[];
                public category_name: string;
                public sort_order: number;
                public static encode(message: POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.ICategoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.CategoryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.CategoryProto;
                public static toObject(message: POGOProtos.Rpc.ItemInventoryUpdateSettingsProto.CategoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IItemProto {
            item_id?: (POGOProtos.Rpc.Item|null);
            count?: (number|null);
            unseen?: (boolean|null);
            expiration_time?: (string|null);
            ignore_inventory_count?: (boolean|null);
            unconverted_local_expiration_time_ms?: (number|Long|null);
            time_period_counter?: (POGOProtos.Rpc.IItemTimePeriodCountersProto|null);
        }

        class ItemProto implements IItemProto {
            constructor(properties?: POGOProtos.Rpc.IItemProto);
            public item_id: POGOProtos.Rpc.Item;
            public count: number;
            public unseen: boolean;
            public expiration_time: string;
            public ignore_inventory_count: boolean;
            public unconverted_local_expiration_time_ms: (number|Long);
            public time_period_counter?: (POGOProtos.Rpc.IItemTimePeriodCountersProto|null);
            public static encode(message: POGOProtos.Rpc.IItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemProto;
            public static toObject(message: POGOProtos.Rpc.ItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemRewardProto {
            item?: (POGOProtos.Rpc.Item|null);
            amount?: (number|null);
        }

        class ItemRewardProto implements IItemRewardProto {
            constructor(properties?: POGOProtos.Rpc.IItemRewardProto);
            public item: POGOProtos.Rpc.Item;
            public amount: number;
            public static encode(message: POGOProtos.Rpc.IItemRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemRewardProto;
            public static toObject(message: POGOProtos.Rpc.ItemRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemSettingsProto {
            unique_id?: (POGOProtos.Rpc.Item|null);
            item_type?: (POGOProtos.Rpc.HoloItemType|null);
            category?: (POGOProtos.Rpc.HoloItemCategory|null);
            drop_freq?: (number|null);
            drop_trainer_level?: (number|null);
            pokeball?: (POGOProtos.Rpc.IPokeBallAttributesProto|null);
            potion?: (POGOProtos.Rpc.IPotionAttributesProto|null);
            revive?: (POGOProtos.Rpc.IReviveAttributesProto|null);
            battle?: (POGOProtos.Rpc.IBattleAttributesProto|null);
            food?: (POGOProtos.Rpc.IFoodAttributesProto|null);
            inventory_upgrade?: (POGOProtos.Rpc.IInventoryUpgradeAttributesProto|null);
            xp_boost?: (POGOProtos.Rpc.IExperienceBoostAttributesProto|null);
            incense?: (POGOProtos.Rpc.IIncenseAttributesProto|null);
            egg_incubator?: (POGOProtos.Rpc.IEggIncubatorAttributesProto|null);
            fort_modifier?: (POGOProtos.Rpc.IFortModifierAttributesProto|null);
            stardust_boost?: (POGOProtos.Rpc.IStardustBoostAttributesProto|null);
            incident_ticket?: (POGOProtos.Rpc.IIncidentTicketAttributesProto|null);
            global_event_ticket?: (POGOProtos.Rpc.IGlobalEventTicketAttributesProto|null);
            ignore_inventory_space?: (boolean|null);
            item_cap?: (number|null);
            vs_effect?: (POGOProtos.Rpc.IMoveModifierProto[]|null);
            name_override?: (string|null);
            name_plural_override?: (string|null);
            description_override?: (string|null);
            replenish_mp?: (POGOProtos.Rpc.IReplenishMpAttributesProto|null);
            event_pass_point?: (POGOProtos.Rpc.IEventPassPointAttributesProto|null);
            time_period_counters?: (POGOProtos.Rpc.IItemTimePeriodCountersSettingsProto|null);
            hide_item_in_inventory?: (boolean|null);
            stat_increase?: (POGOProtos.Rpc.IStatIncreaseAttributesProto|null);
        }

        class ItemSettingsProto implements IItemSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IItemSettingsProto);
            public unique_id: POGOProtos.Rpc.Item;
            public item_type: POGOProtos.Rpc.HoloItemType;
            public category: POGOProtos.Rpc.HoloItemCategory;
            public drop_freq: number;
            public drop_trainer_level: number;
            public pokeball?: (POGOProtos.Rpc.IPokeBallAttributesProto|null);
            public potion?: (POGOProtos.Rpc.IPotionAttributesProto|null);
            public revive?: (POGOProtos.Rpc.IReviveAttributesProto|null);
            public battle?: (POGOProtos.Rpc.IBattleAttributesProto|null);
            public food?: (POGOProtos.Rpc.IFoodAttributesProto|null);
            public inventory_upgrade?: (POGOProtos.Rpc.IInventoryUpgradeAttributesProto|null);
            public xp_boost?: (POGOProtos.Rpc.IExperienceBoostAttributesProto|null);
            public incense?: (POGOProtos.Rpc.IIncenseAttributesProto|null);
            public egg_incubator?: (POGOProtos.Rpc.IEggIncubatorAttributesProto|null);
            public fort_modifier?: (POGOProtos.Rpc.IFortModifierAttributesProto|null);
            public stardust_boost?: (POGOProtos.Rpc.IStardustBoostAttributesProto|null);
            public incident_ticket?: (POGOProtos.Rpc.IIncidentTicketAttributesProto|null);
            public global_event_ticket?: (POGOProtos.Rpc.IGlobalEventTicketAttributesProto|null);
            public ignore_inventory_space: boolean;
            public item_cap: number;
            public vs_effect: POGOProtos.Rpc.IMoveModifierProto[];
            public name_override: string;
            public name_plural_override: string;
            public description_override: string;
            public replenish_mp?: (POGOProtos.Rpc.IReplenishMpAttributesProto|null);
            public event_pass_point?: (POGOProtos.Rpc.IEventPassPointAttributesProto|null);
            public time_period_counters?: (POGOProtos.Rpc.IItemTimePeriodCountersSettingsProto|null);
            public hide_item_in_inventory: boolean;
            public stat_increase?: (POGOProtos.Rpc.IStatIncreaseAttributesProto|null);
            public static encode(message: POGOProtos.Rpc.IItemSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ItemSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemTelemetry {
            item_use_click_id?: (POGOProtos.Rpc.ItemUseTelemetryIds|null);
            item_id?: (POGOProtos.Rpc.Item|null);
            equipped?: (boolean|null);
            from_inventory?: (boolean|null);
            item_id_string?: (string|null);
        }

        class ItemTelemetry implements IItemTelemetry {
            constructor(properties?: POGOProtos.Rpc.IItemTelemetry);
            public item_use_click_id: POGOProtos.Rpc.ItemUseTelemetryIds;
            public item_id: POGOProtos.Rpc.Item;
            public equipped: boolean;
            public from_inventory: boolean;
            public item_id_string: string;
            public static encode(message: POGOProtos.Rpc.IItemTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemTelemetry;
            public static toObject(message: POGOProtos.Rpc.ItemTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemTimePeriodCountersProto {
            player_activity?: (POGOProtos.Rpc.IDailyCounterProto|null);
        }

        class ItemTimePeriodCountersProto implements IItemTimePeriodCountersProto {
            constructor(properties?: POGOProtos.Rpc.IItemTimePeriodCountersProto);
            public player_activity?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public static encode(message: POGOProtos.Rpc.IItemTimePeriodCountersProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemTimePeriodCountersProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemTimePeriodCountersProto;
            public static toObject(message: POGOProtos.Rpc.ItemTimePeriodCountersProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IItemTimePeriodCountersSettingsProto {
            player_activity?: (POGOProtos.Rpc.ITimePeriodCounterSettingsProto|null);
        }

        class ItemTimePeriodCountersSettingsProto implements IItemTimePeriodCountersSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IItemTimePeriodCountersSettingsProto);
            public player_activity?: (POGOProtos.Rpc.ITimePeriodCounterSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IItemTimePeriodCountersSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ItemTimePeriodCountersSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ItemTimePeriodCountersSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ItemTimePeriodCountersSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinBreadLobbyOutProto {
            result?: (POGOProtos.Rpc.JoinBreadLobbyOutProto.Result|null);
            bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            concurrent_player_boost_level?: (number|null);
            existing_lobby?: (POGOProtos.Rpc.JoinBreadLobbyOutProto.IExistingLobbyProto|null);
            server_timestamp_ms?: (number|Long|null);
        }

        class JoinBreadLobbyOutProto implements IJoinBreadLobbyOutProto {
            constructor(properties?: POGOProtos.Rpc.IJoinBreadLobbyOutProto);
            public result: POGOProtos.Rpc.JoinBreadLobbyOutProto.Result;
            public bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            public concurrent_player_boost_level: number;
            public existing_lobby?: (POGOProtos.Rpc.JoinBreadLobbyOutProto.IExistingLobbyProto|null);
            public server_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IJoinBreadLobbyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinBreadLobbyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinBreadLobbyOutProto;
            public static toObject(message: POGOProtos.Rpc.JoinBreadLobbyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace JoinBreadLobbyOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_BREAD_BATTLE_UNAVAILABLE = 3,
                ERROR_BREAD_BATTLE_COMPLETED = 4,
                ERROR_NO_AVAILABLE_BREAD_LOBBIES = 5,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 6,
                ERROR_STATION_INACCESSIBLE = 7,
                ERROR_NO_POWER_CRYSTAL = 10,
                ERROR_NO_INVITE = 11,
                ERROR_NO_POWER_CRYSTAL_SLOTS_REMAINING = 12,
                ERROR_BREAD_LOBBY_FULL = 13,
                ERROR_BREAD_LOBBY_EXPIRED = 14,
                ERROR_POWER_CRYSTAL_LIMIT_REACHED = 15,
                ERROR_INSUFFICIENT_MP = 16,
                ERROR_ALREADY_IN_BATTLE = 17,
                ERROR_ALREADY_IN_EXISTING_LOBBY_OR_BATTLE = 18,
                ERROR_FAILED_TO_CREATE_BATTLE = 19,
                ERROR_NO_REMOTE_TICKET = 20,
                ERROR_NO_REMOTE_SLOTS_REMAINING = 21,
                ERROR_DAILY_REMOTE_MAX = 22,
                ERROR_SOCIAL_FEATURES_DISABLED = 23,
                ERROR_JOIN_VIA_FRIENDS_DISABLED = 24,
                ERROR_BREAD_BATTLE_LEVEL_UNAVAILABLE = 25,
                ERROR_FRIEND_DETAILS_UNAVAILABLE = 26,
                ERROR_BREAD_BATTLE_NOT_FOUND = 27
            }

            interface IExistingLobbyProto {
                station_id?: (string|null);
                lat_degrees?: (number|null);
                lng_degrees?: (number|null);
                lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            }

            class ExistingLobbyProto implements IExistingLobbyProto {
                constructor(properties?: POGOProtos.Rpc.JoinBreadLobbyOutProto.IExistingLobbyProto);
                public station_id: string;
                public lat_degrees: number;
                public lng_degrees: number;
                public lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
                public static encode(message: POGOProtos.Rpc.JoinBreadLobbyOutProto.IExistingLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinBreadLobbyOutProto.ExistingLobbyProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinBreadLobbyOutProto.ExistingLobbyProto;
                public static toObject(message: POGOProtos.Rpc.JoinBreadLobbyOutProto.ExistingLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IJoinBreadLobbyProto {
            bread_battle_seed?: (number|Long|null);
            station_id?: (string|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
            bread_battle_entry_point?: (POGOProtos.Rpc.BreadBattleEntryPoint|null);
            use_power_crystal?: (boolean|null);
            bread_lobby_id?: (number|Long|null);
            is_battle_assist?: (boolean|null);
            use_remote_pass?: (boolean|null);
            inviter_id?: (string|null);
            is_self_invite?: (boolean|null);
        }

        class JoinBreadLobbyProto implements IJoinBreadLobbyProto {
            constructor(properties?: POGOProtos.Rpc.IJoinBreadLobbyProto);
            public bread_battle_seed: (number|Long);
            public station_id: string;
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public bread_battle_entry_point: POGOProtos.Rpc.BreadBattleEntryPoint;
            public use_power_crystal: boolean;
            public bread_lobby_id: (number|Long);
            public is_battle_assist: boolean;
            public use_remote_pass: boolean;
            public inviter_id: string;
            public is_self_invite: boolean;
            public static encode(message: POGOProtos.Rpc.IJoinBreadLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinBreadLobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinBreadLobbyProto;
            public static toObject(message: POGOProtos.Rpc.JoinBreadLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinBuddyMultiplayerSessionOutProto {
            result?: (POGOProtos.Rpc.JoinBuddyMultiplayerSessionOutProto.Result|null);
            arbe_join_token?: (Uint8Array|null);
            generation_timestamp?: (number|Long|null);
            max_players?: (number|null);
        }

        class JoinBuddyMultiplayerSessionOutProto implements IJoinBuddyMultiplayerSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.IJoinBuddyMultiplayerSessionOutProto);
            public result: POGOProtos.Rpc.JoinBuddyMultiplayerSessionOutProto.Result;
            public arbe_join_token: Uint8Array;
            public generation_timestamp: (number|Long);
            public max_players: number;
            public static encode(message: POGOProtos.Rpc.IJoinBuddyMultiplayerSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinBuddyMultiplayerSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinBuddyMultiplayerSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.JoinBuddyMultiplayerSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace JoinBuddyMultiplayerSessionOutProto {

            enum Result {
                JOIN_SUCCESS = 0,
                JOIN_LOBBY_FULL = 1,
                JOIN_HOST_TOO_FAR = 2,
                JOIN_LOBBY_NOT_FOUND = 3,
                JOIN_BUDDY_NOT_SET = 4,
                JOIN_BUDDY_NOT_FOUND = 5,
                JOIN_BAD_BUDDY = 6,
                JOIN_BUDDY_V2_NOT_ENABLED = 7,
                JOIN_PLAYER_LEVEL_TOO_LOW = 8,
                JOIN_UNKNOWN_ERROR = 9,
                JOIN_U13_NO_PERMISSION = 10
            }
        }

        interface IJoinBuddyMultiplayerSessionProto {
            plfe_session_id?: (string|null);
        }

        class JoinBuddyMultiplayerSessionProto implements IJoinBuddyMultiplayerSessionProto {
            constructor(properties?: POGOProtos.Rpc.IJoinBuddyMultiplayerSessionProto);
            public plfe_session_id: string;
            public static encode(message: POGOProtos.Rpc.IJoinBuddyMultiplayerSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinBuddyMultiplayerSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinBuddyMultiplayerSessionProto;
            public static toObject(message: POGOProtos.Rpc.JoinBuddyMultiplayerSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinLobbyData {
            "private"?: (boolean|null);
            use_remote_pass?: (boolean|null);
            rpc_id?: (number|null);
        }

        class JoinLobbyData implements IJoinLobbyData {
            constructor(properties?: POGOProtos.Rpc.IJoinLobbyData);
            public private: boolean;
            public use_remote_pass: boolean;
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IJoinLobbyData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinLobbyData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinLobbyData;
            public static toObject(message: POGOProtos.Rpc.JoinLobbyData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinLobbyOutProto {
            result?: (POGOProtos.Rpc.JoinLobbyOutProto.Result|null);
            lobby?: (POGOProtos.Rpc.ILobbyProto|null);
        }

        class JoinLobbyOutProto implements IJoinLobbyOutProto {
            constructor(properties?: POGOProtos.Rpc.IJoinLobbyOutProto);
            public result: POGOProtos.Rpc.JoinLobbyOutProto.Result;
            public lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            public static encode(message: POGOProtos.Rpc.IJoinLobbyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinLobbyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinLobbyOutProto;
            public static toObject(message: POGOProtos.Rpc.JoinLobbyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace JoinLobbyOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_RAID_UNAVAILABLE = 3,
                ERROR_RAID_COMPLETED = 4,
                ERROR_NO_AVAILABLE_LOBBIES = 5,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 6,
                ERROR_POI_INACCESSIBLE = 7,
                ERROR_GYM_LOCKOUT = 8,
                ERROR_NO_TICKET = 9,
                ERROR_NO_REMOTE_TICKET = 10,
                ERROR_NO_INVITE = 11,
                ERROR_NO_REMOTE_SLOTS_REMAINING = 12,
                ERROR_LOBBY_FULL = 13,
                ERROR_LOBBY_EXPIRED = 14,
                ERROR_DATA = 15,
                ERROR_MAX_LOBBIES_REACHED = 16,
                ERROR_FAILED_TO_CREATE_BATTLE = 17
            }
        }

        interface IJoinLobbyProto {
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            "private"?: (boolean|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
            use_remote_pass?: (boolean|null);
            inviter_id?: (string|null);
            is_self_invite?: (boolean|null);
        }

        class JoinLobbyProto implements IJoinLobbyProto {
            constructor(properties?: POGOProtos.Rpc.IJoinLobbyProto);
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public private: boolean;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public use_remote_pass: boolean;
            public inviter_id: string;
            public is_self_invite: boolean;
            public static encode(message: POGOProtos.Rpc.IJoinLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinLobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinLobbyProto;
            public static toObject(message: POGOProtos.Rpc.JoinLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinLobbyResponseData {
            result?: (POGOProtos.Rpc.JoinLobbyOutProto.Result|null);
            lobby_id?: (number[]|null);
            player_count?: (number|null);
            player_join_end_offset_ms?: (number|null);
            pokemon_selection_end_offset_ms?: (number|null);
            raid_battle_start_offset_ms?: (number|null);
            raid_battle_end_offset_ms?: (number|null);
            raid_battle_id?: (string|null);
            "private"?: (boolean|null);
            creation_offset_ms?: (number|null);
            battle_plfe_instance?: (number|null);
            weather_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class JoinLobbyResponseData implements IJoinLobbyResponseData {
            constructor(properties?: POGOProtos.Rpc.IJoinLobbyResponseData);
            public result: POGOProtos.Rpc.JoinLobbyOutProto.Result;
            public lobby_id: number[];
            public player_count: number;
            public player_join_end_offset_ms: number;
            public pokemon_selection_end_offset_ms: number;
            public raid_battle_start_offset_ms: number;
            public raid_battle_end_offset_ms: number;
            public raid_battle_id: string;
            public private: boolean;
            public creation_offset_ms: number;
            public battle_plfe_instance: number;
            public weather_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.IJoinLobbyResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinLobbyResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinLobbyResponseData;
            public static toObject(message: POGOProtos.Rpc.JoinLobbyResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinPartyOutProto {
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            result?: (POGOProtos.Rpc.JoinPartyOutProto.Result|null);
        }

        class JoinPartyOutProto implements IJoinPartyOutProto {
            constructor(properties?: POGOProtos.Rpc.IJoinPartyOutProto);
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public result: POGOProtos.Rpc.JoinPartyOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IJoinPartyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinPartyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinPartyOutProto;
            public static toObject(message: POGOProtos.Rpc.JoinPartyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace JoinPartyOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_PLAYER_LEVEL_TOO_LOW = 3,
                ERROR_FEATURE_DISABLED = 4,
                ERROR_ALREADY_IN_PARTY = 5,
                ERROR_NO_SUCH_PARTY = 6,
                ERROR_PARTY_IS_FULL = 7,
                ERROR_NOT_IN_RANGE = 8,
                ERROR_PARTY_DARK_LAUNCH_QUEUE_EMPTY = 9,
                ERROR_DARK_LAUNCH_NOT_ENABLED_FOR_PLAYER = 10,
                ERROR_REDIS_EXCEPTION = 11,
                ERROR_U13_NO_PERMISSION = 12,
                ERROR_U13_NOT_FRIENDS_WITH_HOST = 13,
                ERROR_PARTY_TIMED_OUT = 14,
                ERROR_NO_LOCATION = 15,
                ERROR_PLFE_REDIRECT_NEEDED = 16,
                ERROR_PARTY_QUEST_ENCOUNTER_INCOMPLETE = 17,
                ERROR_INVITE_ONLY_GROUP = 18,
                ERROR_MATCHMAKING_GROUP = 19
            }
        }

        interface IJoinPartyProto {
            party_id?: (number[]|null);
            inviting_player_id?: (string|null);
            id?: (number|Long|null);
            is_dark_launch_request?: (boolean|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
        }

        class JoinPartyProto implements IJoinPartyProto {
            constructor(properties?: POGOProtos.Rpc.IJoinPartyProto);
            public party_id: number[];
            public inviting_player_id: string;
            public id: (number|Long);
            public is_dark_launch_request: boolean;
            public party_type: POGOProtos.Rpc.PartyType;
            public static encode(message: POGOProtos.Rpc.IJoinPartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinPartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinPartyProto;
            public static toObject(message: POGOProtos.Rpc.JoinPartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinRaidViaFriendListSettingsProto {
            enabled?: (boolean|null);
            min_player_level?: (number|null);
            min_friendship_score?: (number|null);
            friend_activities_background_update_period_ms?: (number|Long|null);
            friend_lobby_count_push_gateway_namespace?: (string|null);
            max_battle_enabled?: (boolean|null);
            max_battle_min_player_level?: (number|null);
            max_battle_min_friendship_score?: (number|null);
        }

        class JoinRaidViaFriendListSettingsProto implements IJoinRaidViaFriendListSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IJoinRaidViaFriendListSettingsProto);
            public enabled: boolean;
            public min_player_level: number;
            public min_friendship_score: number;
            public friend_activities_background_update_period_ms: (number|Long);
            public friend_lobby_count_push_gateway_namespace: string;
            public max_battle_enabled: boolean;
            public max_battle_min_player_level: number;
            public max_battle_min_friendship_score: number;
            public static encode(message: POGOProtos.Rpc.IJoinRaidViaFriendListSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinRaidViaFriendListSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinRaidViaFriendListSettingsProto;
            public static toObject(message: POGOProtos.Rpc.JoinRaidViaFriendListSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinedPlayerObfuscationEntryProto {
            participant_player_id?: (string|null);
            joined_player_id_player_obfuscated?: (string|null);
            joined_nia_account_id_player_obfuscated?: (string|null);
        }

        class JoinedPlayerObfuscationEntryProto implements IJoinedPlayerObfuscationEntryProto {
            constructor(properties?: POGOProtos.Rpc.IJoinedPlayerObfuscationEntryProto);
            public participant_player_id: string;
            public joined_player_id_player_obfuscated: string;
            public joined_nia_account_id_player_obfuscated: string;
            public static encode(message: POGOProtos.Rpc.IJoinedPlayerObfuscationEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinedPlayerObfuscationEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinedPlayerObfuscationEntryProto;
            public static toObject(message: POGOProtos.Rpc.JoinedPlayerObfuscationEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJoinedPlayerObfuscationMapProto {
            joined_player_id?: (string|null);
            obfuscation_entries?: (POGOProtos.Rpc.IJoinedPlayerObfuscationEntryProto[]|null);
        }

        class JoinedPlayerObfuscationMapProto implements IJoinedPlayerObfuscationMapProto {
            constructor(properties?: POGOProtos.Rpc.IJoinedPlayerObfuscationMapProto);
            public joined_player_id: string;
            public obfuscation_entries: POGOProtos.Rpc.IJoinedPlayerObfuscationEntryProto[];
            public static encode(message: POGOProtos.Rpc.IJoinedPlayerObfuscationMapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JoinedPlayerObfuscationMapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JoinedPlayerObfuscationMapProto;
            public static toObject(message: POGOProtos.Rpc.JoinedPlayerObfuscationMapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJournalAddEntryProto {
            hashed_key?: (POGOProtos.Rpc.IHashedKeyProto|null);
            entry_size?: (number|Long|null);
        }

        class JournalAddEntryProto implements IJournalAddEntryProto {
            constructor(properties?: POGOProtos.Rpc.IJournalAddEntryProto);
            public hashed_key?: (POGOProtos.Rpc.IHashedKeyProto|null);
            public entry_size: (number|Long);
            public static encode(message: POGOProtos.Rpc.IJournalAddEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JournalAddEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JournalAddEntryProto;
            public static toObject(message: POGOProtos.Rpc.JournalAddEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJournalEntryProto {
            add_entry?: (POGOProtos.Rpc.IJournalAddEntryProto|null);
            read_entry?: (POGOProtos.Rpc.IJournalReadEntryProto|null);
            remove_entry?: (POGOProtos.Rpc.IJournalRemoveEntryProto|null);
        }

        class JournalEntryProto implements IJournalEntryProto {
            constructor(properties?: POGOProtos.Rpc.IJournalEntryProto);
            public add_entry?: (POGOProtos.Rpc.IJournalAddEntryProto|null);
            public read_entry?: (POGOProtos.Rpc.IJournalReadEntryProto|null);
            public remove_entry?: (POGOProtos.Rpc.IJournalRemoveEntryProto|null);
            public Subentry?: ("add_entry"|"read_entry"|"remove_entry");
            public static encode(message: POGOProtos.Rpc.IJournalEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JournalEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JournalEntryProto;
            public static toObject(message: POGOProtos.Rpc.JournalEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJournalReadEntryProto {
            hashed_key?: (POGOProtos.Rpc.IHashedKeyProto|null);
        }

        class JournalReadEntryProto implements IJournalReadEntryProto {
            constructor(properties?: POGOProtos.Rpc.IJournalReadEntryProto);
            public hashed_key?: (POGOProtos.Rpc.IHashedKeyProto|null);
            public static encode(message: POGOProtos.Rpc.IJournalReadEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JournalReadEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JournalReadEntryProto;
            public static toObject(message: POGOProtos.Rpc.JournalReadEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJournalRemoveEntryProto {
            hashed_key?: (POGOProtos.Rpc.IHashedKeyProto|null);
        }

        class JournalRemoveEntryProto implements IJournalRemoveEntryProto {
            constructor(properties?: POGOProtos.Rpc.IJournalRemoveEntryProto);
            public hashed_key?: (POGOProtos.Rpc.IHashedKeyProto|null);
            public static encode(message: POGOProtos.Rpc.IJournalRemoveEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JournalRemoveEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JournalRemoveEntryProto;
            public static toObject(message: POGOProtos.Rpc.JournalRemoveEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IJournalVersionProto {
            version?: (number|null);
        }

        class JournalVersionProto implements IJournalVersionProto {
            constructor(properties?: POGOProtos.Rpc.IJournalVersionProto);
            public version: number;
            public static encode(message: POGOProtos.Rpc.IJournalVersionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.JournalVersionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.JournalVersionProto;
            public static toObject(message: POGOProtos.Rpc.JournalVersionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IKangarooSettingsProto {
            enable_kangaroo_v2?: (boolean|null);
        }

        class KangarooSettingsProto implements IKangarooSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IKangarooSettingsProto);
            public enable_kangaroo_v2: boolean;
            public static encode(message: POGOProtos.Rpc.IKangarooSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.KangarooSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.KangarooSettingsProto;
            public static toObject(message: POGOProtos.Rpc.KangarooSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IKey {
            id?: (string|null);
            kind?: (string|null);
        }

        class Key implements IKey {
            constructor(properties?: POGOProtos.Rpc.IKey);
            public id: string;
            public kind: string;
            public static encode(message: POGOProtos.Rpc.IKey, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Key;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Key;
            public static toObject(message: POGOProtos.Rpc.Key, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IKeyBlock {
            min_bounds?: (number[]|null);
            max_bounds?: (number[]|null);
            num_points?: (number|null);
            point_indices?: (number[]|null);
            observation_probs?: (number[]|null);
        }

        class KeyBlock implements IKeyBlock {
            constructor(properties?: POGOProtos.Rpc.IKeyBlock);
            public min_bounds: number[];
            public max_bounds: number[];
            public num_points: number;
            public point_indices: number[];
            public observation_probs: number[];
            public static encode(message: POGOProtos.Rpc.IKeyBlock, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.KeyBlock;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.KeyBlock;
            public static toObject(message: POGOProtos.Rpc.KeyBlock, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IKeyValuePair {
            key?: (POGOProtos.Rpc.IKey|null);
            value?: (Uint8Array|null);
        }

        class KeyValuePair implements IKeyValuePair {
            constructor(properties?: POGOProtos.Rpc.IKeyValuePair);
            public key?: (POGOProtos.Rpc.IKey|null);
            public value: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IKeyValuePair, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.KeyValuePair;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.KeyValuePair;
            public static toObject(message: POGOProtos.Rpc.KeyValuePair, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IKickOtherPlayerFromPartyOutProto {
            result?: (POGOProtos.Rpc.KickOtherPlayerFromPartyOutProto.Result|null);
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
        }

        class KickOtherPlayerFromPartyOutProto implements IKickOtherPlayerFromPartyOutProto {
            constructor(properties?: POGOProtos.Rpc.IKickOtherPlayerFromPartyOutProto);
            public result: POGOProtos.Rpc.KickOtherPlayerFromPartyOutProto.Result;
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public static encode(message: POGOProtos.Rpc.IKickOtherPlayerFromPartyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.KickOtherPlayerFromPartyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.KickOtherPlayerFromPartyOutProto;
            public static toObject(message: POGOProtos.Rpc.KickOtherPlayerFromPartyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace KickOtherPlayerFromPartyOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_PLAYER_NOT_IN_PARTY = 3,
                ERROR_PLAYER_NOT_HOST = 4,
                ERROR_PLAYER_NOT_FOUND = 5,
                ERROR_UNEXPECTED_PARTY_TYPE = 6
            }
        }

        interface IKickOtherPlayerFromPartyProto {
            player_id_to_remove?: (string|null);
        }

        class KickOtherPlayerFromPartyProto implements IKickOtherPlayerFromPartyProto {
            constructor(properties?: POGOProtos.Rpc.IKickOtherPlayerFromPartyProto);
            public player_id_to_remove: string;
            public static encode(message: POGOProtos.Rpc.IKickOtherPlayerFromPartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.KickOtherPlayerFromPartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.KickOtherPlayerFromPartyProto;
            public static toObject(message: POGOProtos.Rpc.KickOtherPlayerFromPartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IKoalaSettingsProto {
            app_id?: (string|null);
            use_sandbox?: (boolean|null);
            use_koala?: (boolean|null);
            use_adjust?: (boolean|null);
        }

        class KoalaSettingsProto implements IKoalaSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IKoalaSettingsProto);
            public app_id: string;
            public use_sandbox: boolean;
            public use_koala: boolean;
            public use_adjust: boolean;
            public static encode(message: POGOProtos.Rpc.IKoalaSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.KoalaSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.KoalaSettingsProto;
            public static toObject(message: POGOProtos.Rpc.KoalaSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILabel {
            min_zoom?: (number|null);
            max_zoom?: (number|null);
            priority?: (number|null);
            localizations?: (POGOProtos.Rpc.ILabelContentLocalization[]|null);
        }

        class Label implements ILabel {
            constructor(properties?: POGOProtos.Rpc.ILabel);
            public min_zoom: number;
            public max_zoom: number;
            public priority: number;
            public localizations: POGOProtos.Rpc.ILabelContentLocalization[];
            public static encode(message: POGOProtos.Rpc.ILabel, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Label;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Label;
            public static toObject(message: POGOProtos.Rpc.Label, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILabelContentLocalization {
            language?: (string|null);
            name?: (string|null);
        }

        class LabelContentLocalization implements ILabelContentLocalization {
            constructor(properties?: POGOProtos.Rpc.ILabelContentLocalization);
            public language: string;
            public name: string;
            public static encode(message: POGOProtos.Rpc.ILabelContentLocalization, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LabelContentLocalization;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LabelContentLocalization;
            public static toObject(message: POGOProtos.Rpc.LabelContentLocalization, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILanguageBundleProto {
            bundle_name?: (string|null);
        }

        class LanguageBundleProto implements ILanguageBundleProto {
            constructor(properties?: POGOProtos.Rpc.ILanguageBundleProto);
            public bundle_name: string;
            public static encode(message: POGOProtos.Rpc.ILanguageBundleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LanguageBundleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LanguageBundleProto;
            public static toObject(message: POGOProtos.Rpc.LanguageBundleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILanguageSelectorSettingsProto {
            language_selector_enabled?: (boolean|null);
        }

        class LanguageSelectorSettingsProto implements ILanguageSelectorSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILanguageSelectorSettingsProto);
            public language_selector_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ILanguageSelectorSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LanguageSelectorSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LanguageSelectorSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LanguageSelectorSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILanguageSettingsProto {
            language?: (string|null);
            is_enabled?: (boolean|null);
            is_early_access?: (boolean|null);
        }

        class LanguageSettingsProto implements ILanguageSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILanguageSettingsProto);
            public language: string;
            public is_enabled: boolean;
            public is_early_access: boolean;
            public static encode(message: POGOProtos.Rpc.ILanguageSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LanguageSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LanguageSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LanguageSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILanguageTelemetry {
            selected_language?: (string|null);
        }

        class LanguageTelemetry implements ILanguageTelemetry {
            constructor(properties?: POGOProtos.Rpc.ILanguageTelemetry);
            public selected_language: string;
            public static encode(message: POGOProtos.Rpc.ILanguageTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LanguageTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LanguageTelemetry;
            public static toObject(message: POGOProtos.Rpc.LanguageTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILayer {
            features?: (POGOProtos.Rpc.IFeature[]|null);
            layer_kind?: (POGOProtos.Rpc.LayerKind|null);
        }

        class Layer implements ILayer {
            constructor(properties?: POGOProtos.Rpc.ILayer);
            public features: POGOProtos.Rpc.IFeature[];
            public layer_kind: POGOProtos.Rpc.LayerKind;
            public static encode(message: POGOProtos.Rpc.ILayer, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Layer;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Layer;
            public static toObject(message: POGOProtos.Rpc.Layer, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeagueIdMismatchData {
            non_matching_league_id?: (string|null);
            log_type?: (POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType|null);
        }

        class LeagueIdMismatchData implements ILeagueIdMismatchData {
            constructor(properties?: POGOProtos.Rpc.ILeagueIdMismatchData);
            public non_matching_league_id: string;
            public log_type: POGOProtos.Rpc.CombatLogData.CombatLogDataHeader.LogType;
            public static encode(message: POGOProtos.Rpc.ILeagueIdMismatchData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeagueIdMismatchData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeagueIdMismatchData;
            public static toObject(message: POGOProtos.Rpc.LeagueIdMismatchData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeaveBreadLobbyOutProto {
            result?: (POGOProtos.Rpc.LeaveBreadLobbyOutProto.Result|null);
            bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
        }

        class LeaveBreadLobbyOutProto implements ILeaveBreadLobbyOutProto {
            constructor(properties?: POGOProtos.Rpc.ILeaveBreadLobbyOutProto);
            public result: POGOProtos.Rpc.LeaveBreadLobbyOutProto.Result;
            public bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            public static encode(message: POGOProtos.Rpc.ILeaveBreadLobbyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveBreadLobbyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveBreadLobbyOutProto;
            public static toObject(message: POGOProtos.Rpc.LeaveBreadLobbyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LeaveBreadLobbyOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BREAD_LOBBY_UNAVAILABLE = 2,
                ERROR_STATION_INACCESSIBLE = 3,
                ERROR_BREAD_LOBBY_NOT_FOUND = 4
            }
        }

        interface ILeaveBreadLobbyProto {
            bread_battle_seed?: (number|Long|null);
            station_id?: (string|null);
            bread_lobby_id?: (number|Long|null);
            bread_battle_entry_point?: (POGOProtos.Rpc.BreadBattleEntryPoint|null);
        }

        class LeaveBreadLobbyProto implements ILeaveBreadLobbyProto {
            constructor(properties?: POGOProtos.Rpc.ILeaveBreadLobbyProto);
            public bread_battle_seed: (number|Long);
            public station_id: string;
            public bread_lobby_id: (number|Long);
            public bread_battle_entry_point: POGOProtos.Rpc.BreadBattleEntryPoint;
            public static encode(message: POGOProtos.Rpc.ILeaveBreadLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveBreadLobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveBreadLobbyProto;
            public static toObject(message: POGOProtos.Rpc.LeaveBreadLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeaveBuddyMultiplayerSessionOutProto {
            result?: (POGOProtos.Rpc.LeaveBuddyMultiplayerSessionOutProto.Result|null);
        }

        class LeaveBuddyMultiplayerSessionOutProto implements ILeaveBuddyMultiplayerSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionOutProto);
            public result: POGOProtos.Rpc.LeaveBuddyMultiplayerSessionOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveBuddyMultiplayerSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveBuddyMultiplayerSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.LeaveBuddyMultiplayerSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LeaveBuddyMultiplayerSessionOutProto {

            enum Result {
                LEAVE_SUCCESS = 0,
                LEAVE_NOT_IN_LOBBY = 1,
                LEAVE_LOBBY_NOT_FOUND = 2,
                LEAVE_UNKNOWN_ERROR = 3
            }
        }

        interface ILeaveBuddyMultiplayerSessionProto {
            plfe_session_id?: (string|null);
        }

        class LeaveBuddyMultiplayerSessionProto implements ILeaveBuddyMultiplayerSessionProto {
            constructor(properties?: POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionProto);
            public plfe_session_id: string;
            public static encode(message: POGOProtos.Rpc.ILeaveBuddyMultiplayerSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveBuddyMultiplayerSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveBuddyMultiplayerSessionProto;
            public static toObject(message: POGOProtos.Rpc.LeaveBuddyMultiplayerSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeaveInteractionRangeTelemetry {
            result?: (string|null);
            fort_id?: (string|null);
            fort_type?: (number|null);
            client_timestamp?: (number|Long|null);
            partner_id?: (string|null);
            time_spent?: (number|Long|null);
            campaign_id?: (string|null);
        }

        class LeaveInteractionRangeTelemetry implements ILeaveInteractionRangeTelemetry {
            constructor(properties?: POGOProtos.Rpc.ILeaveInteractionRangeTelemetry);
            public result: string;
            public fort_id: string;
            public fort_type: number;
            public client_timestamp: (number|Long);
            public partner_id: string;
            public time_spent: (number|Long);
            public campaign_id: string;
            public static encode(message: POGOProtos.Rpc.ILeaveInteractionRangeTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveInteractionRangeTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveInteractionRangeTelemetry;
            public static toObject(message: POGOProtos.Rpc.LeaveInteractionRangeTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeaveLobbyData {
            rpc_id?: (number|null);
        }

        class LeaveLobbyData implements ILeaveLobbyData {
            constructor(properties?: POGOProtos.Rpc.ILeaveLobbyData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ILeaveLobbyData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveLobbyData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveLobbyData;
            public static toObject(message: POGOProtos.Rpc.LeaveLobbyData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeaveLobbyOutProto {
            result?: (POGOProtos.Rpc.LeaveLobbyOutProto.Result|null);
            lobby?: (POGOProtos.Rpc.ILobbyProto|null);
        }

        class LeaveLobbyOutProto implements ILeaveLobbyOutProto {
            constructor(properties?: POGOProtos.Rpc.ILeaveLobbyOutProto);
            public result: POGOProtos.Rpc.LeaveLobbyOutProto.Result;
            public lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            public static encode(message: POGOProtos.Rpc.ILeaveLobbyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveLobbyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveLobbyOutProto;
            public static toObject(message: POGOProtos.Rpc.LeaveLobbyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LeaveLobbyOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_RAID_UNAVAILABLE = 2,
                ERROR_LOBBY_NOT_FOUND = 3
            }
        }

        interface ILeaveLobbyProto {
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
        }

        class LeaveLobbyProto implements ILeaveLobbyProto {
            constructor(properties?: POGOProtos.Rpc.ILeaveLobbyProto);
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public static encode(message: POGOProtos.Rpc.ILeaveLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveLobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveLobbyProto;
            public static toObject(message: POGOProtos.Rpc.LeaveLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeaveLobbyResponseData {
            result?: (POGOProtos.Rpc.LeaveLobbyOutProto.Result|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class LeaveLobbyResponseData implements ILeaveLobbyResponseData {
            constructor(properties?: POGOProtos.Rpc.ILeaveLobbyResponseData);
            public result: POGOProtos.Rpc.LeaveLobbyOutProto.Result;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.ILeaveLobbyResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeaveLobbyResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeaveLobbyResponseData;
            public static toObject(message: POGOProtos.Rpc.LeaveLobbyResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeavePartyOutProto {
            result?: (POGOProtos.Rpc.LeavePartyOutProto.Result|null);
        }

        class LeavePartyOutProto implements ILeavePartyOutProto {
            constructor(properties?: POGOProtos.Rpc.ILeavePartyOutProto);
            public result: POGOProtos.Rpc.LeavePartyOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ILeavePartyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeavePartyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeavePartyOutProto;
            public static toObject(message: POGOProtos.Rpc.LeavePartyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LeavePartyOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_FEATURE_DISABLED = 3,
                ERROR_PLAYER_NOT_IN_PARTY = 4
            }
        }

        interface ILeavePartyProto {
            party_id?: (number[]|null);
            is_dark_launch_request?: (boolean|null);
            reason_to_leave?: (POGOProtos.Rpc.LeavePartyProto.ReasonToLeave|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
        }

        class LeavePartyProto implements ILeavePartyProto {
            constructor(properties?: POGOProtos.Rpc.ILeavePartyProto);
            public party_id: number[];
            public is_dark_launch_request: boolean;
            public reason_to_leave: POGOProtos.Rpc.LeavePartyProto.ReasonToLeave;
            public party_type: POGOProtos.Rpc.PartyType;
            public static encode(message: POGOProtos.Rpc.ILeavePartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeavePartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeavePartyProto;
            public static toObject(message: POGOProtos.Rpc.LeavePartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LeavePartyProto {

            enum ReasonToLeave {
                UNSET = 0,
                PRESSED_BUTTON = 1,
                U13_HOST_NOT_FRIEND = 2,
                TOO_FAR_AWAY = 3,
                DISBANDED = 4,
                EXPIRED = 5,
                DECLINED_REJOIN = 6,
                FEATURE_DISABLED = 7
            }
        }

        interface ILeavePointOfInterestTelemetry {
            result?: (string|null);
            fort_id?: (string|null);
            fort_type?: (number|null);
            client_timestamp?: (number|Long|null);
            partner_id?: (string|null);
            time_spent?: (number|Long|null);
            campaign_id?: (string|null);
        }

        class LeavePointOfInterestTelemetry implements ILeavePointOfInterestTelemetry {
            constructor(properties?: POGOProtos.Rpc.ILeavePointOfInterestTelemetry);
            public result: string;
            public fort_id: string;
            public fort_type: number;
            public client_timestamp: (number|Long);
            public partner_id: string;
            public time_spent: (number|Long);
            public campaign_id: string;
            public static encode(message: POGOProtos.Rpc.ILeavePointOfInterestTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeavePointOfInterestTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeavePointOfInterestTelemetry;
            public static toObject(message: POGOProtos.Rpc.LeavePointOfInterestTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILevelSettingsProto {
            trainer_cp_modifier?: (number|null);
            trainer_difficulty_modifier?: (number|null);
        }

        class LevelSettingsProto implements ILevelSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILevelSettingsProto);
            public trainer_cp_modifier: number;
            public trainer_difficulty_modifier: number;
            public static encode(message: POGOProtos.Rpc.ILevelSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LevelSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LevelSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LevelSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILevelUpRewardsOutProto {
            result?: (POGOProtos.Rpc.LevelUpRewardsOutProto.Result|null);
            items?: (POGOProtos.Rpc.IAwardItemProto[]|null);
            items_unlocked?: (POGOProtos.Rpc.Item[]|null);
            avatar_template_ids?: (string[]|null);
            pokecoins?: (number|null);
            neutral_avatar_item_templates?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto[]|null);
        }

        class LevelUpRewardsOutProto implements ILevelUpRewardsOutProto {
            constructor(properties?: POGOProtos.Rpc.ILevelUpRewardsOutProto);
            public result: POGOProtos.Rpc.LevelUpRewardsOutProto.Result;
            public items: POGOProtos.Rpc.IAwardItemProto[];
            public items_unlocked: POGOProtos.Rpc.Item[];
            public avatar_template_ids: string[];
            public pokecoins: number;
            public neutral_avatar_item_templates: POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto[];
            public static encode(message: POGOProtos.Rpc.ILevelUpRewardsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LevelUpRewardsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LevelUpRewardsOutProto;
            public static toObject(message: POGOProtos.Rpc.LevelUpRewardsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LevelUpRewardsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                AWARDED_ALREADY = 2
            }
        }

        interface ILevelUpRewardsProto {
            level?: (number|null);
        }

        class LevelUpRewardsProto implements ILevelUpRewardsProto {
            constructor(properties?: POGOProtos.Rpc.ILevelUpRewardsProto);
            public level: number;
            public static encode(message: POGOProtos.Rpc.ILevelUpRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LevelUpRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LevelUpRewardsProto;
            public static toObject(message: POGOProtos.Rpc.LevelUpRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILevelUpRewardsSettingsProto {
            level?: (number|null);
            items?: (POGOProtos.Rpc.Item[]|null);
            items_count?: (number[]|null);
            items_unlocked?: (POGOProtos.Rpc.Item[]|null);
            avatar_template_ids?: (string[]|null);
            pokecoins?: (number|null);
            neutral_avatar_item_templates?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto[]|null);
        }

        class LevelUpRewardsSettingsProto implements ILevelUpRewardsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILevelUpRewardsSettingsProto);
            public level: number;
            public items: POGOProtos.Rpc.Item[];
            public items_count: number[];
            public items_unlocked: POGOProtos.Rpc.Item[];
            public avatar_template_ids: string[];
            public pokecoins: number;
            public neutral_avatar_item_templates: POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto[];
            public static encode(message: POGOProtos.Rpc.ILevelUpRewardsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LevelUpRewardsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LevelUpRewardsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LevelUpRewardsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILeveledUpFriendsProto {
            friend_profiles?: (POGOProtos.Rpc.IPlayerPublicProfileProto[]|null);
            friend_milestone_levels?: (POGOProtos.Rpc.IFriendshipLevelDataProto[]|null);
        }

        class LeveledUpFriendsProto implements ILeveledUpFriendsProto {
            constructor(properties?: POGOProtos.Rpc.ILeveledUpFriendsProto);
            public friend_profiles: POGOProtos.Rpc.IPlayerPublicProfileProto[];
            public friend_milestone_levels: POGOProtos.Rpc.IFriendshipLevelDataProto[];
            public static encode(message: POGOProtos.Rpc.ILeveledUpFriendsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LeveledUpFriendsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LeveledUpFriendsProto;
            public static toObject(message: POGOProtos.Rpc.LeveledUpFriendsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILiftUserAgeGateConfirmationOutProto {
            result?: (POGOProtos.Rpc.LiftUserAgeGateConfirmationOutProto.Result|null);
            error_message?: (string|null);
        }

        class LiftUserAgeGateConfirmationOutProto implements ILiftUserAgeGateConfirmationOutProto {
            constructor(properties?: POGOProtos.Rpc.ILiftUserAgeGateConfirmationOutProto);
            public result: POGOProtos.Rpc.LiftUserAgeGateConfirmationOutProto.Result;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.ILiftUserAgeGateConfirmationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LiftUserAgeGateConfirmationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LiftUserAgeGateConfirmationOutProto;
            public static toObject(message: POGOProtos.Rpc.LiftUserAgeGateConfirmationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LiftUserAgeGateConfirmationOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ILiftUserAgeGateConfirmationProto {
            user_id?: (string|null);
        }

        class LiftUserAgeGateConfirmationProto implements ILiftUserAgeGateConfirmationProto {
            constructor(properties?: POGOProtos.Rpc.ILiftUserAgeGateConfirmationProto);
            public user_id: string;
            public static encode(message: POGOProtos.Rpc.ILiftUserAgeGateConfirmationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LiftUserAgeGateConfirmationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LiftUserAgeGateConfirmationProto;
            public static toObject(message: POGOProtos.Rpc.LiftUserAgeGateConfirmationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILikeRoutePinOutProto {
            result?: (POGOProtos.Rpc.LikeRoutePinOutProto.Result|null);
            updated_pin?: (POGOProtos.Rpc.IRoutePin|null);
        }

        class LikeRoutePinOutProto implements ILikeRoutePinOutProto {
            constructor(properties?: POGOProtos.Rpc.ILikeRoutePinOutProto);
            public result: POGOProtos.Rpc.LikeRoutePinOutProto.Result;
            public updated_pin?: (POGOProtos.Rpc.IRoutePin|null);
            public static encode(message: POGOProtos.Rpc.ILikeRoutePinOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LikeRoutePinOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LikeRoutePinOutProto;
            public static toObject(message: POGOProtos.Rpc.LikeRoutePinOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LikeRoutePinOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ROUTE_NOT_FOUND = 3,
                ERROR_PIN_NOT_FOUND = 4,
                ERROR_STICKER_NOT_FOUND = 5,
                ERROR_NOT_ENOUGH_STICKERS = 6,
                ERROR_STICKER_LIMIT = 7
            }
        }

        interface ILikeRoutePinProto {
            like?: (boolean|null);
            route_id?: (string|null);
            pin_id?: (string|null);
            sticker_id?: (string|null);
        }

        class LikeRoutePinProto implements ILikeRoutePinProto {
            constructor(properties?: POGOProtos.Rpc.ILikeRoutePinProto);
            public like?: (boolean|null);
            public route_id: string;
            public pin_id: string;
            public sticker_id: string;
            public LikeData?: "like";
            public static encode(message: POGOProtos.Rpc.ILikeRoutePinProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LikeRoutePinProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LikeRoutePinProto;
            public static toObject(message: POGOProtos.Rpc.LikeRoutePinProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILimitedEditionPokemonEncounterRewardProto {
            lifetime_max_count?: (number|null);
            per_competitive_combat_season_max_count?: (number|null);
            pokemon?: (POGOProtos.Rpc.IPokemonEncounterRewardProto|null);
            identifier?: (string|null);
        }

        class LimitedEditionPokemonEncounterRewardProto implements ILimitedEditionPokemonEncounterRewardProto {
            constructor(properties?: POGOProtos.Rpc.ILimitedEditionPokemonEncounterRewardProto);
            public lifetime_max_count?: (number|null);
            public per_competitive_combat_season_max_count?: (number|null);
            public pokemon?: (POGOProtos.Rpc.IPokemonEncounterRewardProto|null);
            public identifier: string;
            public Limit?: ("lifetime_max_count"|"per_competitive_combat_season_max_count");
            public static encode(message: POGOProtos.Rpc.ILimitedEditionPokemonEncounterRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LimitedEditionPokemonEncounterRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LimitedEditionPokemonEncounterRewardProto;
            public static toObject(message: POGOProtos.Rpc.LimitedEditionPokemonEncounterRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILimitedPurchaseSkuRecordProto {
            purchases?: ({ [k: string]: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.IPurchaseProto }|null);
        }

        class LimitedPurchaseSkuRecordProto implements ILimitedPurchaseSkuRecordProto {
            constructor(properties?: POGOProtos.Rpc.ILimitedPurchaseSkuRecordProto);
            public purchases: { [k: string]: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.IPurchaseProto };
            public static encode(message: POGOProtos.Rpc.ILimitedPurchaseSkuRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LimitedPurchaseSkuRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LimitedPurchaseSkuRecordProto;
            public static toObject(message: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LimitedPurchaseSkuRecordProto {

            enum ChronoUnit {
                UNSET = 0,
                MINUTE = 1,
                HOUR = 2,
                DAY = 3,
                WEEK = 4,
                MONTH = 5
            }

            interface IPurchaseProto {
                version?: (number|null);
                num_purchases?: (number|null);
                last_purchase_ms?: (number|Long|null);
                total_num_purchases?: (number|null);
            }

            class PurchaseProto implements IPurchaseProto {
                constructor(properties?: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.IPurchaseProto);
                public version: number;
                public num_purchases: number;
                public last_purchase_ms: (number|Long);
                public total_num_purchases: number;
                public static encode(message: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.IPurchaseProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.PurchaseProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.PurchaseProto;
                public static toObject(message: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.PurchaseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ILimitedPurchaseSkuSettingsProto {
            purchase_limit?: (number|null);
            version?: (number|null);
            chrono_unit?: (POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.ChronoUnit|null);
            loot_table_id?: (string|null);
            reset_interval?: (number|null);
        }

        class LimitedPurchaseSkuSettingsProto implements ILimitedPurchaseSkuSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILimitedPurchaseSkuSettingsProto);
            public purchase_limit: number;
            public version: number;
            public chrono_unit: POGOProtos.Rpc.LimitedPurchaseSkuRecordProto.ChronoUnit;
            public loot_table_id: string;
            public reset_interval: number;
            public static encode(message: POGOProtos.Rpc.ILimitedPurchaseSkuSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LimitedPurchaseSkuSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LimitedPurchaseSkuSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LimitedPurchaseSkuSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILineProto {
            vertex?: (POGOProtos.Rpc.IPointProto[]|null);
        }

        class LineProto implements ILineProto {
            constructor(properties?: POGOProtos.Rpc.ILineProto);
            public vertex: POGOProtos.Rpc.IPointProto[];
            public static encode(message: POGOProtos.Rpc.ILineProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LineProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LineProto;
            public static toObject(message: POGOProtos.Rpc.LineProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILinkLoginTelemetry {
            linked?: (boolean|null);
            success?: (string|null);
            error?: (string|null);
            active_auth_provider_id?: (string|null);
            provider?: (string|null);
        }

        class LinkLoginTelemetry implements ILinkLoginTelemetry {
            constructor(properties?: POGOProtos.Rpc.ILinkLoginTelemetry);
            public linked: boolean;
            public success: string;
            public error: string;
            public active_auth_provider_id: string;
            public provider: string;
            public static encode(message: POGOProtos.Rpc.ILinkLoginTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LinkLoginTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LinkLoginTelemetry;
            public static toObject(message: POGOProtos.Rpc.LinkLoginTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILinkToAccountLoginRequestProto {
            new_auth_token?: (Uint8Array|null);
            new_auth_provider_id?: (string|null);
        }

        class LinkToAccountLoginRequestProto implements ILinkToAccountLoginRequestProto {
            constructor(properties?: POGOProtos.Rpc.ILinkToAccountLoginRequestProto);
            public new_auth_token: Uint8Array;
            public new_auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.ILinkToAccountLoginRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LinkToAccountLoginRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LinkToAccountLoginRequestProto;
            public static toObject(message: POGOProtos.Rpc.LinkToAccountLoginRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILinkToAccountLoginResponseProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
            status?: (POGOProtos.Rpc.LinkToAccountLoginResponseProto.Status|null);
        }

        class LinkToAccountLoginResponseProto implements ILinkToAccountLoginResponseProto {
            constructor(properties?: POGOProtos.Rpc.ILinkToAccountLoginResponseProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public status: POGOProtos.Rpc.LinkToAccountLoginResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.ILinkToAccountLoginResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LinkToAccountLoginResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LinkToAccountLoginResponseProto;
            public static toObject(message: POGOProtos.Rpc.LinkToAccountLoginResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LinkToAccountLoginResponseProto {

            enum Status {
                UNSET = 0,
                UNKNOWN_ERROR = 1,
                AUTH_FAILURE = 2,
                LOGIN_TAKEN = 3,
                GUEST_LOGIN_DISABLED = 4,
                SUCCESS_ALREADY_LINKED = 5
            }
        }

        interface ILiquidAttribute {
            int_value?: (number|Long|null);
            double_value?: (number|null);
            string_value?: (string|null);
            bool_value?: (boolean|null);
        }

        class LiquidAttribute implements ILiquidAttribute {
            constructor(properties?: POGOProtos.Rpc.ILiquidAttribute);
            public int_value?: (number|Long|null);
            public double_value?: (number|null);
            public string_value?: (string|null);
            public bool_value?: (boolean|null);
            public Value?: ("int_value"|"double_value"|"string_value"|"bool_value");
            public static encode(message: POGOProtos.Rpc.ILiquidAttribute, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LiquidAttribute;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LiquidAttribute;
            public static toObject(message: POGOProtos.Rpc.LiquidAttribute, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListAvatarAppearanceItemsOutProto {
            result?: (POGOProtos.Rpc.ListAvatarAppearanceItemsOutProto.Result|null);
            appearances?: (POGOProtos.Rpc.IAvatarStoreListingProto[]|null);
        }

        class ListAvatarAppearanceItemsOutProto implements IListAvatarAppearanceItemsOutProto {
            constructor(properties?: POGOProtos.Rpc.IListAvatarAppearanceItemsOutProto);
            public result: POGOProtos.Rpc.ListAvatarAppearanceItemsOutProto.Result;
            public appearances: POGOProtos.Rpc.IAvatarStoreListingProto[];
            public static encode(message: POGOProtos.Rpc.IListAvatarAppearanceItemsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarAppearanceItemsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarAppearanceItemsOutProto;
            public static toObject(message: POGOProtos.Rpc.ListAvatarAppearanceItemsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ListAvatarAppearanceItemsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IListAvatarAppearanceItemsProto {
        }

        class ListAvatarAppearanceItemsProto implements IListAvatarAppearanceItemsProto {
            constructor(properties?: POGOProtos.Rpc.IListAvatarAppearanceItemsProto);
            public static encode(message: POGOProtos.Rpc.IListAvatarAppearanceItemsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarAppearanceItemsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarAppearanceItemsProto;
            public static toObject(message: POGOProtos.Rpc.ListAvatarAppearanceItemsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListAvatarCustomizationsOutProto {
            result?: (POGOProtos.Rpc.ListAvatarCustomizationsOutProto.Result|null);
            avatar_customizations?: (POGOProtos.Rpc.ListAvatarCustomizationsOutProto.IAvatarCustomization[]|null);
        }

        class ListAvatarCustomizationsOutProto implements IListAvatarCustomizationsOutProto {
            constructor(properties?: POGOProtos.Rpc.IListAvatarCustomizationsOutProto);
            public result: POGOProtos.Rpc.ListAvatarCustomizationsOutProto.Result;
            public avatar_customizations: POGOProtos.Rpc.ListAvatarCustomizationsOutProto.IAvatarCustomization[];
            public static encode(message: POGOProtos.Rpc.IListAvatarCustomizationsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarCustomizationsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarCustomizationsOutProto;
            public static toObject(message: POGOProtos.Rpc.ListAvatarCustomizationsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ListAvatarCustomizationsOutProto {

            enum Label {
                UNSET_LABEL = 0,
                DEFAULT = 1,
                OWNED = 2,
                FEATURED = 3,
                NEW = 4,
                SALE = 5,
                PURCHASABLE = 6,
                UNLOCKABLE = 7,
                VIEWED = 8,
                LOCKED_PURCHASABLE = 9
            }

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }

            interface IAvatarCustomization {
                avatar_template_id?: (string|null);
                labels?: (POGOProtos.Rpc.ListAvatarCustomizationsOutProto.Label[]|null);
            }

            class AvatarCustomization implements IAvatarCustomization {
                constructor(properties?: POGOProtos.Rpc.ListAvatarCustomizationsOutProto.IAvatarCustomization);
                public avatar_template_id: string;
                public labels: POGOProtos.Rpc.ListAvatarCustomizationsOutProto.Label[];
                public static encode(message: POGOProtos.Rpc.ListAvatarCustomizationsOutProto.IAvatarCustomization, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarCustomizationsOutProto.AvatarCustomization;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarCustomizationsOutProto.AvatarCustomization;
                public static toObject(message: POGOProtos.Rpc.ListAvatarCustomizationsOutProto.AvatarCustomization, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IListAvatarCustomizationsProto {
            avatar_type?: (POGOProtos.Rpc.PlayerAvatarType|null);
            slot?: (POGOProtos.Rpc.AvatarCustomizationProto.Slot[]|null);
            filters?: (POGOProtos.Rpc.ListAvatarCustomizationsProto.Filter[]|null);
            start?: (number|null);
            limit?: (number|null);
        }

        class ListAvatarCustomizationsProto implements IListAvatarCustomizationsProto {
            constructor(properties?: POGOProtos.Rpc.IListAvatarCustomizationsProto);
            public avatar_type: POGOProtos.Rpc.PlayerAvatarType;
            public slot: POGOProtos.Rpc.AvatarCustomizationProto.Slot[];
            public filters: POGOProtos.Rpc.ListAvatarCustomizationsProto.Filter[];
            public start: number;
            public limit: number;
            public static encode(message: POGOProtos.Rpc.IListAvatarCustomizationsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarCustomizationsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarCustomizationsProto;
            public static toObject(message: POGOProtos.Rpc.ListAvatarCustomizationsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ListAvatarCustomizationsProto {

            enum Filter {
                UNSET = 0,
                ALL = 1,
                DEFAULT = 2,
                OWNED = 3,
                FEATURED = 4,
                PURCHASABLE = 5,
                UNLOCKABLE = 6
            }
        }

        interface IListAvatarStoreItemsOutProto {
            result?: (POGOProtos.Rpc.ListAvatarStoreItemsOutProto.Result|null);
            listings?: (POGOProtos.Rpc.IAvatarStoreListingProto[]|null);
            filters?: (POGOProtos.Rpc.IAvatarStoreFilterProto[]|null);
        }

        class ListAvatarStoreItemsOutProto implements IListAvatarStoreItemsOutProto {
            constructor(properties?: POGOProtos.Rpc.IListAvatarStoreItemsOutProto);
            public result: POGOProtos.Rpc.ListAvatarStoreItemsOutProto.Result;
            public listings: POGOProtos.Rpc.IAvatarStoreListingProto[];
            public filters: POGOProtos.Rpc.IAvatarStoreFilterProto[];
            public static encode(message: POGOProtos.Rpc.IListAvatarStoreItemsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarStoreItemsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarStoreItemsOutProto;
            public static toObject(message: POGOProtos.Rpc.ListAvatarStoreItemsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ListAvatarStoreItemsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IListAvatarStoreItemsProto {
        }

        class ListAvatarStoreItemsProto implements IListAvatarStoreItemsProto {
            constructor(properties?: POGOProtos.Rpc.IListAvatarStoreItemsProto);
            public static encode(message: POGOProtos.Rpc.IListAvatarStoreItemsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListAvatarStoreItemsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListAvatarStoreItemsProto;
            public static toObject(message: POGOProtos.Rpc.ListAvatarStoreItemsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListExperiencesFilter {
            circle?: (POGOProtos.Rpc.ICircleShape|null);
        }

        class ListExperiencesFilter implements IListExperiencesFilter {
            constructor(properties?: POGOProtos.Rpc.IListExperiencesFilter);
            public circle?: (POGOProtos.Rpc.ICircleShape|null);
            public shape?: "circle";
            public static encode(message: POGOProtos.Rpc.IListExperiencesFilter, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListExperiencesFilter;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListExperiencesFilter;
            public static toObject(message: POGOProtos.Rpc.ListExperiencesFilter, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListExperiencesRequest {
            filter?: (POGOProtos.Rpc.IListExperiencesFilter|null);
        }

        class ListExperiencesRequest implements IListExperiencesRequest {
            constructor(properties?: POGOProtos.Rpc.IListExperiencesRequest);
            public filter?: (POGOProtos.Rpc.IListExperiencesFilter|null);
            public static encode(message: POGOProtos.Rpc.IListExperiencesRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListExperiencesRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListExperiencesRequest;
            public static toObject(message: POGOProtos.Rpc.ListExperiencesRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListExperiencesResponse {
            experiences?: (POGOProtos.Rpc.IExperience[]|null);
        }

        class ListExperiencesResponse implements IListExperiencesResponse {
            constructor(properties?: POGOProtos.Rpc.IListExperiencesResponse);
            public experiences: POGOProtos.Rpc.IExperience[];
            public static encode(message: POGOProtos.Rpc.IListExperiencesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListExperiencesResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListExperiencesResponse;
            public static toObject(message: POGOProtos.Rpc.ListExperiencesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListFriendActivitiesRequestProto {
        }

        class ListFriendActivitiesRequestProto implements IListFriendActivitiesRequestProto {
            constructor(properties?: POGOProtos.Rpc.IListFriendActivitiesRequestProto);
            public static encode(message: POGOProtos.Rpc.IListFriendActivitiesRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListFriendActivitiesRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListFriendActivitiesRequestProto;
            public static toObject(message: POGOProtos.Rpc.ListFriendActivitiesRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListFriendActivitiesResponseProto {
            result?: (POGOProtos.Rpc.ListFriendActivitiesResponseProto.Result|null);
            friend_activity?: (POGOProtos.Rpc.ListFriendActivitiesResponseProto.IFriendActivityProto[]|null);
        }

        class ListFriendActivitiesResponseProto implements IListFriendActivitiesResponseProto {
            constructor(properties?: POGOProtos.Rpc.IListFriendActivitiesResponseProto);
            public result: POGOProtos.Rpc.ListFriendActivitiesResponseProto.Result;
            public friend_activity: POGOProtos.Rpc.ListFriendActivitiesResponseProto.IFriendActivityProto[];
            public static encode(message: POGOProtos.Rpc.IListFriendActivitiesResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListFriendActivitiesResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListFriendActivitiesResponseProto;
            public static toObject(message: POGOProtos.Rpc.ListFriendActivitiesResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ListFriendActivitiesResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }

            interface IFriendActivityProto {
                nia_account_id?: (string|null);
                friend_activity?: (Uint8Array|null);
                friend_activity_received_timestamp_ms?: (number|Long|null);
                friend_activity_expiry_timestamp_ms?: (number|Long|null);
            }

            class FriendActivityProto implements IFriendActivityProto {
                constructor(properties?: POGOProtos.Rpc.ListFriendActivitiesResponseProto.IFriendActivityProto);
                public nia_account_id: string;
                public friend_activity: Uint8Array;
                public friend_activity_received_timestamp_ms: (number|Long);
                public friend_activity_expiry_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.ListFriendActivitiesResponseProto.IFriendActivityProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListFriendActivitiesResponseProto.FriendActivityProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListFriendActivitiesResponseProto.FriendActivityProto;
                public static toObject(message: POGOProtos.Rpc.ListFriendActivitiesResponseProto.FriendActivityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IListGymBadgesOutProto {
            gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge[]|null);
        }

        class ListGymBadgesOutProto implements IListGymBadgesOutProto {
            constructor(properties?: POGOProtos.Rpc.IListGymBadgesOutProto);
            public gym_badge: POGOProtos.Rpc.IAwardedGymBadge[];
            public static encode(message: POGOProtos.Rpc.IListGymBadgesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListGymBadgesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListGymBadgesOutProto;
            public static toObject(message: POGOProtos.Rpc.ListGymBadgesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListGymBadgesProto {
        }

        class ListGymBadgesProto implements IListGymBadgesProto {
            constructor(properties?: POGOProtos.Rpc.IListGymBadgesProto);
            public static encode(message: POGOProtos.Rpc.IListGymBadgesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListGymBadgesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListGymBadgesProto;
            public static toObject(message: POGOProtos.Rpc.ListGymBadgesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
        }

        class ListLoginActionOutProto implements IListLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IListLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public static encode(message: POGOProtos.Rpc.IListLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.ListLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListRouteBadgesOutProto {
            route_badges?: (POGOProtos.Rpc.IRouteBadgeListEntry[]|null);
            awarded_route_badges?: (POGOProtos.Rpc.IAwardedRouteBadge[]|null);
        }

        class ListRouteBadgesOutProto implements IListRouteBadgesOutProto {
            constructor(properties?: POGOProtos.Rpc.IListRouteBadgesOutProto);
            public route_badges: POGOProtos.Rpc.IRouteBadgeListEntry[];
            public awarded_route_badges: POGOProtos.Rpc.IAwardedRouteBadge[];
            public static encode(message: POGOProtos.Rpc.IListRouteBadgesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListRouteBadgesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListRouteBadgesOutProto;
            public static toObject(message: POGOProtos.Rpc.ListRouteBadgesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListRouteBadgesProto {
        }

        class ListRouteBadgesProto implements IListRouteBadgesProto {
            constructor(properties?: POGOProtos.Rpc.IListRouteBadgesProto);
            public static encode(message: POGOProtos.Rpc.IListRouteBadgesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListRouteBadgesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListRouteBadgesProto;
            public static toObject(message: POGOProtos.Rpc.ListRouteBadgesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListRouteStampsOutProto {
            route_stamps?: (POGOProtos.Rpc.IAwardedRouteStamp[]|null);
        }

        class ListRouteStampsOutProto implements IListRouteStampsOutProto {
            constructor(properties?: POGOProtos.Rpc.IListRouteStampsOutProto);
            public route_stamps: POGOProtos.Rpc.IAwardedRouteStamp[];
            public static encode(message: POGOProtos.Rpc.IListRouteStampsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListRouteStampsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListRouteStampsOutProto;
            public static toObject(message: POGOProtos.Rpc.ListRouteStampsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListRouteStampsProto {
        }

        class ListRouteStampsProto implements IListRouteStampsProto {
            constructor(properties?: POGOProtos.Rpc.IListRouteStampsProto);
            public static encode(message: POGOProtos.Rpc.IListRouteStampsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListRouteStampsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListRouteStampsProto;
            public static toObject(message: POGOProtos.Rpc.ListRouteStampsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IListValue {
        }

        class ListValue implements IListValue {
            constructor(properties?: POGOProtos.Rpc.IListValue);
            public static encode(message: POGOProtos.Rpc.IListValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ListValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ListValue;
            public static toObject(message: POGOProtos.Rpc.ListValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoadingScreenProto {
            url?: (string|null);
            display_after_timestamp_ms?: (number|Long|null);
            color_settings?: ({ [k: string]: string }|null);
        }

        class LoadingScreenProto implements ILoadingScreenProto {
            constructor(properties?: POGOProtos.Rpc.ILoadingScreenProto);
            public url: string;
            public display_after_timestamp_ms: (number|Long);
            public color_settings: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.ILoadingScreenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoadingScreenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoadingScreenProto;
            public static toObject(message: POGOProtos.Rpc.LoadingScreenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILobbyClientSettingsProto {
            lobby_refresh_interval_ms?: (number|Long|null);
        }

        class LobbyClientSettingsProto implements ILobbyClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILobbyClientSettingsProto);
            public lobby_refresh_interval_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ILobbyClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LobbyClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LobbyClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LobbyClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILobbyPokemonProto {
            id?: (number|Long|null);
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            percent_health?: (number|null);
        }

        class LobbyPokemonProto implements ILobbyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ILobbyPokemonProto);
            public id: (number|Long);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public percent_health: number;
            public static encode(message: POGOProtos.Rpc.ILobbyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LobbyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LobbyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.LobbyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILobbyProto {
            lobby_id?: (number[]|null);
            players?: (POGOProtos.Rpc.IBattleParticipantProto[]|null);
            player_join_end_ms?: (number|Long|null);
            pokemon_selection_end_ms?: (number|Long|null);
            raid_battle_start_ms?: (number|Long|null);
            raid_battle_end_ms?: (number|Long|null);
            raid_battle_id?: (string|null);
            owner_nickname?: (string|null);
            "private"?: (boolean|null);
            creation_ms?: (number|Long|null);
            battle_plfe_instance?: (number|null);
            weather_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            invited_player_ids?: (string[]|null);
            is_shard_manager_battle_enabled?: (boolean|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            rvn_version?: (number|null);
        }

        class LobbyProto implements ILobbyProto {
            constructor(properties?: POGOProtos.Rpc.ILobbyProto);
            public lobby_id: number[];
            public players: POGOProtos.Rpc.IBattleParticipantProto[];
            public player_join_end_ms: (number|Long);
            public pokemon_selection_end_ms: (number|Long);
            public raid_battle_start_ms: (number|Long);
            public raid_battle_end_ms: (number|Long);
            public raid_battle_id: string;
            public owner_nickname: string;
            public private: boolean;
            public creation_ms: (number|Long);
            public battle_plfe_instance: number;
            public weather_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public invited_player_ids: string[];
            public is_shard_manager_battle_enabled: boolean;
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public rvn_version: number;
            public static encode(message: POGOProtos.Rpc.ILobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LobbyProto;
            public static toObject(message: POGOProtos.Rpc.LobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILobbyVisibilityData {
            rpc_id?: (number|null);
        }

        class LobbyVisibilityData implements ILobbyVisibilityData {
            constructor(properties?: POGOProtos.Rpc.ILobbyVisibilityData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ILobbyVisibilityData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LobbyVisibilityData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LobbyVisibilityData;
            public static toObject(message: POGOProtos.Rpc.LobbyVisibilityData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILobbyVisibilityResponseData {
            result?: (POGOProtos.Rpc.SetLobbyVisibilityOutProto.Result|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class LobbyVisibilityResponseData implements ILobbyVisibilityResponseData {
            constructor(properties?: POGOProtos.Rpc.ILobbyVisibilityResponseData);
            public result: POGOProtos.Rpc.SetLobbyVisibilityOutProto.Result;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.ILobbyVisibilityResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LobbyVisibilityResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LobbyVisibilityResponseData;
            public static toObject(message: POGOProtos.Rpc.LobbyVisibilityResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocalDateTimeProto {
            year?: (number|null);
            month?: (number|null);
            day_of_month?: (number|null);
            hour?: (number|null);
            minute?: (number|null);
            second?: (number|null);
            nano_of_second?: (number|null);
        }

        class LocalDateTimeProto implements ILocalDateTimeProto {
            constructor(properties?: POGOProtos.Rpc.ILocalDateTimeProto);
            public year: number;
            public month: number;
            public day_of_month: number;
            public hour: number;
            public minute: number;
            public second: number;
            public nano_of_second: number;
            public static encode(message: POGOProtos.Rpc.ILocalDateTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocalDateTimeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocalDateTimeProto;
            public static toObject(message: POGOProtos.Rpc.LocalDateTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocationCardDisplayProto {
            location_card?: (POGOProtos.Rpc.LocationCard|null);
        }

        class LocationCardDisplayProto implements ILocationCardDisplayProto {
            constructor(properties?: POGOProtos.Rpc.ILocationCardDisplayProto);
            public location_card: POGOProtos.Rpc.LocationCard;
            public static encode(message: POGOProtos.Rpc.ILocationCardDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationCardDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationCardDisplayProto;
            public static toObject(message: POGOProtos.Rpc.LocationCardDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocationCardFeatureSettingsProto {
            enabled?: (boolean|null);
            ob_bool?: (boolean|null);
        }

        class LocationCardFeatureSettingsProto implements ILocationCardFeatureSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILocationCardFeatureSettingsProto);
            public enabled: boolean;
            public ob_bool: boolean;
            public static encode(message: POGOProtos.Rpc.ILocationCardFeatureSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationCardFeatureSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationCardFeatureSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LocationCardFeatureSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocationCardSettingsProto {
            location_card?: (POGOProtos.Rpc.LocationCard|null);
            image_url?: (string|null);
            card_type?: (POGOProtos.Rpc.CardType|null);
            vfx_address?: (string|null);
        }

        class LocationCardSettingsProto implements ILocationCardSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILocationCardSettingsProto);
            public location_card: POGOProtos.Rpc.LocationCard;
            public image_url: string;
            public card_type: POGOProtos.Rpc.CardType;
            public vfx_address: string;
            public static encode(message: POGOProtos.Rpc.ILocationCardSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationCardSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationCardSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LocationCardSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocationE6Proto {
            latitude_e6?: (number|null);
            longitude_e6?: (number|null);
        }

        class LocationE6Proto implements ILocationE6Proto {
            constructor(properties?: POGOProtos.Rpc.ILocationE6Proto);
            public latitude_e6: number;
            public longitude_e6: number;
            public static encode(message: POGOProtos.Rpc.ILocationE6Proto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationE6Proto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationE6Proto;
            public static toObject(message: POGOProtos.Rpc.LocationE6Proto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocationPingOutProto {
        }

        class LocationPingOutProto implements ILocationPingOutProto {
            constructor(properties?: POGOProtos.Rpc.ILocationPingOutProto);
            public static encode(message: POGOProtos.Rpc.ILocationPingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationPingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationPingOutProto;
            public static toObject(message: POGOProtos.Rpc.LocationPingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILocationPingProto {
            geofence_identifier?: (string|null);
            reason?: (POGOProtos.Rpc.LocationPingProto.PingReason|null);
        }

        class LocationPingProto implements ILocationPingProto {
            constructor(properties?: POGOProtos.Rpc.ILocationPingProto);
            public geofence_identifier: string;
            public reason: POGOProtos.Rpc.LocationPingProto.PingReason;
            public static encode(message: POGOProtos.Rpc.ILocationPingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationPingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationPingProto;
            public static toObject(message: POGOProtos.Rpc.LocationPingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LocationPingProto {

            enum PingReason {
                UNSET = 0,
                ENTRANCE_EVENT = 1,
                EXIT_EVENT = 2,
                DWELL_EVENT = 3,
                VISIT_EVENT = 4,
                FITNESS_WAKEUP = 5,
                OTHER_WAKEUP = 6
            }
        }

        interface ILocationPingUpdateProto {
            geofence_identifier?: (string|null);
            reason?: (POGOProtos.Rpc.LocationPingUpdateProto.PingReason|null);
            timestamp_ms?: (number|Long|null);
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
            app_is_foregrounded?: (boolean|null);
            time_zone?: (string|null);
            time_zone_offset_min?: (number|null);
            accuracy_m?: (number|null);
        }

        class LocationPingUpdateProto implements ILocationPingUpdateProto {
            constructor(properties?: POGOProtos.Rpc.ILocationPingUpdateProto);
            public geofence_identifier: string;
            public reason: POGOProtos.Rpc.LocationPingUpdateProto.PingReason;
            public timestamp_ms: (number|Long);
            public latitude_deg: number;
            public longitude_deg: number;
            public app_is_foregrounded: boolean;
            public time_zone: string;
            public time_zone_offset_min: number;
            public accuracy_m: number;
            public static encode(message: POGOProtos.Rpc.ILocationPingUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LocationPingUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LocationPingUpdateProto;
            public static toObject(message: POGOProtos.Rpc.LocationPingUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LocationPingUpdateProto {

            enum PingReason {
                UNSET = 0,
                ENTRANCE_EVENT = 1,
                EXIT_EVENT = 2,
                DWELL_EVENT = 3,
                VISIT_EVENT = 4,
                FITNESS_WAKEUP = 5,
                OTHER_WAKEUP = 6
            }
        }

        interface ILogEntry {
            join_lobby_data?: (POGOProtos.Rpc.IJoinLobbyData|null);
            join_lobby_response_data?: (POGOProtos.Rpc.IJoinLobbyResponseData|null);
            leave_lobby_data?: (POGOProtos.Rpc.ILeaveLobbyData|null);
            leave_lobby_response_data?: (POGOProtos.Rpc.ILeaveLobbyResponseData|null);
            lobby_visibility_data?: (POGOProtos.Rpc.ILobbyVisibilityData|null);
            lobby_visibility_response_data?: (POGOProtos.Rpc.ILobbyVisibilityResponseData|null);
            get_raid_details_data?: (POGOProtos.Rpc.IGetRaidDetailsData|null);
            get_raid_details_response_data?: (POGOProtos.Rpc.IGetRaidDetailsResponseData|null);
            start_raid_battle_data?: (POGOProtos.Rpc.IStartRaidBattleData|null);
            start_raid_battle_response_data?: (POGOProtos.Rpc.IStartRaidBattleResponseData|null);
            attack_raid_data?: (POGOProtos.Rpc.IAttackRaidData|null);
            attack_raid_response_data?: (POGOProtos.Rpc.IAttackRaidResponseData|null);
            send_raid_invitation_data?: (POGOProtos.Rpc.ISendRaidInvitationData|null);
            send_raid_invitation_response_data?: (POGOProtos.Rpc.ISendRaidInvitationResponseData|null);
            on_application_focus_data?: (POGOProtos.Rpc.IOnApplicationFocusData|null);
            on_application_pause_data?: (POGOProtos.Rpc.IOnApplicationPauseData|null);
            on_application_quit_data?: (POGOProtos.Rpc.IOnApplicationQuitData|null);
            exception_caught_data?: (POGOProtos.Rpc.IExceptionCaughtData|null);
            progress_token_data?: (POGOProtos.Rpc.IProgressTokenData|null);
            rpc_error_data?: (POGOProtos.Rpc.IRpcErrorData|null);
            client_prediction_inconsistency_data?: (POGOProtos.Rpc.IClientPredictionInconsistencyData|null);
            raid_end_data?: (POGOProtos.Rpc.IRaidEndData|null);
            header?: (POGOProtos.Rpc.LogEntry.ILogEntryHeader|null);
        }

        class LogEntry implements ILogEntry {
            constructor(properties?: POGOProtos.Rpc.ILogEntry);
            public join_lobby_data?: (POGOProtos.Rpc.IJoinLobbyData|null);
            public join_lobby_response_data?: (POGOProtos.Rpc.IJoinLobbyResponseData|null);
            public leave_lobby_data?: (POGOProtos.Rpc.ILeaveLobbyData|null);
            public leave_lobby_response_data?: (POGOProtos.Rpc.ILeaveLobbyResponseData|null);
            public lobby_visibility_data?: (POGOProtos.Rpc.ILobbyVisibilityData|null);
            public lobby_visibility_response_data?: (POGOProtos.Rpc.ILobbyVisibilityResponseData|null);
            public get_raid_details_data?: (POGOProtos.Rpc.IGetRaidDetailsData|null);
            public get_raid_details_response_data?: (POGOProtos.Rpc.IGetRaidDetailsResponseData|null);
            public start_raid_battle_data?: (POGOProtos.Rpc.IStartRaidBattleData|null);
            public start_raid_battle_response_data?: (POGOProtos.Rpc.IStartRaidBattleResponseData|null);
            public attack_raid_data?: (POGOProtos.Rpc.IAttackRaidData|null);
            public attack_raid_response_data?: (POGOProtos.Rpc.IAttackRaidResponseData|null);
            public send_raid_invitation_data?: (POGOProtos.Rpc.ISendRaidInvitationData|null);
            public send_raid_invitation_response_data?: (POGOProtos.Rpc.ISendRaidInvitationResponseData|null);
            public on_application_focus_data?: (POGOProtos.Rpc.IOnApplicationFocusData|null);
            public on_application_pause_data?: (POGOProtos.Rpc.IOnApplicationPauseData|null);
            public on_application_quit_data?: (POGOProtos.Rpc.IOnApplicationQuitData|null);
            public exception_caught_data?: (POGOProtos.Rpc.IExceptionCaughtData|null);
            public progress_token_data?: (POGOProtos.Rpc.IProgressTokenData|null);
            public rpc_error_data?: (POGOProtos.Rpc.IRpcErrorData|null);
            public client_prediction_inconsistency_data?: (POGOProtos.Rpc.IClientPredictionInconsistencyData|null);
            public raid_end_data?: (POGOProtos.Rpc.IRaidEndData|null);
            public header?: (POGOProtos.Rpc.LogEntry.ILogEntryHeader|null);
            public Data?: ("join_lobby_data"|"join_lobby_response_data"|"leave_lobby_data"|"leave_lobby_response_data"|"lobby_visibility_data"|"lobby_visibility_response_data"|"get_raid_details_data"|"get_raid_details_response_data"|"start_raid_battle_data"|"start_raid_battle_response_data"|"attack_raid_data"|"attack_raid_response_data"|"send_raid_invitation_data"|"send_raid_invitation_response_data"|"on_application_focus_data"|"on_application_pause_data"|"on_application_quit_data"|"exception_caught_data"|"progress_token_data"|"rpc_error_data"|"client_prediction_inconsistency_data"|"raid_end_data");
            public static encode(message: POGOProtos.Rpc.ILogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LogEntry;
            public static toObject(message: POGOProtos.Rpc.LogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LogEntry {

            interface ILogEntryHeader {
                type?: (POGOProtos.Rpc.LogEntry.LogEntryHeader.LogType|null);
                time_now_offset_ms?: (number|null);
                client_server_time_offset_ms?: (number|null);
                player_distance_to_gym?: (number|null);
                frame_rate?: (number|null);
            }

            class LogEntryHeader implements ILogEntryHeader {
                constructor(properties?: POGOProtos.Rpc.LogEntry.ILogEntryHeader);
                public type: POGOProtos.Rpc.LogEntry.LogEntryHeader.LogType;
                public time_now_offset_ms: number;
                public client_server_time_offset_ms: number;
                public player_distance_to_gym: number;
                public frame_rate: number;
                public static encode(message: POGOProtos.Rpc.LogEntry.ILogEntryHeader, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LogEntry.LogEntryHeader;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LogEntry.LogEntryHeader;
                public static toObject(message: POGOProtos.Rpc.LogEntry.LogEntryHeader, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace LogEntryHeader {

                enum LogType {
                    NO_TYPE = 0,
                    JOIN_LOBBY_REQUEST = 1,
                    JOIN_LOBBY_RESPONSE = 2,
                    LEAVE_LOBBY_REQUEST = 3,
                    LEAVE_LOBBY_RESPONSE = 4,
                    LOBBY_VISIBILITY_REQUEST = 5,
                    LOBBY_VISIBILITY_RESPONSE = 6,
                    GET_RAID_DETAILS_REQUEST = 7,
                    GET_RAID_DETAILS_RESPONSE = 8,
                    START_RAID_BATTLE_REQUEST = 9,
                    START_RAID_BATTLE_RESPONSE = 10,
                    ATTACK_RAID_REQUEST = 11,
                    ATTACK_RAID_RESPONSE = 12,
                    SEND_RAID_INVITATION_REQUEST = 13,
                    SEND_RAID_INVITATION_RESPONSE = 14,
                    ON_APPLICATION_FOCUS = 15,
                    ON_APPLICATION_PAUSE = 16,
                    ON_APPLICATION_QUIT = 17,
                    EXCEPTION_CAUGHT = 18,
                    PROGRESS_TOKEN = 19,
                    RPC_ERROR = 20,
                    CLIENT_PREDICTION_INCONSISTENCY = 21,
                    PLAYER_END_RAID = 22
                }
            }
        }

        interface ILogEventDropped {
            events_dropped_count?: (number|Long|null);
            reason?: (POGOProtos.Rpc.LogEventDropped.Reason|null);
        }

        class LogEventDropped implements ILogEventDropped {
            constructor(properties?: POGOProtos.Rpc.ILogEventDropped);
            public events_dropped_count: (number|Long);
            public reason: POGOProtos.Rpc.LogEventDropped.Reason;
            public static encode(message: POGOProtos.Rpc.ILogEventDropped, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LogEventDropped;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LogEventDropped;
            public static toObject(message: POGOProtos.Rpc.LogEventDropped, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LogEventDropped {

            enum Reason {
                REASON_UNKNOWN = 0,
                MESSAGE_TOO_OLD = 1,
                CACHE_FULL = 2,
                PAYLOAD_TOO_BIG = 3,
                MAX_RETRIES_REACHED = 4,
                INVALID_PAYLOD = 5,
                SERVER_ERROR = 6
            }
        }

        interface ILogMessage {
            timestamp_ms?: (number|Long|null);
            log_level?: (POGOProtos.Rpc.LogMessage.LogLevel|null);
            log_channel?: (string|null);
            message?: (string|null);
        }

        class LogMessage implements ILogMessage {
            constructor(properties?: POGOProtos.Rpc.ILogMessage);
            public timestamp_ms: (number|Long);
            public log_level: POGOProtos.Rpc.LogMessage.LogLevel;
            public log_channel: string;
            public message: string;
            public static encode(message: POGOProtos.Rpc.ILogMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LogMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LogMessage;
            public static toObject(message: POGOProtos.Rpc.LogMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LogMessage {

            enum LogLevel {
                UNSET = 0,
                FATAL = 1,
                ERROR = 2,
                WARNING = 3,
                INFO = 4,
                VERBOSE = 5,
                TRACE = 6,
                DISABLED = 7
            }
        }

        interface ILogSourceMetrics {
            log_source?: (string|null);
            log_event_dropped?: (POGOProtos.Rpc.ILogEventDropped[]|null);
        }

        class LogSourceMetrics implements ILogSourceMetrics {
            constructor(properties?: POGOProtos.Rpc.ILogSourceMetrics);
            public log_source: string;
            public log_event_dropped: POGOProtos.Rpc.ILogEventDropped[];
            public static encode(message: POGOProtos.Rpc.ILogSourceMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LogSourceMetrics;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LogSourceMetrics;
            public static toObject(message: POGOProtos.Rpc.LogSourceMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginActionTelemetry {
            login_action_id?: (POGOProtos.Rpc.LoginActionTelemetryIds|null);
            first_time?: (boolean|null);
            success?: (boolean|null);
            intent_existing?: (boolean|null);
            error?: (string|null);
            auth_status?: (string|null);
            selection_time?: (number|Long|null);
        }

        class LoginActionTelemetry implements ILoginActionTelemetry {
            constructor(properties?: POGOProtos.Rpc.ILoginActionTelemetry);
            public login_action_id: POGOProtos.Rpc.LoginActionTelemetryIds;
            public first_time: boolean;
            public success: boolean;
            public intent_existing: boolean;
            public error: string;
            public auth_status: string;
            public selection_time: (number|Long);
            public static encode(message: POGOProtos.Rpc.ILoginActionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginActionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginActionTelemetry;
            public static toObject(message: POGOProtos.Rpc.LoginActionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginDetail {
            identity_provider?: (POGOProtos.Rpc.AuthIdentityProvider|null);
            email?: (string|null);
            auth_provider_id?: (string|null);
            third_party_username?: (string|null);
        }

        class LoginDetail implements ILoginDetail {
            constructor(properties?: POGOProtos.Rpc.ILoginDetail);
            public identity_provider: POGOProtos.Rpc.AuthIdentityProvider;
            public email: string;
            public auth_provider_id: string;
            public third_party_username: string;
            public static encode(message: POGOProtos.Rpc.ILoginDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginDetail;
            public static toObject(message: POGOProtos.Rpc.LoginDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginNewPlayer {
            method_name?: (string|null);
        }

        class LoginNewPlayer implements ILoginNewPlayer {
            constructor(properties?: POGOProtos.Rpc.ILoginNewPlayer);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.ILoginNewPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginNewPlayer;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginNewPlayer;
            public static toObject(message: POGOProtos.Rpc.LoginNewPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginNewPlayerCreateAccount {
            method_name?: (string|null);
        }

        class LoginNewPlayerCreateAccount implements ILoginNewPlayerCreateAccount {
            constructor(properties?: POGOProtos.Rpc.ILoginNewPlayerCreateAccount);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.ILoginNewPlayerCreateAccount, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginNewPlayerCreateAccount;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginNewPlayerCreateAccount;
            public static toObject(message: POGOProtos.Rpc.LoginNewPlayerCreateAccount, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginReturningPlayer {
            method_name?: (string|null);
        }

        class LoginReturningPlayer implements ILoginReturningPlayer {
            constructor(properties?: POGOProtos.Rpc.ILoginReturningPlayer);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.ILoginReturningPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginReturningPlayer;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginReturningPlayer;
            public static toObject(message: POGOProtos.Rpc.LoginReturningPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginReturningPlayerSignIn {
            method_name?: (string|null);
        }

        class LoginReturningPlayerSignIn implements ILoginReturningPlayerSignIn {
            constructor(properties?: POGOProtos.Rpc.ILoginReturningPlayerSignIn);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.ILoginReturningPlayerSignIn, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginReturningPlayerSignIn;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginReturningPlayerSignIn;
            public static toObject(message: POGOProtos.Rpc.LoginReturningPlayerSignIn, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginSettingsProto {
            enable_multi_login_linking?: (boolean|null);
        }

        class LoginSettingsProto implements ILoginSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILoginSettingsProto);
            public enable_multi_login_linking: boolean;
            public static encode(message: POGOProtos.Rpc.ILoginSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LoginSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoginStartup {
            method_name?: (string|null);
        }

        class LoginStartup implements ILoginStartup {
            constructor(properties?: POGOProtos.Rpc.ILoginStartup);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.ILoginStartup, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoginStartup;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoginStartup;
            public static toObject(message: POGOProtos.Rpc.LoginStartup, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILoopProto {
            vertex?: (POGOProtos.Rpc.IPointProto[]|null);
        }

        class LoopProto implements ILoopProto {
            constructor(properties?: POGOProtos.Rpc.ILoopProto);
            public vertex: POGOProtos.Rpc.IPointProto[];
            public static encode(message: POGOProtos.Rpc.ILoopProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LoopProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LoopProto;
            public static toObject(message: POGOProtos.Rpc.LoopProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILootItemProto {
            item?: (POGOProtos.Rpc.Item|null);
            stardust?: (boolean|null);
            pokecoin?: (boolean|null);
            pokemon_candy?: (POGOProtos.Rpc.HoloPokemonId|null);
            experience?: (boolean|null);
            pokemon_egg?: (POGOProtos.Rpc.IPokemonProto|null);
            avatar_template_id?: (string|null);
            sticker_id?: (string|null);
            mega_energy_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            xl_candy?: (POGOProtos.Rpc.HoloPokemonId|null);
            follower_pokemon?: (POGOProtos.Rpc.IFollowerPokemonProto|null);
            neutral_avatar_template_id?: (string|null);
            neutral_avatar_item_template?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto|null);
            neutral_avatar_item_display?: (POGOProtos.Rpc.INeutralAvatarLootItemDisplayProto|null);
            count?: (number|null);
        }

        class LootItemProto implements ILootItemProto {
            constructor(properties?: POGOProtos.Rpc.ILootItemProto);
            public item?: (POGOProtos.Rpc.Item|null);
            public stardust?: (boolean|null);
            public pokecoin?: (boolean|null);
            public pokemon_candy?: (POGOProtos.Rpc.HoloPokemonId|null);
            public experience?: (boolean|null);
            public pokemon_egg?: (POGOProtos.Rpc.IPokemonProto|null);
            public avatar_template_id?: (string|null);
            public sticker_id?: (string|null);
            public mega_energy_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            public xl_candy?: (POGOProtos.Rpc.HoloPokemonId|null);
            public follower_pokemon?: (POGOProtos.Rpc.IFollowerPokemonProto|null);
            public neutral_avatar_template_id?: (string|null);
            public neutral_avatar_item_template?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto|null);
            public neutral_avatar_item_display?: (POGOProtos.Rpc.INeutralAvatarLootItemDisplayProto|null);
            public count: number;
            public Type?: ("item"|"stardust"|"pokecoin"|"pokemon_candy"|"experience"|"pokemon_egg"|"avatar_template_id"|"sticker_id"|"mega_energy_pokemon_id"|"xl_candy"|"follower_pokemon"|"neutral_avatar_template_id"|"neutral_avatar_item_template"|"neutral_avatar_item_display");
            public static encode(message: POGOProtos.Rpc.ILootItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LootItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LootItemProto;
            public static toObject(message: POGOProtos.Rpc.LootItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILootProto {
            loot_item?: (POGOProtos.Rpc.ILootItemProto[]|null);
        }

        class LootProto implements ILootProto {
            constructor(properties?: POGOProtos.Rpc.ILootProto);
            public loot_item: POGOProtos.Rpc.ILootItemProto[];
            public static encode(message: POGOProtos.Rpc.ILootProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LootProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LootProto;
            public static toObject(message: POGOProtos.Rpc.LootProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILootStationLogEntry {
            station_id?: (string|null);
            loot?: (POGOProtos.Rpc.ILootProto|null);
            bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
        }

        class LootStationLogEntry implements ILootStationLogEntry {
            constructor(properties?: POGOProtos.Rpc.ILootStationLogEntry);
            public station_id: string;
            public loot?: (POGOProtos.Rpc.ILootProto|null);
            public bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.ILootStationLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LootStationLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LootStationLogEntry;
            public static toObject(message: POGOProtos.Rpc.LootStationLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILootStationOutProto {
            status?: (POGOProtos.Rpc.LootStationOutProto.Status|null);
            loot?: (POGOProtos.Rpc.ILootProto|null);
            bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            spawned_encounter_id?: (number|Long|null);
            pokemon_proto?: (POGOProtos.Rpc.IPokemonProto|null);
            encounter_location?: (string|null);
            encounter_s2_cell_id?: (number|Long|null);
            spawned_encounter_expiration_time_ms?: (number|Long|null);
        }

        class LootStationOutProto implements ILootStationOutProto {
            constructor(properties?: POGOProtos.Rpc.ILootStationOutProto);
            public status: POGOProtos.Rpc.LootStationOutProto.Status;
            public loot?: (POGOProtos.Rpc.ILootProto|null);
            public bonus_loot?: (POGOProtos.Rpc.ILootProto|null);
            public spawned_encounter_id: (number|Long);
            public pokemon_proto?: (POGOProtos.Rpc.IPokemonProto|null);
            public encounter_location: string;
            public encounter_s2_cell_id: (number|Long);
            public spawned_encounter_expiration_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ILootStationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LootStationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LootStationOutProto;
            public static toObject(message: POGOProtos.Rpc.LootStationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace LootStationOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ON_COOLDOWN = 2,
                INVENTORY_FULL = 3,
                NO_SUCH_STATION = 4,
                MP_NOT_ENABLED = 5,
                OUT_OF_RANGE = 6,
                MP_DAILY_CAP_REACHED = 7
            }
        }

        interface ILootStationProto {
            station_id?: (string|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
        }

        class LootStationProto implements ILootStationProto {
            constructor(properties?: POGOProtos.Rpc.ILootStationProto);
            public station_id: string;
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.ILootStationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LootStationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LootStationProto;
            public static toObject(message: POGOProtos.Rpc.LootStationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILuckyPokemonSettingsProto {
            power_up_stardust_discount_percent?: (number|null);
        }

        class LuckyPokemonSettingsProto implements ILuckyPokemonSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ILuckyPokemonSettingsProto);
            public power_up_stardust_discount_percent: number;
            public static encode(message: POGOProtos.Rpc.ILuckyPokemonSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.LuckyPokemonSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.LuckyPokemonSettingsProto;
            public static toObject(message: POGOProtos.Rpc.LuckyPokemonSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMainMenuCameraButtonSettingsProto {
            enabled?: (boolean|null);
        }

        class MainMenuCameraButtonSettingsProto implements IMainMenuCameraButtonSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMainMenuCameraButtonSettingsProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IMainMenuCameraButtonSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MainMenuCameraButtonSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MainMenuCameraButtonSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MainMenuCameraButtonSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IManagedPoseData {
            identifier?: (POGOProtos.Rpc.IUUID|null);
            version?: (number|null);
            creation_time_ms?: (number|Long|null);
            placement_accuracy?: (POGOProtos.Rpc.IPlacementAccuracy|null);
            node_associations?: (POGOProtos.Rpc.INodeAssociation[]|null);
            geo_association?: (POGOProtos.Rpc.IGeoAssociation|null);
        }

        class ManagedPoseData implements IManagedPoseData {
            constructor(properties?: POGOProtos.Rpc.IManagedPoseData);
            public identifier?: (POGOProtos.Rpc.IUUID|null);
            public version: number;
            public creation_time_ms: (number|Long);
            public placement_accuracy?: (POGOProtos.Rpc.IPlacementAccuracy|null);
            public node_associations: POGOProtos.Rpc.INodeAssociation[];
            public geo_association?: (POGOProtos.Rpc.IGeoAssociation|null);
            public static encode(message: POGOProtos.Rpc.IManagedPoseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ManagedPoseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ManagedPoseData;
            public static toObject(message: POGOProtos.Rpc.ManagedPoseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMap {
            node_id?: (POGOProtos.Rpc.INodeId|null);
            num_points?: (number|null);
            map_descriptors?: ((number|Long)[]|null);
            serialized_map_points?: (Uint8Array|null);
            num_blocks?: (number|null);
            key_blocks?: (POGOProtos.Rpc.IKeyBlock[]|null);
            version?: (string|null);
            earliest_compatible_version?: (string|null);
            descriptor_type?: (string|null);
        }

        class Map implements IMap {
            constructor(properties?: POGOProtos.Rpc.IMap);
            public node_id?: (POGOProtos.Rpc.INodeId|null);
            public num_points: number;
            public map_descriptors: (number|Long)[];
            public serialized_map_points: Uint8Array;
            public num_blocks: number;
            public key_blocks: POGOProtos.Rpc.IKeyBlock[];
            public version: string;
            public earliest_compatible_version: string;
            public descriptor_type: string;
            public static encode(message: POGOProtos.Rpc.IMap, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Map;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Map;
            public static toObject(message: POGOProtos.Rpc.Map, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapArea {
            description?: (string|null);
            epoch?: (number|null);
            map_provider?: (string|null);
            bounding_rect?: (POGOProtos.Rpc.IBoundingRect[]|null);
            blocked_label_name?: (string[]|null);
            minimum_client_version?: (string|null);
            tile_encryption_key?: (Uint8Array|null);
        }

        class MapArea implements IMapArea {
            constructor(properties?: POGOProtos.Rpc.IMapArea);
            public description: string;
            public epoch: number;
            public map_provider: string;
            public bounding_rect: POGOProtos.Rpc.IBoundingRect[];
            public blocked_label_name: string[];
            public minimum_client_version: string;
            public tile_encryption_key: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IMapArea, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapArea;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapArea;
            public static toObject(message: POGOProtos.Rpc.MapArea, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapBuddySettingsProto {
            for_buddy_group_number?: (number|null);
            target_offset_min?: (number|null);
            target_offset_max?: (number|null);
            leash_distance?: (number|null);
            max_seconds_to_idle?: (number|null);
            max_rotation_speed?: (number|null);
            walk_threshold?: (number|null);
            run_threshold?: (number|null);
            should_glide?: (boolean|null);
            glide_smooth_time?: (number|null);
            glide_max_speed?: (number|null);
        }

        class MapBuddySettingsProto implements IMapBuddySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMapBuddySettingsProto);
            public for_buddy_group_number: number;
            public target_offset_min: number;
            public target_offset_max: number;
            public leash_distance: number;
            public max_seconds_to_idle: number;
            public max_rotation_speed: number;
            public walk_threshold: number;
            public run_threshold: number;
            public should_glide: boolean;
            public glide_smooth_time: number;
            public glide_max_speed: number;
            public static encode(message: POGOProtos.Rpc.IMapBuddySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapBuddySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapBuddySettingsProto;
            public static toObject(message: POGOProtos.Rpc.MapBuddySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapCompositionRoot {
            map_area?: (POGOProtos.Rpc.IMapArea[]|null);
            biome_map_area?: (POGOProtos.Rpc.IMapArea[]|null);
            map_provider?: (POGOProtos.Rpc.IMapProvider[]|null);
        }

        class MapCompositionRoot implements IMapCompositionRoot {
            constructor(properties?: POGOProtos.Rpc.IMapCompositionRoot);
            public map_area: POGOProtos.Rpc.IMapArea[];
            public biome_map_area: POGOProtos.Rpc.IMapArea[];
            public map_provider: POGOProtos.Rpc.IMapProvider[];
            public static encode(message: POGOProtos.Rpc.IMapCompositionRoot, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapCompositionRoot;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapCompositionRoot;
            public static toObject(message: POGOProtos.Rpc.MapCompositionRoot, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapCoordOverlayProto {
            map_overlay_id?: (string|null);
            addressable_id?: (string|null);
            anchor_latitude?: (number|null);
            anchor_longitude?: (number|null);
        }

        class MapCoordOverlayProto implements IMapCoordOverlayProto {
            constructor(properties?: POGOProtos.Rpc.IMapCoordOverlayProto);
            public map_overlay_id: string;
            public addressable_id: string;
            public anchor_latitude: number;
            public anchor_longitude: number;
            public static encode(message: POGOProtos.Rpc.IMapCoordOverlayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapCoordOverlayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapCoordOverlayProto;
            public static toObject(message: POGOProtos.Rpc.MapCoordOverlayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapDisplaySettingsProto {
            map_effect?: (POGOProtos.Rpc.MapDisplaySettingsProto.MapEffect|null);
            research_icon_url?: (string|null);
            bgm?: (POGOProtos.Rpc.MapDisplaySettingsProto.MusicType|null);
            show_enhanced_sky?: (boolean|null);
            sky_override?: (string|null);
            music_name?: (string|null);
            map_effect_name?: (string|null);
            show_map_shore_lines?: (boolean|null);
            sky_effect_name?: (string|null);
            event_theme_name?: (string|null);
        }

        class MapDisplaySettingsProto implements IMapDisplaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMapDisplaySettingsProto);
            public map_effect: POGOProtos.Rpc.MapDisplaySettingsProto.MapEffect;
            public research_icon_url: string;
            public bgm: POGOProtos.Rpc.MapDisplaySettingsProto.MusicType;
            public show_enhanced_sky: boolean;
            public sky_override: string;
            public music_name: string;
            public map_effect_name: string;
            public show_map_shore_lines: boolean;
            public sky_effect_name: string;
            public event_theme_name: string;
            public static encode(message: POGOProtos.Rpc.IMapDisplaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapDisplaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapDisplaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.MapDisplaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapDisplaySettingsProto {

            enum MapEffect {
                EFFECT_NONE = 0,
                EFFECT_CONFETTI_BASIC = 1,
                EFFECT_CONFETTI_FIRE = 2,
                EFFECT_CONFETTI_WATER = 3,
                EFFECT_CONFETTI_GRASS = 4,
                EFFECT_CONFETTI_RAID_BATTLE = 5,
                EFFECT_CONFETTI_FRIENDSHIP = 6,
                EFFECT_CONFETTI_ROCKET = 7,
                EFFECT_FIREWORKS_PLAIN = 8,
                EFFECT_CONFETTI_FLOWER = 9,
                EFFECT_CONFETTI_PLAINS = 10,
                EFFECT_CONFETTI_CITY = 11,
                EFFECT_CONFETTI_TUNDRA = 12,
                EFFECT_CONFETTI_RAINFOREST = 13
            }

            enum MusicType {
                BGM_UNSET = 0,
                BGM_EVENT = 101,
                BGM_HALLOWEEN = 200,
                BGM_GO_TOUR_00 = 201,
                BGM_GO_TOUR_01 = 202,
                BGM_GO_TOUR_02 = 203,
                BGM_GO_TOUR_03 = 204,
                BGM_GO_TOUR_04 = 205,
                BGM_GO_TOUR_05 = 206,
                BGM_GO_TOUR_06 = 207,
                BGM_GO_TOUR_07 = 208,
                BGM_GO_TOUR_08 = 209,
                BGM_GO_TOUR_09 = 210,
                BGM_TEAM_ROCKET_DEFAULT = 300
            }
        }

        interface IMapEventsTelemetry {
            map_event_click_id?: (POGOProtos.Rpc.MapEventsTelemetryIds|null);
            fort_id?: (string|null);
            guard_pokemon_level?: (number[]|null);
            team?: (POGOProtos.Rpc.Team|null);
            is_player_in_range?: (boolean|null);
        }

        class MapEventsTelemetry implements IMapEventsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IMapEventsTelemetry);
            public map_event_click_id: POGOProtos.Rpc.MapEventsTelemetryIds;
            public fort_id: string;
            public guard_pokemon_level: number[];
            public team: POGOProtos.Rpc.Team;
            public is_player_in_range: boolean;
            public static encode(message: POGOProtos.Rpc.IMapEventsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapEventsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapEventsTelemetry;
            public static toObject(message: POGOProtos.Rpc.MapEventsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapIconProto {
            map_icon_category?: (POGOProtos.Rpc.MapIconProto.MapIconCategory|null);
            sort_order?: (number|null);
        }

        class MapIconProto implements IMapIconProto {
            constructor(properties?: POGOProtos.Rpc.IMapIconProto);
            public map_icon_category: POGOProtos.Rpc.MapIconProto.MapIconCategory;
            public sort_order: number;
            public static encode(message: POGOProtos.Rpc.IMapIconProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapIconProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapIconProto;
            public static toObject(message: POGOProtos.Rpc.MapIconProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapIconProto {

            enum MapIconCategory {
                GLOBAL_BONUSES = 0,
                ADVENTURE_EFFECTS = 1,
                MEGA_EVOLUTIONS = 2,
                ACTIVE_TRAINER_BOOSTS = 3,
                PAUSED_TRAINER_BOOSTS = 4,
                ROCKET_RADARS = 5,
                NON_ACTIVE_DAI = 6,
                STAMP_COLLECTION = 7
            }
        }

        interface IMapIconSortOrderProto {
            map_icon?: (POGOProtos.Rpc.IMapIconProto[]|null);
        }

        class MapIconSortOrderProto implements IMapIconSortOrderProto {
            constructor(properties?: POGOProtos.Rpc.IMapIconSortOrderProto);
            public map_icon: POGOProtos.Rpc.IMapIconProto[];
            public static encode(message: POGOProtos.Rpc.IMapIconSortOrderProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapIconSortOrderProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapIconSortOrderProto;
            public static toObject(message: POGOProtos.Rpc.MapIconSortOrderProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapIconsSettingsProto {
            enable_map_expandable_righthand_icons?: (boolean|null);
        }

        class MapIconsSettingsProto implements IMapIconsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMapIconsSettingsProto);
            public enable_map_expandable_righthand_icons: boolean;
            public static encode(message: POGOProtos.Rpc.IMapIconsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapIconsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapIconsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MapIconsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapPokemonProto {
            spawnpoint_id?: (string|null);
            encounter_id?: (number|Long|null);
            pokedex_type_id?: (number|null);
            expiration_time_ms?: (number|Long|null);
            latitude?: (number|null);
            longitude?: (number|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class MapPokemonProto implements IMapPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IMapPokemonProto);
            public spawnpoint_id: string;
            public encounter_id: (number|Long);
            public pokedex_type_id: number;
            public expiration_time_ms: (number|Long);
            public latitude: number;
            public longitude: number;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IMapPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapPokemonProto;
            public static toObject(message: POGOProtos.Rpc.MapPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapProvider {
            name?: (string|null);
            base_url?: (string|null);
            query_format?: (string|null);
            min_tile_level?: (number|null);
            max_tile_level?: (number|null);
            map_type?: (POGOProtos.Rpc.MapProvider.MapType|null);
        }

        class MapProvider implements IMapProvider {
            constructor(properties?: POGOProtos.Rpc.IMapProvider);
            public name: string;
            public base_url: string;
            public query_format: string;
            public min_tile_level: number;
            public max_tile_level: number;
            public map_type: POGOProtos.Rpc.MapProvider.MapType;
            public static encode(message: POGOProtos.Rpc.IMapProvider, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapProvider;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapProvider;
            public static toObject(message: POGOProtos.Rpc.MapProvider, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapProvider {

            enum MapType {
                UNSET = 0,
                BLANK = 3,
                NIANTIC_BUNDLE = 5,
                BIOME_RASTER = 6
            }
        }

        interface IMapQueryRequestProto {
            query_s2_cell_ids?: ((number|Long)[]|null);
            query_s2_cell_timestamps?: ((number|Long)[]|null);
        }

        class MapQueryRequestProto implements IMapQueryRequestProto {
            constructor(properties?: POGOProtos.Rpc.IMapQueryRequestProto);
            public query_s2_cell_ids: (number|Long)[];
            public query_s2_cell_timestamps: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IMapQueryRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapQueryRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapQueryRequestProto;
            public static toObject(message: POGOProtos.Rpc.MapQueryRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapQueryResponseProto {
            s2_cells?: (POGOProtos.Rpc.IMapS2Cell[]|null);
            entities?: (POGOProtos.Rpc.IMapS2CellEntity[]|null);
            deleted_entities?: (string[]|null);
        }

        class MapQueryResponseProto implements IMapQueryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IMapQueryResponseProto);
            public s2_cells: POGOProtos.Rpc.IMapS2Cell[];
            public entities: POGOProtos.Rpc.IMapS2CellEntity[];
            public deleted_entities: string[];
            public static encode(message: POGOProtos.Rpc.IMapQueryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapQueryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapQueryResponseProto;
            public static toObject(message: POGOProtos.Rpc.MapQueryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapRighthandIconsTelemetry {
            map_righthand_icons_event_ids?: (POGOProtos.Rpc.MapRighthandIconsTelemetry.IconEvents|null);
            number_icons_in_grid?: (number|null);
        }

        class MapRighthandIconsTelemetry implements IMapRighthandIconsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IMapRighthandIconsTelemetry);
            public map_righthand_icons_event_ids: POGOProtos.Rpc.MapRighthandIconsTelemetry.IconEvents;
            public number_icons_in_grid: number;
            public static encode(message: POGOProtos.Rpc.IMapRighthandIconsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapRighthandIconsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapRighthandIconsTelemetry;
            public static toObject(message: POGOProtos.Rpc.MapRighthandIconsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapRighthandIconsTelemetry {

            enum IconEvents {
                UNDEFINED_MAP_RIGHTHAND_ICON_EVENT = 0,
                ICON_GRID_EXPANSION_BUTTON_APPEARED = 1,
                ICON_GRID_NUMBER_COLUMNS_INCREASED = 2,
                ICON_GRID_EXPANDED_BY_CLICK = 3
            }
        }

        interface IMapS2Cell {
            s2_cell_id?: (number|Long|null);
            s2_cell_base_timestamp?: (number|Long|null);
            s2_cell_timestamp?: (number|Long|null);
            entity_key?: (string[]|null);
            deleted_entity_key?: (string[]|null);
        }

        class MapS2Cell implements IMapS2Cell {
            constructor(properties?: POGOProtos.Rpc.IMapS2Cell);
            public s2_cell_id: (number|Long);
            public s2_cell_base_timestamp: (number|Long);
            public s2_cell_timestamp: (number|Long);
            public entity_key: string[];
            public deleted_entity_key: string[];
            public static encode(message: POGOProtos.Rpc.IMapS2Cell, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapS2Cell;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapS2Cell;
            public static toObject(message: POGOProtos.Rpc.MapS2Cell, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapS2CellEntity {
            key?: (string|null);
            timestamp?: (number|Long|null);
            payload?: (Uint8Array|null);
            new_shape?: (POGOProtos.Rpc.IShapeProto|null);
        }

        class MapS2CellEntity implements IMapS2CellEntity {
            constructor(properties?: POGOProtos.Rpc.IMapS2CellEntity);
            public key: string;
            public timestamp: (number|Long);
            public payload: Uint8Array;
            public new_shape?: (POGOProtos.Rpc.IShapeProto|null);
            public static encode(message: POGOProtos.Rpc.IMapS2CellEntity, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapS2CellEntity;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapS2CellEntity;
            public static toObject(message: POGOProtos.Rpc.MapS2CellEntity, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapS2CellEntity {

            interface ILocation {
                latitude?: (number|null);
                longitude?: (number|null);
                altitude?: (number|null);
            }

            class Location implements ILocation {
                constructor(properties?: POGOProtos.Rpc.MapS2CellEntity.ILocation);
                public latitude: number;
                public longitude: number;
                public altitude: number;
                public static encode(message: POGOProtos.Rpc.MapS2CellEntity.ILocation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapS2CellEntity.Location;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapS2CellEntity.Location;
                public static toObject(message: POGOProtos.Rpc.MapS2CellEntity.Location, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IMapSceneFeatureFlagsProto {
            map_scene_view_service_enabled?: (boolean|null);
            top_down_view_enabled?: (boolean|null);
            top_down_view_pokemon_enabled?: (boolean|null);
            dynamic_panning_limit?: (number|null);
            dynamic_map_panning_enabled?: (boolean|null);
        }

        class MapSceneFeatureFlagsProto implements IMapSceneFeatureFlagsProto {
            constructor(properties?: POGOProtos.Rpc.IMapSceneFeatureFlagsProto);
            public map_scene_view_service_enabled: boolean;
            public top_down_view_enabled: boolean;
            public top_down_view_pokemon_enabled: boolean;
            public dynamic_panning_limit: number;
            public dynamic_map_panning_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IMapSceneFeatureFlagsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapSceneFeatureFlagsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapSceneFeatureFlagsProto;
            public static toObject(message: POGOProtos.Rpc.MapSceneFeatureFlagsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapSettingsProto {
            pokemon_visible_range?: (number|null);
            poke_nav_range_meters?: (number|null);
            encounter_range_meters?: (number|null);
            get_map_objects_min_refresh_seconds?: (number|null);
            get_map_objects_max_refresh_seconds?: (number|null);
            get_map_objects_min_distance_meters?: (number|null);
            google_maps_api_key?: (string|null);
            min_nearby_hide_sightings?: (number|null);
            enable_special_weather?: (boolean|null);
            special_weather_probability?: (number|null);
            google_maps_client_id?: (string|null);
            enable_encounter_v2?: (boolean|null);
            pokemon_despawn_range?: (number|null);
        }

        class MapSettingsProto implements IMapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMapSettingsProto);
            public pokemon_visible_range: number;
            public poke_nav_range_meters: number;
            public encounter_range_meters: number;
            public get_map_objects_min_refresh_seconds: number;
            public get_map_objects_max_refresh_seconds: number;
            public get_map_objects_min_distance_meters: number;
            public google_maps_api_key: string;
            public min_nearby_hide_sightings: number;
            public enable_special_weather: boolean;
            public special_weather_probability: number;
            public google_maps_client_id: string;
            public enable_encounter_v2: boolean;
            public pokemon_despawn_range: number;
            public static encode(message: POGOProtos.Rpc.IMapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapTile {
            zoom?: (number|null);
            x?: (number|null);
            y?: (number|null);
            layers?: (POGOProtos.Rpc.ILayer[]|null);
        }

        class MapTile implements IMapTile {
            constructor(properties?: POGOProtos.Rpc.IMapTile);
            public zoom: number;
            public x: number;
            public y: number;
            public layers: POGOProtos.Rpc.ILayer[];
            public static encode(message: POGOProtos.Rpc.IMapTile, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapTile;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapTile;
            public static toObject(message: POGOProtos.Rpc.MapTile, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapTileBundle {
            format_version?: (number|null);
            tile_zoom?: (number|null);
            bundle_zoom?: (number|null);
            bundle_x?: (number|null);
            bundle_y?: (number|null);
            epoch?: (number|null);
            tiles?: (POGOProtos.Rpc.IMapTile[]|null);
        }

        class MapTileBundle implements IMapTileBundle {
            constructor(properties?: POGOProtos.Rpc.IMapTileBundle);
            public format_version: number;
            public tile_zoom: number;
            public bundle_zoom: number;
            public bundle_x: number;
            public bundle_y: number;
            public epoch: number;
            public tiles: POGOProtos.Rpc.IMapTile[];
            public static encode(message: POGOProtos.Rpc.IMapTileBundle, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapTileBundle;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapTileBundle;
            public static toObject(message: POGOProtos.Rpc.MapTileBundle, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapTilesProcessed {
            num_tiles?: (number|null);
            queue_time_ms?: (number|Long|null);
            build_time_ms?: (number|Long|null);
            main_thread_build_time_ms?: (number|Long|null);
        }

        class MapTilesProcessed implements IMapTilesProcessed {
            constructor(properties?: POGOProtos.Rpc.IMapTilesProcessed);
            public num_tiles: number;
            public queue_time_ms: (number|Long);
            public build_time_ms: (number|Long);
            public main_thread_build_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMapTilesProcessed, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapTilesProcessed;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapTilesProcessed;
            public static toObject(message: POGOProtos.Rpc.MapTilesProcessed, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsAgeGateResult {
            method_name?: (string|null);
        }

        class MapsAgeGateResult implements IMapsAgeGateResult {
            constructor(properties?: POGOProtos.Rpc.IMapsAgeGateResult);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsAgeGateResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsAgeGateResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsAgeGateResult;
            public static toObject(message: POGOProtos.Rpc.MapsAgeGateResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsAgeGateStartup {
            method_name?: (string|null);
        }

        class MapsAgeGateStartup implements IMapsAgeGateStartup {
            constructor(properties?: POGOProtos.Rpc.IMapsAgeGateStartup);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsAgeGateStartup, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsAgeGateStartup;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsAgeGateStartup;
            public static toObject(message: POGOProtos.Rpc.MapsAgeGateStartup, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientEnvironmentProto {
            language_code?: (string|null);
            timezone?: (string|null);
            device_country_code?: (string|null);
            ip_country_code?: (string|null);
            client_version?: (string|null);
            device_type?: (string|null);
            device_os?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
        }

        class MapsClientEnvironmentProto implements IMapsClientEnvironmentProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientEnvironmentProto);
            public language_code: string;
            public timezone: string;
            public device_country_code: string;
            public ip_country_code: string;
            public client_version: string;
            public device_type: string;
            public device_os: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public static encode(message: POGOProtos.Rpc.IMapsClientEnvironmentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientEnvironmentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientEnvironmentProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientEnvironmentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientTelemetryBatchProto {
            telemetry_scope_id?: (POGOProtos.Rpc.MapsClientTelemetryBatchProto.TelemetryScopeId|null);
            events?: (POGOProtos.Rpc.IMapsClientTelemetryRecordProto[]|null);
            metrics?: (POGOProtos.Rpc.IMapsClientTelemetryRecordProto[]|null);
            api_version?: (string|null);
            message_version?: (string|null);
        }

        class MapsClientTelemetryBatchProto implements IMapsClientTelemetryBatchProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryBatchProto);
            public telemetry_scope_id: POGOProtos.Rpc.MapsClientTelemetryBatchProto.TelemetryScopeId;
            public events: POGOProtos.Rpc.IMapsClientTelemetryRecordProto[];
            public metrics: POGOProtos.Rpc.IMapsClientTelemetryRecordProto[];
            public api_version: string;
            public message_version: string;
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryBatchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryBatchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryBatchProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryBatchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsClientTelemetryBatchProto {

            enum TelemetryScopeId {
                UNSET = 0,
                CORE = 1,
                GAME = 2,
                TITAN = 3,
                COMMON = 4,
                PRE_AGE_GATE = 5,
                PRE_LOGIN = 6,
                ARDK = 7,
                MARKETING = 8
            }
        }

        interface IMapsClientTelemetryClientSettingsProto {
            is_upload_enabled?: (boolean|null);
            max_upload_size_in_bytes?: (number|Long|null);
            update_interval_in_sec?: (number|Long|null);
            settings_update_interval_in_sec?: (number|Long|null);
            max_envelope_queue_size?: (number|Long|null);
            sampling_probability?: (number|null);
            use_player_based_sampling?: (boolean|null);
            player_hash?: (number|null);
            player_external_omni_id?: (string|null);
            disable_omni_sending?: (boolean|null);
            special_sampling_probability_map?: ({ [k: string]: number }|null);
            player_external_ua_id?: (string|null);
            player_external_in_app_survey_id?: (string|null);
            player_external_ardk_id?: (string|null);
            enable_experimental_features?: (boolean|null);
        }

        class MapsClientTelemetryClientSettingsProto implements IMapsClientTelemetryClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryClientSettingsProto);
            public is_upload_enabled: boolean;
            public max_upload_size_in_bytes: (number|Long);
            public update_interval_in_sec: (number|Long);
            public settings_update_interval_in_sec: (number|Long);
            public max_envelope_queue_size: (number|Long);
            public sampling_probability: number;
            public use_player_based_sampling: boolean;
            public player_hash: number;
            public player_external_omni_id: string;
            public disable_omni_sending: boolean;
            public special_sampling_probability_map: { [k: string]: number };
            public player_external_ua_id: string;
            public player_external_in_app_survey_id: string;
            public player_external_ardk_id: string;
            public enable_experimental_features: boolean;
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientTelemetryCommonFilterProto {
            application_identifier?: (string|null);
            operating_system_name?: (string|null);
            device_model?: (string|null);
            locale_country_code?: (string|null);
            locale_language_code?: (string|null);
            sampling_probability?: (number|null);
            quality_level?: (string|null);
            network_connectivity_type?: (string|null);
            game_context?: (string|null);
            language_code?: (string|null);
            timezone?: (string|null);
            ip_country_code?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
            client_version?: (string|null);
        }

        class MapsClientTelemetryCommonFilterProto implements IMapsClientTelemetryCommonFilterProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto);
            public application_identifier: string;
            public operating_system_name: string;
            public device_model: string;
            public locale_country_code: string;
            public locale_language_code: string;
            public sampling_probability: number;
            public quality_level: string;
            public network_connectivity_type: string;
            public game_context: string;
            public language_code: string;
            public timezone: string;
            public ip_country_code: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public client_version: string;
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryCommonFilterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryCommonFilterProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryCommonFilterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientTelemetryOmniProto {
            assertion_failed?: (POGOProtos.Rpc.IAssertionFailed|null);
            log_message?: (POGOProtos.Rpc.ILogMessage|null);
            maptiles_processed?: (POGOProtos.Rpc.IMapTilesProcessed|null);
            timestamp_ms?: (number|Long|null);
            common_filters?: (POGOProtos.Rpc.IMapsTelemetryCommonFilterProto|null);
        }

        class MapsClientTelemetryOmniProto implements IMapsClientTelemetryOmniProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryOmniProto);
            public assertion_failed?: (POGOProtos.Rpc.IAssertionFailed|null);
            public log_message?: (POGOProtos.Rpc.ILogMessage|null);
            public maptiles_processed?: (POGOProtos.Rpc.IMapTilesProcessed|null);
            public timestamp_ms: (number|Long);
            public common_filters?: (POGOProtos.Rpc.IMapsTelemetryCommonFilterProto|null);
            public TelemetryEvent?: ("assertion_failed"|"log_message"|"maptiles_processed");
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryOmniProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryOmniProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryOmniProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryOmniProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientTelemetryRecordProto {
            record_id?: (string|null);
            encoded_message?: (Uint8Array|null);
            client_timestamp_ms?: (number|Long|null);
            metric_id?: (number|Long|null);
            event_name?: (string|null);
            common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
        }

        class MapsClientTelemetryRecordProto implements IMapsClientTelemetryRecordProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryRecordProto);
            public record_id: string;
            public encoded_message: Uint8Array;
            public client_timestamp_ms: (number|Long);
            public metric_id: (number|Long);
            public event_name: string;
            public common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryRecordProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientTelemetryRecordResult {
            record_id?: (string|null);
            status?: (POGOProtos.Rpc.MapsClientTelemetryRecordResult.Status|null);
            telemetry_type_name?: (string|null);
        }

        class MapsClientTelemetryRecordResult implements IMapsClientTelemetryRecordResult {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryRecordResult);
            public record_id: string;
            public status: POGOProtos.Rpc.MapsClientTelemetryRecordResult.Status;
            public telemetry_type_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryRecordResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryRecordResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryRecordResult;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryRecordResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsClientTelemetryRecordResult {

            enum Status {
                UNSET = 0,
                SUCCESS = 20,
                ERROR_FAMILY_UNSET = 21,
                ERROR_FAMILY_INVALID = 22,
                ERROR_ENCODING_INVALID = 23,
                ERROR_UNSET_METRIC_ID = 24,
                ERROR_EVENT_TELEMETRY_UNDEFINED = 25
            }
        }

        interface IMapsClientTelemetryResponseProto {
            status?: (POGOProtos.Rpc.MapsClientTelemetryResponseProto.Status|null);
            rows_written?: (number|null);
            nonretryable_failures?: (number|null);
        }

        class MapsClientTelemetryResponseProto implements IMapsClientTelemetryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryResponseProto);
            public status: POGOProtos.Rpc.MapsClientTelemetryResponseProto.Status;
            public rows_written: number;
            public nonretryable_failures: number;
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryResponseProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsClientTelemetryResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                PARTIAL_FAILURE = 3,
                INVALID_REQUEST = 4
            }
        }

        interface IMapsClientTelemetrySettingsRequestProto {
        }

        class MapsClientTelemetrySettingsRequestProto implements IMapsClientTelemetrySettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetrySettingsRequestProto);
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetrySettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetrySettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetrySettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetrySettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsClientTelemetryV2Request {
            telemetry_request_metadata?: (POGOProtos.Rpc.IMapsTelemetryRequestMetadata|null);
            batch_proto?: (POGOProtos.Rpc.IMapsTelemetryBatchProto|null);
        }

        class MapsClientTelemetryV2Request implements IMapsClientTelemetryV2Request {
            constructor(properties?: POGOProtos.Rpc.IMapsClientTelemetryV2Request);
            public telemetry_request_metadata?: (POGOProtos.Rpc.IMapsTelemetryRequestMetadata|null);
            public batch_proto?: (POGOProtos.Rpc.IMapsTelemetryBatchProto|null);
            public static encode(message: POGOProtos.Rpc.IMapsClientTelemetryV2Request, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsClientTelemetryV2Request;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsClientTelemetryV2Request;
            public static toObject(message: POGOProtos.Rpc.MapsClientTelemetryV2Request, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsDatapoint {
            long?: (number|Long|null);
            double?: (number|null);
            boolean?: (boolean|null);
            kind?: (POGOProtos.Rpc.MapsDatapoint.Kind|null);
        }

        class MapsDatapoint implements IMapsDatapoint {
            constructor(properties?: POGOProtos.Rpc.IMapsDatapoint);
            public long?: (number|Long|null);
            public double?: (number|null);
            public boolean?: (boolean|null);
            public kind: POGOProtos.Rpc.MapsDatapoint.Kind;
            public Value?: ("long"|"double"|"boolean");
            public static encode(message: POGOProtos.Rpc.IMapsDatapoint, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsDatapoint;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsDatapoint;
            public static toObject(message: POGOProtos.Rpc.MapsDatapoint, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsDatapoint {

            enum Kind {
                UNSPECIFIED = 0,
                GAUGE = 1,
                DELTA = 2,
                CUMULATIVE = 3
            }
        }

        interface IMapsLoginNewPlayer {
            method_name?: (string|null);
        }

        class MapsLoginNewPlayer implements IMapsLoginNewPlayer {
            constructor(properties?: POGOProtos.Rpc.IMapsLoginNewPlayer);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsLoginNewPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsLoginNewPlayer;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsLoginNewPlayer;
            public static toObject(message: POGOProtos.Rpc.MapsLoginNewPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsLoginNewPlayerCreateAccount {
            method_name?: (string|null);
        }

        class MapsLoginNewPlayerCreateAccount implements IMapsLoginNewPlayerCreateAccount {
            constructor(properties?: POGOProtos.Rpc.IMapsLoginNewPlayerCreateAccount);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsLoginNewPlayerCreateAccount, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsLoginNewPlayerCreateAccount;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsLoginNewPlayerCreateAccount;
            public static toObject(message: POGOProtos.Rpc.MapsLoginNewPlayerCreateAccount, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsLoginReturningPlayer {
            method_name?: (string|null);
        }

        class MapsLoginReturningPlayer implements IMapsLoginReturningPlayer {
            constructor(properties?: POGOProtos.Rpc.IMapsLoginReturningPlayer);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsLoginReturningPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsLoginReturningPlayer;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsLoginReturningPlayer;
            public static toObject(message: POGOProtos.Rpc.MapsLoginReturningPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsLoginReturningPlayerSignIn {
            method_name?: (string|null);
        }

        class MapsLoginReturningPlayerSignIn implements IMapsLoginReturningPlayerSignIn {
            constructor(properties?: POGOProtos.Rpc.IMapsLoginReturningPlayerSignIn);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsLoginReturningPlayerSignIn, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsLoginReturningPlayerSignIn;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsLoginReturningPlayerSignIn;
            public static toObject(message: POGOProtos.Rpc.MapsLoginReturningPlayerSignIn, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsLoginStartup {
            method_name?: (string|null);
        }

        class MapsLoginStartup implements IMapsLoginStartup {
            constructor(properties?: POGOProtos.Rpc.IMapsLoginStartup);
            public method_name: string;
            public static encode(message: POGOProtos.Rpc.IMapsLoginStartup, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsLoginStartup;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsLoginStartup;
            public static toObject(message: POGOProtos.Rpc.MapsLoginStartup, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsMetricRecord {
            server_data?: (POGOProtos.Rpc.IMapsServerRecordMetadata|null);
            datapoint?: (POGOProtos.Rpc.IMapsDatapoint|null);
            common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
        }

        class MapsMetricRecord implements IMapsMetricRecord {
            constructor(properties?: POGOProtos.Rpc.IMapsMetricRecord);
            public server_data?: (POGOProtos.Rpc.IMapsServerRecordMetadata|null);
            public datapoint?: (POGOProtos.Rpc.IMapsDatapoint|null);
            public common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
            public static encode(message: POGOProtos.Rpc.IMapsMetricRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsMetricRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsMetricRecord;
            public static toObject(message: POGOProtos.Rpc.MapsMetricRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsPlaceholderMessage {
            placeholder?: (string|null);
        }

        class MapsPlaceholderMessage implements IMapsPlaceholderMessage {
            constructor(properties?: POGOProtos.Rpc.IMapsPlaceholderMessage);
            public placeholder: string;
            public static encode(message: POGOProtos.Rpc.IMapsPlaceholderMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsPlaceholderMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsPlaceholderMessage;
            public static toObject(message: POGOProtos.Rpc.MapsPlaceholderMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsPlatformPlayerInfo {
            identity_provider?: (string|null);
            profile_creation_timestamp_ms?: (number|Long|null);
            player_level?: (number|null);
            team_id?: (number|null);
            lifetime_km_walked?: (number|null);
            lifetime_steps_walked?: (number|Long|null);
        }

        class MapsPlatformPlayerInfo implements IMapsPlatformPlayerInfo {
            constructor(properties?: POGOProtos.Rpc.IMapsPlatformPlayerInfo);
            public identity_provider: string;
            public profile_creation_timestamp_ms: (number|Long);
            public player_level: number;
            public team_id: number;
            public lifetime_km_walked: number;
            public lifetime_steps_walked: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMapsPlatformPlayerInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsPlatformPlayerInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsPlatformPlayerInfo;
            public static toObject(message: POGOProtos.Rpc.MapsPlatformPlayerInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsPlatformPreAgeGateTrackingOmniproto {
            age_gate_startup?: (POGOProtos.Rpc.IMapsAgeGateStartup|null);
            age_gate_result?: (POGOProtos.Rpc.IMapsAgeGateResult|null);
            pre_age_gate_metadata?: (POGOProtos.Rpc.IMapsPreAgeGateMetadata|null);
            common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
        }

        class MapsPlatformPreAgeGateTrackingOmniproto implements IMapsPlatformPreAgeGateTrackingOmniproto {
            constructor(properties?: POGOProtos.Rpc.IMapsPlatformPreAgeGateTrackingOmniproto);
            public age_gate_startup?: (POGOProtos.Rpc.IMapsAgeGateStartup|null);
            public age_gate_result?: (POGOProtos.Rpc.IMapsAgeGateResult|null);
            public pre_age_gate_metadata?: (POGOProtos.Rpc.IMapsPreAgeGateMetadata|null);
            public common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
            public PlatformPreAgeGateEvent?: ("age_gate_startup"|"age_gate_result");
            public static encode(message: POGOProtos.Rpc.IMapsPlatformPreAgeGateTrackingOmniproto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsPlatformPreAgeGateTrackingOmniproto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsPlatformPreAgeGateTrackingOmniproto;
            public static toObject(message: POGOProtos.Rpc.MapsPlatformPreAgeGateTrackingOmniproto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsPlatformPreLoginTrackingOmniproto {
            login_startup?: (POGOProtos.Rpc.IMapsLoginStartup|null);
            login_new_player?: (POGOProtos.Rpc.IMapsLoginNewPlayer|null);
            login_returning_player?: (POGOProtos.Rpc.IMapsLoginReturningPlayer|null);
            login_new_player_create_account?: (POGOProtos.Rpc.IMapsLoginNewPlayerCreateAccount|null);
            login_returning_player_sign_in?: (POGOProtos.Rpc.IMapsLoginReturningPlayerSignIn|null);
            pre_login_metadata?: (POGOProtos.Rpc.IMapsPreLoginMetadata|null);
            common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
        }

        class MapsPlatformPreLoginTrackingOmniproto implements IMapsPlatformPreLoginTrackingOmniproto {
            constructor(properties?: POGOProtos.Rpc.IMapsPlatformPreLoginTrackingOmniproto);
            public login_startup?: (POGOProtos.Rpc.IMapsLoginStartup|null);
            public login_new_player?: (POGOProtos.Rpc.IMapsLoginNewPlayer|null);
            public login_returning_player?: (POGOProtos.Rpc.IMapsLoginReturningPlayer|null);
            public login_new_player_create_account?: (POGOProtos.Rpc.IMapsLoginNewPlayerCreateAccount|null);
            public login_returning_player_sign_in?: (POGOProtos.Rpc.IMapsLoginReturningPlayerSignIn|null);
            public pre_login_metadata?: (POGOProtos.Rpc.IMapsPreLoginMetadata|null);
            public common_filters?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
            public PlatformPreLoginEvent?: ("login_startup"|"login_new_player"|"login_returning_player"|"login_new_player_create_account"|"login_returning_player_sign_in");
            public static encode(message: POGOProtos.Rpc.IMapsPlatformPreLoginTrackingOmniproto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsPlatformPreLoginTrackingOmniproto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsPlatformPreLoginTrackingOmniproto;
            public static toObject(message: POGOProtos.Rpc.MapsPlatformPreLoginTrackingOmniproto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsPreAgeGateMetadata {
            timestamp_ms?: (number|Long|null);
            client_timestamp_ms?: (number|Long|null);
            experiment_ids?: (number[]|null);
            pre_login_user_id?: (string|null);
            minor?: (boolean|null);
            num_starts?: (number|Long|null);
            client_environment?: (POGOProtos.Rpc.IMapsClientEnvironmentProto|null);
            startup_measurement?: (POGOProtos.Rpc.IMapsStartupMeasurementProto|null);
        }

        class MapsPreAgeGateMetadata implements IMapsPreAgeGateMetadata {
            constructor(properties?: POGOProtos.Rpc.IMapsPreAgeGateMetadata);
            public timestamp_ms: (number|Long);
            public client_timestamp_ms: (number|Long);
            public experiment_ids: number[];
            public pre_login_user_id: string;
            public minor: boolean;
            public num_starts: (number|Long);
            public client_environment?: (POGOProtos.Rpc.IMapsClientEnvironmentProto|null);
            public startup_measurement?: (POGOProtos.Rpc.IMapsStartupMeasurementProto|null);
            public static encode(message: POGOProtos.Rpc.IMapsPreAgeGateMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsPreAgeGateMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsPreAgeGateMetadata;
            public static toObject(message: POGOProtos.Rpc.MapsPreAgeGateMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsPreLoginMetadata {
            user_id?: (string|null);
            timestamp_ms?: (number|Long|null);
            client_timestamp_ms?: (number|Long|null);
            experiment_ids?: (number[]|null);
            pre_login_user_id?: (string|null);
            num_starts?: (number|Long|null);
        }

        class MapsPreLoginMetadata implements IMapsPreLoginMetadata {
            constructor(properties?: POGOProtos.Rpc.IMapsPreLoginMetadata);
            public user_id: string;
            public timestamp_ms: (number|Long);
            public client_timestamp_ms: (number|Long);
            public experiment_ids: number[];
            public pre_login_user_id: string;
            public num_starts: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMapsPreLoginMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsPreLoginMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsPreLoginMetadata;
            public static toObject(message: POGOProtos.Rpc.MapsPreLoginMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsServerRecordMetadata {
            user_id?: (string|null);
            telemetry_name?: (string|null);
            session_id?: (string|null);
            experiment_ids?: (number[]|null);
            request_id?: (string|null);
            server_timestamp_ms?: (number|Long|null);
            analytics_experiment_ids?: (string[]|null);
            client_request_id?: (string|null);
            user_population_group_ids?: (string[]|null);
        }

        class MapsServerRecordMetadata implements IMapsServerRecordMetadata {
            constructor(properties?: POGOProtos.Rpc.IMapsServerRecordMetadata);
            public user_id: string;
            public telemetry_name: string;
            public session_id: string;
            public experiment_ids: number[];
            public request_id: string;
            public server_timestamp_ms: (number|Long);
            public analytics_experiment_ids: string[];
            public client_request_id: string;
            public user_population_group_ids: string[];
            public static encode(message: POGOProtos.Rpc.IMapsServerRecordMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsServerRecordMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsServerRecordMetadata;
            public static toObject(message: POGOProtos.Rpc.MapsServerRecordMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsStartupMeasurementProto {
            num_starts?: (number|Long|null);
            load_to_tos_login_duration_ms?: (number|Long|null);
            load_to_map_duration_ms?: (number|Long|null);
            load_durations?: (POGOProtos.Rpc.MapsStartupMeasurementProto.IComponentLoadDurations[]|null);
        }

        class MapsStartupMeasurementProto implements IMapsStartupMeasurementProto {
            constructor(properties?: POGOProtos.Rpc.IMapsStartupMeasurementProto);
            public num_starts: (number|Long);
            public load_to_tos_login_duration_ms: (number|Long);
            public load_to_map_duration_ms: (number|Long);
            public load_durations: POGOProtos.Rpc.MapsStartupMeasurementProto.IComponentLoadDurations[];
            public static encode(message: POGOProtos.Rpc.IMapsStartupMeasurementProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsStartupMeasurementProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsStartupMeasurementProto;
            public static toObject(message: POGOProtos.Rpc.MapsStartupMeasurementProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsStartupMeasurementProto {

            interface IComponentLoadDurations {
                component_name?: (string|null);
                load_duration_ms?: (number|Long|null);
                absolute_duration_ms?: (number|Long|null);
            }

            class ComponentLoadDurations implements IComponentLoadDurations {
                constructor(properties?: POGOProtos.Rpc.MapsStartupMeasurementProto.IComponentLoadDurations);
                public component_name: string;
                public load_duration_ms: (number|Long);
                public absolute_duration_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.MapsStartupMeasurementProto.IComponentLoadDurations, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsStartupMeasurementProto.ComponentLoadDurations;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsStartupMeasurementProto.ComponentLoadDurations;
                public static toObject(message: POGOProtos.Rpc.MapsStartupMeasurementProto.ComponentLoadDurations, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IMapsTelemetryAttribute {
            field?: (POGOProtos.Rpc.IMapsTelemetryField|null);
            value?: (POGOProtos.Rpc.IMapsTelemetryValue|null);
            timestamp?: (number|Long|null);
        }

        class MapsTelemetryAttribute implements IMapsTelemetryAttribute {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryAttribute);
            public field?: (POGOProtos.Rpc.IMapsTelemetryField|null);
            public value?: (POGOProtos.Rpc.IMapsTelemetryValue|null);
            public timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryAttribute, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryAttribute;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryAttribute;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryAttribute, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsTelemetryAttribute {

            interface ILabel {
                field?: (POGOProtos.Rpc.IMapsTelemetryField|null);
            }

            class Label implements ILabel {
                constructor(properties?: POGOProtos.Rpc.MapsTelemetryAttribute.ILabel);
                public field?: (POGOProtos.Rpc.IMapsTelemetryField|null);
                public static encode(message: POGOProtos.Rpc.MapsTelemetryAttribute.ILabel, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryAttribute.Label;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryAttribute.Label;
                public static toObject(message: POGOProtos.Rpc.MapsTelemetryAttribute.Label, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IMapsTelemetryAttributeRecordProto {
            common?: (POGOProtos.Rpc.IMapsTelemetryMetadataProto|null);
            compressed_common?: (Uint8Array|null);
            attribute?: (POGOProtos.Rpc.IMapsTelemetryAttribute|null);
            attribute_v2?: (POGOProtos.Rpc.IMapsTelemetryAttributeV2|null);
        }

        class MapsTelemetryAttributeRecordProto implements IMapsTelemetryAttributeRecordProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryAttributeRecordProto);
            public common?: (POGOProtos.Rpc.IMapsTelemetryMetadataProto|null);
            public compressed_common?: (Uint8Array|null);
            public attribute?: (POGOProtos.Rpc.IMapsTelemetryAttribute|null);
            public attribute_v2?: (POGOProtos.Rpc.IMapsTelemetryAttributeV2|null);
            public Metadata?: ("common"|"compressed_common");
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryAttributeRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryAttributeRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryAttributeRecordProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryAttributeRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryAttributeV2 {
            attribute_name?: (string|null);
            value?: (POGOProtos.Rpc.IMapsTelemetryValue|null);
        }

        class MapsTelemetryAttributeV2 implements IMapsTelemetryAttributeV2 {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryAttributeV2);
            public attribute_name: string;
            public value?: (POGOProtos.Rpc.IMapsTelemetryValue|null);
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryAttributeV2, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryAttributeV2;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryAttributeV2;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryAttributeV2, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryBatchProto {
            environment_id?: (string|null);
            events?: (POGOProtos.Rpc.IMapsTelemetryEventRecordProto[]|null);
        }

        class MapsTelemetryBatchProto implements IMapsTelemetryBatchProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryBatchProto);
            public environment_id: string;
            public events: POGOProtos.Rpc.IMapsTelemetryEventRecordProto[];
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryBatchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryBatchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryBatchProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryBatchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryCommonFilterProto {
            application_identifier?: (string|null);
            operating_system_name?: (string|null);
            device_model?: (string|null);
            locale_country_code?: (string|null);
            locale_language_code?: (string|null);
            quality_level?: (string|null);
            network_connectivity_type?: (string|null);
            game_context?: (string|null);
            timezone?: (string|null);
            client_version?: (string|null);
            sdk_version?: (string|null);
            unity_version?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
        }

        class MapsTelemetryCommonFilterProto implements IMapsTelemetryCommonFilterProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryCommonFilterProto);
            public application_identifier: string;
            public operating_system_name: string;
            public device_model: string;
            public locale_country_code: string;
            public locale_language_code: string;
            public quality_level: string;
            public network_connectivity_type: string;
            public game_context: string;
            public timezone: string;
            public client_version: string;
            public sdk_version: string;
            public unity_version: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryCommonFilterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryCommonFilterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryCommonFilterProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryCommonFilterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryEventRecordProto {
            encoded_message?: (Uint8Array|null);
            compressed_message?: (Uint8Array|null);
            common?: (POGOProtos.Rpc.IMapsTelemetryMetadataProto|null);
            compressed_common?: (Uint8Array|null);
            event_name?: (string|null);
            facet_detail_name?: (string|null);
        }

        class MapsTelemetryEventRecordProto implements IMapsTelemetryEventRecordProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryEventRecordProto);
            public encoded_message?: (Uint8Array|null);
            public compressed_message?: (Uint8Array|null);
            public common?: (POGOProtos.Rpc.IMapsTelemetryMetadataProto|null);
            public compressed_common?: (Uint8Array|null);
            public event_name: string;
            public facet_detail_name: string;
            public Message?: ("encoded_message"|"compressed_message");
            public Metadata?: ("common"|"compressed_common");
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryEventRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryEventRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryEventRecordProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryEventRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryField {
            entity_name?: (string|null);
            field_path?: (string|null);
        }

        class MapsTelemetryField implements IMapsTelemetryField {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryField);
            public entity_name: string;
            public field_path: string;
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryField, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryField;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryField;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryField, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryKey {
            key_name?: (string|null);
            value?: (POGOProtos.Rpc.IMapsTelemetryValue|null);
        }

        class MapsTelemetryKey implements IMapsTelemetryKey {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryKey);
            public key_name: string;
            public value?: (POGOProtos.Rpc.IMapsTelemetryValue|null);
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryKey, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryKey;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryKey;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryKey, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryMetadataProto {
            user_id?: (string|null);
            session_id?: (number|Long|null);
            record_id?: (string|null);
            telemetry_scope_id?: (POGOProtos.Rpc.MapsTelemetryMetadataProto.TelemetryScopeId|null);
            is_queryable?: (boolean|null);
            keyvalue_column?: (string|null);
            processing_attempts_count?: (number|null);
            pub_sub_message_id?: (string|null);
            source_published_timestamp_millis?: (number|Long|null);
            anfe_published_timestamp_millis?: (number|Long|null);
            platform_player_info?: (POGOProtos.Rpc.IMapsPlatformPlayerInfo|null);
            device_info?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
        }

        class MapsTelemetryMetadataProto implements IMapsTelemetryMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryMetadataProto);
            public user_id: string;
            public session_id: (number|Long);
            public record_id: string;
            public telemetry_scope_id: POGOProtos.Rpc.MapsTelemetryMetadataProto.TelemetryScopeId;
            public is_queryable: boolean;
            public keyvalue_column: string;
            public processing_attempts_count: number;
            public pub_sub_message_id: string;
            public source_published_timestamp_millis: (number|Long);
            public anfe_published_timestamp_millis: (number|Long);
            public platform_player_info?: (POGOProtos.Rpc.IMapsPlatformPlayerInfo|null);
            public device_info?: (POGOProtos.Rpc.IMapsClientTelemetryCommonFilterProto|null);
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryMetadataProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsTelemetryMetadataProto {

            enum TelemetryScopeId {
                UNSET = 0,
                PLATFORM_SERVER = 1,
                PLATFORM_CLIENT = 2,
                GAME_SERVER = 3,
                GAME_CLIENT = 4
            }
        }

        interface IMapsTelemetryMetricRecordProto {
            common?: (POGOProtos.Rpc.IMapsTelemetryMetadataProto|null);
            compressed_common?: (Uint8Array|null);
            long?: (number|Long|null);
            double?: (number|null);
            boolean?: (boolean|null);
            metric_id?: (string|null);
            kind?: (POGOProtos.Rpc.MapsTelemetryMetricRecordProto.Kind|null);
        }

        class MapsTelemetryMetricRecordProto implements IMapsTelemetryMetricRecordProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryMetricRecordProto);
            public common?: (POGOProtos.Rpc.IMapsTelemetryMetadataProto|null);
            public compressed_common?: (Uint8Array|null);
            public long?: (number|Long|null);
            public double?: (number|null);
            public boolean?: (boolean|null);
            public metric_id: string;
            public kind: POGOProtos.Rpc.MapsTelemetryMetricRecordProto.Kind;
            public Metadata?: ("common"|"compressed_common");
            public Value?: ("long"|"double"|"boolean");
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryMetricRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryMetricRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryMetricRecordProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryMetricRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsTelemetryMetricRecordProto {

            enum Kind {
                UNSPECIFIED = 0,
                GAUGE = 1,
                DELTA = 2,
                CUMULATIVE = 3
            }
        }

        interface IMapsTelemetryRecordResult {
            record_id?: (string|null);
            status?: (POGOProtos.Rpc.MapsTelemetryRecordResult.Status|null);
            telemetry_type_name?: (string|null);
            failure_detail?: (string|null);
            retry_after_ms?: (number|Long|null);
        }

        class MapsTelemetryRecordResult implements IMapsTelemetryRecordResult {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryRecordResult);
            public record_id: string;
            public status: POGOProtos.Rpc.MapsTelemetryRecordResult.Status;
            public telemetry_type_name: string;
            public failure_detail: string;
            public retry_after_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryRecordResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryRecordResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryRecordResult;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryRecordResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsTelemetryRecordResult {

            enum Status {
                UNSET = 0,
                INVALID_REQUEST = 10,
                ACCESS_DENIED = 11,
                NOT_APPROVED_EVENT = 12,
                BACKEND_ERROR = 20,
                THROTTLED = 30
            }
        }

        interface IMapsTelemetryRequestMetadata {
            user_id?: (string|null);
            is_minor?: (boolean|null);
            env_id?: (string|null);
        }

        class MapsTelemetryRequestMetadata implements IMapsTelemetryRequestMetadata {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryRequestMetadata);
            public user_id: string;
            public is_minor: boolean;
            public env_id: string;
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryRequestMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryRequestMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryRequestMetadata;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryRequestMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryRequestProto {
            api_version?: (string|null);
            message_version?: (string|null);
            telemetry_batch?: (Uint8Array|null);
        }

        class MapsTelemetryRequestProto implements IMapsTelemetryRequestProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryRequestProto);
            public api_version: string;
            public message_version: string;
            public telemetry_batch: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryRequestProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMapsTelemetryResponseProto {
            status?: (POGOProtos.Rpc.MapsTelemetryResponseProto.Status|null);
            rows_written?: (number|null);
            failure_detail?: (string|null);
            retryable_failures?: (POGOProtos.Rpc.IMapsTelemetryRecordResult[]|null);
            non_retryable_failures?: (POGOProtos.Rpc.IMapsTelemetryRecordResult[]|null);
        }

        class MapsTelemetryResponseProto implements IMapsTelemetryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryResponseProto);
            public status: POGOProtos.Rpc.MapsTelemetryResponseProto.Status;
            public rows_written: number;
            public failure_detail: string;
            public retryable_failures: POGOProtos.Rpc.IMapsTelemetryRecordResult[];
            public non_retryable_failures: POGOProtos.Rpc.IMapsTelemetryRecordResult[];
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryResponseProto;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MapsTelemetryResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                PARTIAL_FAILURE = 3
            }
        }

        interface IMapsTelemetryValue {
            int_value?: (number|Long|null);
            double_value?: (number|null);
            string_value?: (string|null);
            bool_value?: (boolean|null);
        }

        class MapsTelemetryValue implements IMapsTelemetryValue {
            constructor(properties?: POGOProtos.Rpc.IMapsTelemetryValue);
            public int_value?: (number|Long|null);
            public double_value?: (number|null);
            public string_value?: (string|null);
            public bool_value?: (boolean|null);
            public Value?: ("int_value"|"double_value"|"string_value"|"bool_value");
            public static encode(message: POGOProtos.Rpc.IMapsTelemetryValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MapsTelemetryValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MapsTelemetryValue;
            public static toObject(message: POGOProtos.Rpc.MapsTelemetryValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMarkMilestoneAsViewedOutProto {
            status?: (POGOProtos.Rpc.MarkMilestoneAsViewedOutProto.Status|null);
        }

        class MarkMilestoneAsViewedOutProto implements IMarkMilestoneAsViewedOutProto {
            constructor(properties?: POGOProtos.Rpc.IMarkMilestoneAsViewedOutProto);
            public status: POGOProtos.Rpc.MarkMilestoneAsViewedOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IMarkMilestoneAsViewedOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkMilestoneAsViewedOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkMilestoneAsViewedOutProto;
            public static toObject(message: POGOProtos.Rpc.MarkMilestoneAsViewedOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarkMilestoneAsViewedOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2,
                ERROR_MILESTONE_NOT_FOUND = 3
            }
        }

        interface IMarkMilestoneAsViewedProto {
            referrer_milestones_to_mark?: (POGOProtos.Rpc.MarkMilestoneAsViewedProto.IMilestoneLookupProto[]|null);
            referee_milestones_to_mark?: (POGOProtos.Rpc.MarkMilestoneAsViewedProto.IMilestoneLookupProto[]|null);
        }

        class MarkMilestoneAsViewedProto implements IMarkMilestoneAsViewedProto {
            constructor(properties?: POGOProtos.Rpc.IMarkMilestoneAsViewedProto);
            public referrer_milestones_to_mark: POGOProtos.Rpc.MarkMilestoneAsViewedProto.IMilestoneLookupProto[];
            public referee_milestones_to_mark: POGOProtos.Rpc.MarkMilestoneAsViewedProto.IMilestoneLookupProto[];
            public static encode(message: POGOProtos.Rpc.IMarkMilestoneAsViewedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkMilestoneAsViewedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkMilestoneAsViewedProto;
            public static toObject(message: POGOProtos.Rpc.MarkMilestoneAsViewedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarkMilestoneAsViewedProto {

            interface IMilestoneLookupProto {
                player_id?: (string|null);
                milestone_id?: (string|null);
            }

            class MilestoneLookupProto implements IMilestoneLookupProto {
                constructor(properties?: POGOProtos.Rpc.MarkMilestoneAsViewedProto.IMilestoneLookupProto);
                public player_id: string;
                public milestone_id: string;
                public static encode(message: POGOProtos.Rpc.MarkMilestoneAsViewedProto.IMilestoneLookupProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkMilestoneAsViewedProto.MilestoneLookupProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkMilestoneAsViewedProto.MilestoneLookupProto;
                public static toObject(message: POGOProtos.Rpc.MarkMilestoneAsViewedProto.MilestoneLookupProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IMarkNewsfeedReadRequest {
            app_id?: (string|null);
            player_id?: (string|null);
            newsfeed_post_id?: (string[]|null);
        }

        class MarkNewsfeedReadRequest implements IMarkNewsfeedReadRequest {
            constructor(properties?: POGOProtos.Rpc.IMarkNewsfeedReadRequest);
            public app_id: string;
            public player_id: string;
            public newsfeed_post_id: string[];
            public static encode(message: POGOProtos.Rpc.IMarkNewsfeedReadRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkNewsfeedReadRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkNewsfeedReadRequest;
            public static toObject(message: POGOProtos.Rpc.MarkNewsfeedReadRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMarkNewsfeedReadResponse {
            result?: (POGOProtos.Rpc.MarkNewsfeedReadResponse.Result|null);
        }

        class MarkNewsfeedReadResponse implements IMarkNewsfeedReadResponse {
            constructor(properties?: POGOProtos.Rpc.IMarkNewsfeedReadResponse);
            public result: POGOProtos.Rpc.MarkNewsfeedReadResponse.Result;
            public static encode(message: POGOProtos.Rpc.IMarkNewsfeedReadResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkNewsfeedReadResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkNewsfeedReadResponse;
            public static toObject(message: POGOProtos.Rpc.MarkNewsfeedReadResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarkNewsfeedReadResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                INTERNAL_ERROR = 2,
                CHANNEL_NOT_DEFINED = 3,
                EMPTY_NEWSFEED_LIST = 4,
                EMPTY_PLAYER_ID = 5,
                EMPTY_APP_ID = 6
            }
        }

        interface IMarkReadNewsArticleOutProto {
            result?: (POGOProtos.Rpc.MarkReadNewsArticleOutProto.Result|null);
        }

        class MarkReadNewsArticleOutProto implements IMarkReadNewsArticleOutProto {
            constructor(properties?: POGOProtos.Rpc.IMarkReadNewsArticleOutProto);
            public result: POGOProtos.Rpc.MarkReadNewsArticleOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IMarkReadNewsArticleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkReadNewsArticleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkReadNewsArticleOutProto;
            public static toObject(message: POGOProtos.Rpc.MarkReadNewsArticleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarkReadNewsArticleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_NEWS_FOUND = 2
            }
        }

        interface IMarkReadNewsArticleProto {
            news_ids?: (string[]|null);
        }

        class MarkReadNewsArticleProto implements IMarkReadNewsArticleProto {
            constructor(properties?: POGOProtos.Rpc.IMarkReadNewsArticleProto);
            public news_ids: string[];
            public static encode(message: POGOProtos.Rpc.IMarkReadNewsArticleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkReadNewsArticleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkReadNewsArticleProto;
            public static toObject(message: POGOProtos.Rpc.MarkReadNewsArticleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMarkSaveForLaterOutProto {
            result?: (POGOProtos.Rpc.MarkSaveForLaterOutProto.Result|null);
        }

        class MarkSaveForLaterOutProto implements IMarkSaveForLaterOutProto {
            constructor(properties?: POGOProtos.Rpc.IMarkSaveForLaterOutProto);
            public result: POGOProtos.Rpc.MarkSaveForLaterOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IMarkSaveForLaterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkSaveForLaterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkSaveForLaterOutProto;
            public static toObject(message: POGOProtos.Rpc.MarkSaveForLaterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarkSaveForLaterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ALREADY_MARKED = 2,
                ERROR_POKEMON_NOT_FOUND = 3,
                ERROR_SAVE_FOR_LATER_LIMIT_REACHED = 4,
                ERROR_NOT_IN_RANGE = 5,
                ERROR_STATION_NOT_FOUND = 6,
                ERROR_SAVE_FOR_LATER_NOT_ENABLED = 7
            }
        }

        interface IMarkSaveForLaterProto {
            station_id?: (string|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
        }

        class MarkSaveForLaterProto implements IMarkSaveForLaterProto {
            constructor(properties?: POGOProtos.Rpc.IMarkSaveForLaterProto);
            public station_id: string;
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IMarkSaveForLaterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkSaveForLaterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkSaveForLaterProto;
            public static toObject(message: POGOProtos.Rpc.MarkSaveForLaterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMarkTutorialCompleteOutProto {
            success?: (boolean|null);
            player?: (POGOProtos.Rpc.IClientPlayerProto|null);
        }

        class MarkTutorialCompleteOutProto implements IMarkTutorialCompleteOutProto {
            constructor(properties?: POGOProtos.Rpc.IMarkTutorialCompleteOutProto);
            public success: boolean;
            public player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public static encode(message: POGOProtos.Rpc.IMarkTutorialCompleteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkTutorialCompleteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkTutorialCompleteOutProto;
            public static toObject(message: POGOProtos.Rpc.MarkTutorialCompleteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMarkTutorialCompleteProto {
            tutorial_complete?: (POGOProtos.Rpc.TutorialCompletion[]|null);
            send_marketing_emails?: (boolean|null);
            send_push_notifications?: (boolean|null);
        }

        class MarkTutorialCompleteProto implements IMarkTutorialCompleteProto {
            constructor(properties?: POGOProtos.Rpc.IMarkTutorialCompleteProto);
            public tutorial_complete: POGOProtos.Rpc.TutorialCompletion[];
            public send_marketing_emails: boolean;
            public send_push_notifications: boolean;
            public static encode(message: POGOProtos.Rpc.IMarkTutorialCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarkTutorialCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarkTutorialCompleteProto;
            public static toObject(message: POGOProtos.Rpc.MarkTutorialCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMarketingTelemetryNewsfeedEvent {
            event_type?: (POGOProtos.Rpc.MarketingTelemetryNewsfeedEvent.NewsfeedEventType|null);
        }

        class MarketingTelemetryNewsfeedEvent implements IMarketingTelemetryNewsfeedEvent {
            constructor(properties?: POGOProtos.Rpc.IMarketingTelemetryNewsfeedEvent);
            public event_type: POGOProtos.Rpc.MarketingTelemetryNewsfeedEvent.NewsfeedEventType;
            public static encode(message: POGOProtos.Rpc.IMarketingTelemetryNewsfeedEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarketingTelemetryNewsfeedEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarketingTelemetryNewsfeedEvent;
            public static toObject(message: POGOProtos.Rpc.MarketingTelemetryNewsfeedEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarketingTelemetryNewsfeedEvent {

            enum NewsfeedEventType {
                UNSET = 0,
                RECEIVED = 1,
                READ = 2
            }
        }

        interface IMarketingTelemetryPushNotificationEvent {
            event_type?: (POGOProtos.Rpc.MarketingTelemetryPushNotificationEvent.PushNotificationEventType|null);
            push_id?: (string|null);
            reason?: (string|null);
        }

        class MarketingTelemetryPushNotificationEvent implements IMarketingTelemetryPushNotificationEvent {
            constructor(properties?: POGOProtos.Rpc.IMarketingTelemetryPushNotificationEvent);
            public event_type: POGOProtos.Rpc.MarketingTelemetryPushNotificationEvent.PushNotificationEventType;
            public push_id: string;
            public reason: string;
            public static encode(message: POGOProtos.Rpc.IMarketingTelemetryPushNotificationEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MarketingTelemetryPushNotificationEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MarketingTelemetryPushNotificationEvent;
            public static toObject(message: POGOProtos.Rpc.MarketingTelemetryPushNotificationEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MarketingTelemetryPushNotificationEvent {

            enum PushNotificationEventType {
                UNSET = 0,
                PROCESSED = 1,
                RECEIVED = 2,
                OPENED = 3,
                DISMISSED = 4,
                BOUNCED = 5,
                SENT = 6,
                FAILED_SEND = 7,
                BAD_REGISTRATION = 8
            }
        }

        interface IMaxBattleFriendActivityProto {
            station_id?: (string|null);
            station_lat?: (number|null);
            station_lon?: (number|null);
            battle_seed?: (number|Long|null);
            max_battle_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            bread_battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
            end_time_ms?: (number|Long|null);
        }

        class MaxBattleFriendActivityProto implements IMaxBattleFriendActivityProto {
            constructor(properties?: POGOProtos.Rpc.IMaxBattleFriendActivityProto);
            public station_id: string;
            public station_lat: number;
            public station_lon: number;
            public battle_seed: (number|Long);
            public max_battle_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public bread_battle_level: POGOProtos.Rpc.BreadBattleLevel;
            public end_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMaxBattleFriendActivityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MaxBattleFriendActivityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MaxBattleFriendActivityProto;
            public static toObject(message: POGOProtos.Rpc.MaxBattleFriendActivityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvoGlobalSettingsProto {
            enable_friends_list_mega_info?: (boolean|null);
            enable_mega_level?: (boolean|null);
        }

        class MegaEvoGlobalSettingsProto implements IMegaEvoGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvoGlobalSettingsProto);
            public enable_friends_list_mega_info: boolean;
            public enable_mega_level: boolean;
            public static encode(message: POGOProtos.Rpc.IMegaEvoGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvoGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvoGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvoGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvoInfoProto {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            evo_expiration_time_ms?: (number|Long|null);
        }

        class MegaEvoInfoProto implements IMegaEvoInfoProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvoInfoProto);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public evo_expiration_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMegaEvoInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvoInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvoInfoProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvoInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvoSettingsProto {
            evolution_length_ms?: (number|Long|null);
            attack_boost_from_mega_different_type?: (number|null);
            attack_boost_from_mega_same_type?: (number|null);
            max_candy_hoard_size?: (number|null);
            enable_buddy_walking_mega_energy_award?: (boolean|null);
            active_mega_bonus_catch_candy?: (number|null);
            enable_mega_level?: (boolean|null);
            enable_mega_evolve_in_lobby?: (boolean|null);
            num_mega_levels?: (number|null);
            client_mega_cooldown_buffer_ms?: (number|null);
            enable_mega_level_legacy_award?: (boolean|null);
        }

        class MegaEvoSettingsProto implements IMegaEvoSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvoSettingsProto);
            public evolution_length_ms: (number|Long);
            public attack_boost_from_mega_different_type: number;
            public attack_boost_from_mega_same_type: number;
            public max_candy_hoard_size: number;
            public enable_buddy_walking_mega_energy_award: boolean;
            public active_mega_bonus_catch_candy: number;
            public enable_mega_level: boolean;
            public enable_mega_evolve_in_lobby: boolean;
            public num_mega_levels: number;
            public client_mega_cooldown_buffer_ms: number;
            public enable_mega_level_legacy_award: boolean;
            public static encode(message: POGOProtos.Rpc.IMegaEvoSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvoSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvoSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvoSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvolutionCooldownSettingsProto {
            duration_ms?: (number|Long|null);
            bypass_cost_initial?: (number|null);
            bypass_cost_final?: (number|null);
            bypass_cost_rounding_value?: (number|null);
        }

        class MegaEvolutionCooldownSettingsProto implements IMegaEvolutionCooldownSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolutionCooldownSettingsProto);
            public duration_ms: (number|Long);
            public bypass_cost_initial: number;
            public bypass_cost_final: number;
            public bypass_cost_rounding_value: number;
            public static encode(message: POGOProtos.Rpc.IMegaEvolutionCooldownSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolutionCooldownSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolutionCooldownSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolutionCooldownSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvolutionEffectsSettingsProto {
            different_type_attack_boost?: (number|null);
            same_type_attack_boost?: (number|null);
            same_type_extra_catch_candy?: (number|null);
            same_type_extra_catch_xp?: (number|null);
            same_type_extra_catch_candy_xl_chance?: (number|null);
        }

        class MegaEvolutionEffectsSettingsProto implements IMegaEvolutionEffectsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolutionEffectsSettingsProto);
            public different_type_attack_boost: number;
            public same_type_attack_boost: number;
            public same_type_extra_catch_candy: number;
            public same_type_extra_catch_xp: number;
            public same_type_extra_catch_candy_xl_chance: number;
            public static encode(message: POGOProtos.Rpc.IMegaEvolutionEffectsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolutionEffectsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolutionEffectsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolutionEffectsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvolutionLevelSettingsProto {
            level?: (number|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            progression?: (POGOProtos.Rpc.IMegaEvolutionProgressionSettingsProto|null);
            cooldown?: (POGOProtos.Rpc.IMegaEvolutionCooldownSettingsProto|null);
            effects?: (POGOProtos.Rpc.IMegaEvolutionEffectsSettingsProto|null);
        }

        class MegaEvolutionLevelSettingsProto implements IMegaEvolutionLevelSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolutionLevelSettingsProto);
            public level: number;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public progression?: (POGOProtos.Rpc.IMegaEvolutionProgressionSettingsProto|null);
            public cooldown?: (POGOProtos.Rpc.IMegaEvolutionCooldownSettingsProto|null);
            public effects?: (POGOProtos.Rpc.IMegaEvolutionEffectsSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IMegaEvolutionLevelSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolutionLevelSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolutionLevelSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolutionLevelSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvolutionProgressionSettingsProto {
            points_required?: (number|null);
            points_limit_per_period?: (number|null);
            points_per_mega_evo_action?: (number|null);
        }

        class MegaEvolutionProgressionSettingsProto implements IMegaEvolutionProgressionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolutionProgressionSettingsProto);
            public points_required: number;
            public points_limit_per_period: number;
            public points_per_mega_evo_action: number;
            public static encode(message: POGOProtos.Rpc.IMegaEvolutionProgressionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolutionProgressionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolutionProgressionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolutionProgressionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvolvePokemonClientContextHelper {
        }

        class MegaEvolvePokemonClientContextHelper implements IMegaEvolvePokemonClientContextHelper {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolvePokemonClientContextHelper);
            public static encode(message: POGOProtos.Rpc.IMegaEvolvePokemonClientContextHelper, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolvePokemonClientContextHelper;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolvePokemonClientContextHelper;
            public static toObject(message: POGOProtos.Rpc.MegaEvolvePokemonClientContextHelper, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MegaEvolvePokemonClientContextHelper {

            enum MegaEvolvePokemonClientContext {
                UNSET = 0,
                POKEMON_DETAILS = 1,
                RAID_LOBBY = 2,
                GYM_BATTLE_LOBBY = 3,
                NPC_COMBAT_LOBBY = 4,
                PLAYER_COMBAT_LOBBY = 5
            }
        }

        interface IMegaEvolvePokemonOutProto {
            result?: (POGOProtos.Rpc.MegaEvolvePokemonOutProto.Result|null);
            evolved_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            exp_awarded?: (number|null);
            preview?: (POGOProtos.Rpc.IPreviewProto|null);
        }

        class MegaEvolvePokemonOutProto implements IMegaEvolvePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolvePokemonOutProto);
            public result: POGOProtos.Rpc.MegaEvolvePokemonOutProto.Result;
            public evolved_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public exp_awarded: number;
            public preview?: (POGOProtos.Rpc.IPreviewProto|null);
            public static encode(message: POGOProtos.Rpc.IMegaEvolvePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolvePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolvePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolvePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MegaEvolvePokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILED_POKEMON_MISSING = 2,
                FAILED_INSUFFICIENT_RESOURCES = 3,
                FAILED_POKEMON_CANNOT_EVOLVE = 4,
                FAILED_POKEMON_IS_DEPLOYED = 5,
                FAILED_INVALID_ITEM_REQUIREMENT = 6,
                FAILED_POKEMON_ALREADY_MEGA_EVOLVED = 7
            }
        }

        interface IMegaEvolvePokemonProto {
            pokemon_id?: (number|Long|null);
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            preview?: (boolean|null);
            client_context?: (POGOProtos.Rpc.MegaEvolvePokemonClientContextHelper.MegaEvolvePokemonClientContext|null);
        }

        class MegaEvolvePokemonProto implements IMegaEvolvePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolvePokemonProto);
            public pokemon_id: (number|Long);
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public preview: boolean;
            public client_context: POGOProtos.Rpc.MegaEvolvePokemonClientContextHelper.MegaEvolvePokemonClientContext;
            public static encode(message: POGOProtos.Rpc.IMegaEvolvePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolvePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolvePokemonProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolvePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMegaEvolvePokemonSpeciesProto {
            energy_count?: (number|null);
            pokemon_species_id?: (number|null);
        }

        class MegaEvolvePokemonSpeciesProto implements IMegaEvolvePokemonSpeciesProto {
            constructor(properties?: POGOProtos.Rpc.IMegaEvolvePokemonSpeciesProto);
            public energy_count: number;
            public pokemon_species_id: number;
            public static encode(message: POGOProtos.Rpc.IMegaEvolvePokemonSpeciesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MegaEvolvePokemonSpeciesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MegaEvolvePokemonSpeciesProto;
            public static toObject(message: POGOProtos.Rpc.MegaEvolvePokemonSpeciesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMementoAttributesProto {
            postcard_display?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
            memento_type?: (POGOProtos.Rpc.MementoType|null);
            latitude?: (number|null);
            longitude?: (number|null);
            added_timestamp_ms?: (number|Long|null);
            memento_hash?: (string|null);
        }

        class MementoAttributesProto implements IMementoAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IMementoAttributesProto);
            public postcard_display?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
            public memento_type: POGOProtos.Rpc.MementoType;
            public latitude: number;
            public longitude: number;
            public added_timestamp_ms: (number|Long);
            public memento_hash: string;
            public Type?: "postcard_display";
            public static encode(message: POGOProtos.Rpc.IMementoAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MementoAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MementoAttributesProto;
            public static toObject(message: POGOProtos.Rpc.MementoAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMeshingStartEvent {
            empty_field?: (boolean|null);
        }

        class MeshingStartEvent implements IMeshingStartEvent {
            constructor(properties?: POGOProtos.Rpc.IMeshingStartEvent);
            public empty_field: boolean;
            public static encode(message: POGOProtos.Rpc.IMeshingStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MeshingStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MeshingStartEvent;
            public static toObject(message: POGOProtos.Rpc.MeshingStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMeshingStopEvent {
            time_elapsed_ms?: (number|null);
        }

        class MeshingStopEvent implements IMeshingStopEvent {
            constructor(properties?: POGOProtos.Rpc.IMeshingStopEvent);
            public time_elapsed_ms: number;
            public static encode(message: POGOProtos.Rpc.IMeshingStopEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MeshingStopEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MeshingStopEvent;
            public static toObject(message: POGOProtos.Rpc.MeshingStopEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMessageOptions {
            message_set_wire_format?: (boolean|null);
            no_standard_descriptor_accessor?: (boolean|null);
            deprecated?: (boolean|null);
            map_entry?: (boolean|null);
        }

        class MessageOptions implements IMessageOptions {
            constructor(properties?: POGOProtos.Rpc.IMessageOptions);
            public message_set_wire_format: boolean;
            public no_standard_descriptor_accessor: boolean;
            public deprecated: boolean;
            public map_entry: boolean;
            public static encode(message: POGOProtos.Rpc.IMessageOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MessageOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MessageOptions;
            public static toObject(message: POGOProtos.Rpc.MessageOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMessagingClientEvent {
            project_number?: (number|Long|null);
            message_id?: (string|null);
            instance_id?: (string|null);
            message_type?: (POGOProtos.Rpc.MessagingClientEvent.MessageType|null);
            sdk_platform?: (POGOProtos.Rpc.MessagingClientEvent.SDKPlatform|null);
            package_name?: (string|null);
            collapse_key?: (string|null);
            priority?: (number|null);
            ttl?: (number|null);
            topic?: (string|null);
            bulk_id?: (number|Long|null);
            event?: (POGOProtos.Rpc.MessagingClientEvent.Event|null);
            analytics_label?: (string|null);
            campaign_id?: (number|Long|null);
            composer_label?: (string|null);
        }

        class MessagingClientEvent implements IMessagingClientEvent {
            constructor(properties?: POGOProtos.Rpc.IMessagingClientEvent);
            public project_number: (number|Long);
            public message_id: string;
            public instance_id: string;
            public message_type: POGOProtos.Rpc.MessagingClientEvent.MessageType;
            public sdk_platform: POGOProtos.Rpc.MessagingClientEvent.SDKPlatform;
            public package_name: string;
            public collapse_key: string;
            public priority: number;
            public ttl: number;
            public topic: string;
            public bulk_id: (number|Long);
            public event: POGOProtos.Rpc.MessagingClientEvent.Event;
            public analytics_label: string;
            public campaign_id: (number|Long);
            public composer_label: string;
            public static encode(message: POGOProtos.Rpc.IMessagingClientEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MessagingClientEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MessagingClientEvent;
            public static toObject(message: POGOProtos.Rpc.MessagingClientEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MessagingClientEvent {

            enum MessageType {
                UNKNOWN = 0,
                DATA_MESSAGE = 1,
                TOPIC = 2,
                DISPLAY_NOTIFICATION = 3
            }

            enum SDKPlatform {
                UNKNOWN_OS = 0,
                ANDROID = 1,
                IOS = 2,
                WEB = 3
            }

            enum Event {
                UNKNOWN_EVENT = 0,
                MESSAGE_DELIVERED = 1,
                MESSAGE_OPEN = 2
            }
        }

        interface IMessagingClientEventExtension {
            messaging_client_event?: (POGOProtos.Rpc.IMessagingClientEvent|null);
        }

        class MessagingClientEventExtension implements IMessagingClientEventExtension {
            constructor(properties?: POGOProtos.Rpc.IMessagingClientEventExtension);
            public messaging_client_event?: (POGOProtos.Rpc.IMessagingClientEvent|null);
            public static encode(message: POGOProtos.Rpc.IMessagingClientEventExtension, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MessagingClientEventExtension;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MessagingClientEventExtension;
            public static toObject(message: POGOProtos.Rpc.MessagingClientEventExtension, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMethodDescriptorProto {
            name?: (string|null);
            input_type?: (string|null);
            output_type?: (string|null);
            options?: (POGOProtos.Rpc.IMethodOptions|null);
            client_streaming?: (boolean|null);
            server_streaming?: (boolean|null);
        }

        class MethodDescriptorProto implements IMethodDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IMethodDescriptorProto);
            public name: string;
            public input_type: string;
            public output_type: string;
            public options?: (POGOProtos.Rpc.IMethodOptions|null);
            public client_streaming: boolean;
            public server_streaming: boolean;
            public static encode(message: POGOProtos.Rpc.IMethodDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MethodDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MethodDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.MethodDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMethodGoogle {
            name?: (string|null);
            request_type_url?: (string|null);
            request_streaming?: (boolean|null);
            response_type_url?: (string|null);
            response_streaming?: (boolean|null);
            options?: (POGOProtos.Rpc.IOption[]|null);
            syntax?: (POGOProtos.Rpc.Syntax|null);
        }

        class MethodGoogle implements IMethodGoogle {
            constructor(properties?: POGOProtos.Rpc.IMethodGoogle);
            public name: string;
            public request_type_url: string;
            public request_streaming: boolean;
            public response_type_url: string;
            public response_streaming: boolean;
            public options: POGOProtos.Rpc.IOption[];
            public syntax: POGOProtos.Rpc.Syntax;
            public static encode(message: POGOProtos.Rpc.IMethodGoogle, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MethodGoogle;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MethodGoogle;
            public static toObject(message: POGOProtos.Rpc.MethodGoogle, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMethodOptions {
            deprecated?: (boolean|null);
        }

        class MethodOptions implements IMethodOptions {
            constructor(properties?: POGOProtos.Rpc.IMethodOptions);
            public deprecated: boolean;
            public static encode(message: POGOProtos.Rpc.IMethodOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MethodOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MethodOptions;
            public static toObject(message: POGOProtos.Rpc.MethodOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMetricRecord {
            server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            datapoint?: (POGOProtos.Rpc.IDatapoint|null);
            common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
        }

        class MetricRecord implements IMetricRecord {
            constructor(properties?: POGOProtos.Rpc.IMetricRecord);
            public server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            public datapoint?: (POGOProtos.Rpc.IDatapoint|null);
            public common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
            public static encode(message: POGOProtos.Rpc.IMetricRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MetricRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MetricRecord;
            public static toObject(message: POGOProtos.Rpc.MetricRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMiniCollectionBadgeData {
            event?: (POGOProtos.Rpc.IMiniCollectionBadgeEvent[]|null);
        }

        class MiniCollectionBadgeData implements IMiniCollectionBadgeData {
            constructor(properties?: POGOProtos.Rpc.IMiniCollectionBadgeData);
            public event: POGOProtos.Rpc.IMiniCollectionBadgeEvent[];
            public static encode(message: POGOProtos.Rpc.IMiniCollectionBadgeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MiniCollectionBadgeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MiniCollectionBadgeData;
            public static toObject(message: POGOProtos.Rpc.MiniCollectionBadgeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMiniCollectionBadgeEvent {
            event_id?: (string|null);
            completed_timestamp?: (number|Long|null);
        }

        class MiniCollectionBadgeEvent implements IMiniCollectionBadgeEvent {
            constructor(properties?: POGOProtos.Rpc.IMiniCollectionBadgeEvent);
            public event_id: string;
            public completed_timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IMiniCollectionBadgeEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MiniCollectionBadgeEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MiniCollectionBadgeEvent;
            public static toObject(message: POGOProtos.Rpc.MiniCollectionBadgeEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMiniCollectionPokemon {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            caught?: (boolean|null);
            collection_type?: (POGOProtos.Rpc.MiniCollectionPokemon.CollectType|null);
            require_alignment_to_match?: (boolean|null);
        }

        class MiniCollectionPokemon implements IMiniCollectionPokemon {
            constructor(properties?: POGOProtos.Rpc.IMiniCollectionPokemon);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public caught: boolean;
            public collection_type: POGOProtos.Rpc.MiniCollectionPokemon.CollectType;
            public require_alignment_to_match: boolean;
            public static encode(message: POGOProtos.Rpc.IMiniCollectionPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MiniCollectionPokemon;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MiniCollectionPokemon;
            public static toObject(message: POGOProtos.Rpc.MiniCollectionPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MiniCollectionPokemon {

            enum CollectType {
                CATCH = 0,
                TRADE = 1,
                EVOLVE = 2,
                CATCH_FROM_RAID = 3,
                HATCH = 4
            }
        }

        interface IMiniCollectionProto {
            pokemon?: (POGOProtos.Rpc.IMiniCollectionPokemon[]|null);
            completed?: (boolean|null);
        }

        class MiniCollectionProto implements IMiniCollectionProto {
            constructor(properties?: POGOProtos.Rpc.IMiniCollectionProto);
            public pokemon: POGOProtos.Rpc.IMiniCollectionPokemon[];
            public completed: boolean;
            public static encode(message: POGOProtos.Rpc.IMiniCollectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MiniCollectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MiniCollectionProto;
            public static toObject(message: POGOProtos.Rpc.MiniCollectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMiniCollectionSectionProto {
            quest_id?: (string|null);
        }

        class MiniCollectionSectionProto implements IMiniCollectionSectionProto {
            constructor(properties?: POGOProtos.Rpc.IMiniCollectionSectionProto);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.IMiniCollectionSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MiniCollectionSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MiniCollectionSectionProto;
            public static toObject(message: POGOProtos.Rpc.MiniCollectionSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMissingTranslationTelemetry {
            key?: (string|null);
            language?: (string|null);
        }

        class MissingTranslationTelemetry implements IMissingTranslationTelemetry {
            constructor(properties?: POGOProtos.Rpc.IMissingTranslationTelemetry);
            public key: string;
            public language: string;
            public static encode(message: POGOProtos.Rpc.IMissingTranslationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MissingTranslationTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MissingTranslationTelemetry;
            public static toObject(message: POGOProtos.Rpc.MissingTranslationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMixin {
            name?: (string|null);
            root?: (string|null);
        }

        class Mixin implements IMixin {
            constructor(properties?: POGOProtos.Rpc.IMixin);
            public name: string;
            public root: string;
            public static encode(message: POGOProtos.Rpc.IMixin, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Mixin;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Mixin;
            public static toObject(message: POGOProtos.Rpc.Mixin, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMonodepthDownloadTelemetry {
            downloaded_package?: (boolean|null);
            skipped_package?: (boolean|null);
            model_downloaded?: (string|null);
        }

        class MonodepthDownloadTelemetry implements IMonodepthDownloadTelemetry {
            constructor(properties?: POGOProtos.Rpc.IMonodepthDownloadTelemetry);
            public downloaded_package: boolean;
            public skipped_package: boolean;
            public model_downloaded: string;
            public static encode(message: POGOProtos.Rpc.IMonodepthDownloadTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MonodepthDownloadTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MonodepthDownloadTelemetry;
            public static toObject(message: POGOProtos.Rpc.MonodepthDownloadTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMonodepthSettingsProto {
            enable_occlusions?: (boolean|null);
            occlusions_default_on?: (boolean|null);
            occlusions_toggle_visible?: (boolean|null);
            enable_ground_suppression?: (boolean|null);
            min_ground_suppression_thresh?: (number|null);
            suppression_channel_id?: (number|null);
            suppression_channel_name?: (string|null);
        }

        class MonodepthSettingsProto implements IMonodepthSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMonodepthSettingsProto);
            public enable_occlusions: boolean;
            public occlusions_default_on: boolean;
            public occlusions_toggle_visible: boolean;
            public enable_ground_suppression: boolean;
            public min_ground_suppression_thresh: number;
            public suppression_channel_id: number;
            public suppression_channel_name: string;
            public static encode(message: POGOProtos.Rpc.IMonodepthSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MonodepthSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MonodepthSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MonodepthSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMotivatedPokemonProto {
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            deploy_ms?: (number|Long|null);
            cp_when_deployed?: (number|null);
            motivation_now?: (number|null);
            cp_now?: (number|null);
            berry_value?: (number|null);
            feed_cooldown_duration_millis?: (number|Long|null);
            food_value?: (POGOProtos.Rpc.IFoodValue[]|null);
        }

        class MotivatedPokemonProto implements IMotivatedPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IMotivatedPokemonProto);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public deploy_ms: (number|Long);
            public cp_when_deployed: number;
            public motivation_now: number;
            public cp_now: number;
            public berry_value: number;
            public feed_cooldown_duration_millis: (number|Long);
            public food_value: POGOProtos.Rpc.IFoodValue[];
            public static encode(message: POGOProtos.Rpc.IMotivatedPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MotivatedPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MotivatedPokemonProto;
            public static toObject(message: POGOProtos.Rpc.MotivatedPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMoveModifierGroup {
            move_modifier?: (POGOProtos.Rpc.IMoveModifierProto[]|null);
        }

        class MoveModifierGroup implements IMoveModifierGroup {
            constructor(properties?: POGOProtos.Rpc.IMoveModifierGroup);
            public move_modifier: POGOProtos.Rpc.IMoveModifierProto[];
            public static encode(message: POGOProtos.Rpc.IMoveModifierGroup, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MoveModifierGroup;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MoveModifierGroup;
            public static toObject(message: POGOProtos.Rpc.MoveModifierGroup, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMoveModifierProto {
            mode?: (POGOProtos.Rpc.MoveModifierProto.MoveModifierMode|null);
            type?: (POGOProtos.Rpc.MoveModifierProto.MoveModifierType|null);
            value?: (number|null);
            condition?: (POGOProtos.Rpc.MoveModifierProto.IModifierCondition[]|null);
            render_modifier?: (POGOProtos.Rpc.IFormRenderModifier[]|null);
            duration?: (number|Long|null);
            string_value?: (string|null);
            best_effort?: (boolean|null);
            modifier_target?: (POGOProtos.Rpc.MoveModifierProto.MoveModifierTarget|null);
        }

        class MoveModifierProto implements IMoveModifierProto {
            constructor(properties?: POGOProtos.Rpc.IMoveModifierProto);
            public mode: POGOProtos.Rpc.MoveModifierProto.MoveModifierMode;
            public type: POGOProtos.Rpc.MoveModifierProto.MoveModifierType;
            public value: number;
            public condition: POGOProtos.Rpc.MoveModifierProto.IModifierCondition[];
            public render_modifier: POGOProtos.Rpc.IFormRenderModifier[];
            public duration: (number|Long);
            public string_value: string;
            public best_effort: boolean;
            public modifier_target: POGOProtos.Rpc.MoveModifierProto.MoveModifierTarget;
            public static encode(message: POGOProtos.Rpc.IMoveModifierProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MoveModifierProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MoveModifierProto;
            public static toObject(message: POGOProtos.Rpc.MoveModifierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MoveModifierProto {

            enum MoveModifierMode {
                UNSET_MOVE_MODIFIER_MODE = 0,
                FORM_CHANGE = 1,
                DIRECT_DAMAGE = 2,
                DEFENDER_DAMAGE_DEALT = 3,
                DEFENDER_DAMAGE_TAKEN = 4,
                ATTACKER_ARBITRARY_COUNTER = 5,
                ATTACKER_FORM_REVERSION = 6,
                DEFENDER_FORM_REVERSION = 7,
                DEFENDER_ARBITRARY_COUNTER = 8,
                APPLY_VS_EFFECT_TAG = 9,
                REMOVE_VS_EFFECT_TAG = 10,
                ATTACK_STAT_CHANGE = 11,
                DEFENSE_STAT_CHANGE = 12,
                STAMINA_STAT_CHANGE = 13,
                STAT_CHANGE = 14,
                GROUP_POINTER = 15
            }

            enum MoveModifierTarget {
                UNSET = 0,
                ATTACKER = 1,
                DEFENDER = 2
            }

            enum MoveModifierType {
                UNSET_MOVE_MODIFIER_TYPE = 0,
                PERCENTAGE = 1,
                FLAT_VALUE = 2
            }

            interface IModifierCondition {
                condition_type?: (POGOProtos.Rpc.MoveModifierProto.ModifierCondition.ConditionType|null);
                value?: (number|Long|null);
                deviation?: (number|null);
                string_lookup?: (string|null);
            }

            class ModifierCondition implements IModifierCondition {
                constructor(properties?: POGOProtos.Rpc.MoveModifierProto.IModifierCondition);
                public condition_type: POGOProtos.Rpc.MoveModifierProto.ModifierCondition.ConditionType;
                public value: (number|Long);
                public deviation: number;
                public string_lookup: string;
                public static encode(message: POGOProtos.Rpc.MoveModifierProto.IModifierCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MoveModifierProto.ModifierCondition;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MoveModifierProto.ModifierCondition;
                public static toObject(message: POGOProtos.Rpc.MoveModifierProto.ModifierCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ModifierCondition {

                enum ConditionType {
                    UNSET = 0,
                    PVE_NPC = 1,
                    HP_PERCENT = 2,
                    INVOCATION_LIMIT = 3,
                    COOLDOWN_MS = 4,
                    DEFENDER_ALIGNMENT_SHADOW = 5,
                    DEFENDER_VS_TAG = 6,
                    ATTACKER_ARBITRARY_COUNTER_MINIMUM = 7,
                    DEFENDER_ARBITRARY_COUNTER_MINIMUM = 8,
                    ATTACKER_VS_TAG = 9
                }
            }
        }

        interface IMoveReassignmentProto {
            existing_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            replacement_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
        }

        class MoveReassignmentProto implements IMoveReassignmentProto {
            constructor(properties?: POGOProtos.Rpc.IMoveReassignmentProto);
            public existing_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public replacement_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public static encode(message: POGOProtos.Rpc.IMoveReassignmentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MoveReassignmentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MoveReassignmentProto;
            public static toObject(message: POGOProtos.Rpc.MoveReassignmentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMoveSequenceSettingsProto {
            sequence?: (string[]|null);
        }

        class MoveSequenceSettingsProto implements IMoveSequenceSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMoveSequenceSettingsProto);
            public sequence: string[];
            public static encode(message: POGOProtos.Rpc.IMoveSequenceSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MoveSequenceSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MoveSequenceSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MoveSequenceSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMoveSettingsProto {
            unique_id?: (POGOProtos.Rpc.HoloPokemonMove|null);
            animation_id?: (number|null);
            pokemon_type?: (POGOProtos.Rpc.HoloPokemonType|null);
            power?: (number|null);
            accuracy_chance?: (number|null);
            critical_chance?: (number|null);
            heal_scalar?: (number|null);
            stamina_loss_scalar?: (number|null);
            trainer_level_min?: (number|null);
            trainer_level_max?: (number|null);
            vfx_name?: (string|null);
            duration_ms?: (number|null);
            damage_window_start_ms?: (number|null);
            damage_window_end_ms?: (number|null);
            energy_delta?: (number|null);
            is_locked?: (boolean|null);
            modifier?: (POGOProtos.Rpc.IMoveModifierProto[]|null);
            power_per_level?: (number[]|null);
        }

        class MoveSettingsProto implements IMoveSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMoveSettingsProto);
            public unique_id: POGOProtos.Rpc.HoloPokemonMove;
            public animation_id: number;
            public pokemon_type: POGOProtos.Rpc.HoloPokemonType;
            public power: number;
            public accuracy_chance: number;
            public critical_chance: number;
            public heal_scalar: number;
            public stamina_loss_scalar: number;
            public trainer_level_min: number;
            public trainer_level_max: number;
            public vfx_name: string;
            public duration_ms: number;
            public damage_window_start_ms: number;
            public damage_window_end_ms: number;
            public energy_delta: number;
            public is_locked: boolean;
            public modifier: POGOProtos.Rpc.IMoveModifierProto[];
            public power_per_level: number[];
            public static encode(message: POGOProtos.Rpc.IMoveSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MoveSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MoveSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MoveSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMpSharedSettingsProto {
            num_mp_from_walk_quest?: (number|null);
            num_meters_goal?: (number|null);
            debug_allow_remove_walk_quest?: (boolean|null);
            num_mp_from_loot_station?: (number|null);
            num_extra_mp_from_first_loot_station?: (number|null);
            debug_num_extra_loot_stations_per_day?: (number|null);
            debug_fixed_mp_walk_quest_cooldown_duration_ms?: (number|Long|null);
            mp_capacity?: (number|null);
            mp_base_daily_limit?: (number|null);
            bread_battle_catch_mp_cost?: (number|null);
            mp_claim_delay_ms?: (number|Long|null);
            mp_claim_particle_speed_multiplier?: (number|null);
            battle_mp_cost_per_tier?: (POGOProtos.Rpc.MpSharedSettingsProto.IBreadBattleMpCostPerTier[]|null);
            ftue_mp_capacity?: (number|null);
            post_battle_upgrade_by_sku?: (boolean|null);
        }

        class MpSharedSettingsProto implements IMpSharedSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMpSharedSettingsProto);
            public num_mp_from_walk_quest: number;
            public num_meters_goal: number;
            public debug_allow_remove_walk_quest: boolean;
            public num_mp_from_loot_station: number;
            public num_extra_mp_from_first_loot_station: number;
            public debug_num_extra_loot_stations_per_day: number;
            public debug_fixed_mp_walk_quest_cooldown_duration_ms: (number|Long);
            public mp_capacity: number;
            public mp_base_daily_limit: number;
            public bread_battle_catch_mp_cost: number;
            public mp_claim_delay_ms: (number|Long);
            public mp_claim_particle_speed_multiplier: number;
            public battle_mp_cost_per_tier: POGOProtos.Rpc.MpSharedSettingsProto.IBreadBattleMpCostPerTier[];
            public ftue_mp_capacity: number;
            public post_battle_upgrade_by_sku: boolean;
            public static encode(message: POGOProtos.Rpc.IMpSharedSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MpSharedSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MpSharedSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MpSharedSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace MpSharedSettingsProto {

            interface IBreadBattleMpCostPerTier {
                bread_battle_catch_mp_cost?: (number|null);
                battle_level?: (POGOProtos.Rpc.BreadBattleLevel|null);
                bread_battle_remote_catch_mp_cost?: (number|null);
            }

            class BreadBattleMpCostPerTier implements IBreadBattleMpCostPerTier {
                constructor(properties?: POGOProtos.Rpc.MpSharedSettingsProto.IBreadBattleMpCostPerTier);
                public bread_battle_catch_mp_cost: number;
                public battle_level: POGOProtos.Rpc.BreadBattleLevel;
                public bread_battle_remote_catch_mp_cost: number;
                public static encode(message: POGOProtos.Rpc.MpSharedSettingsProto.IBreadBattleMpCostPerTier, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MpSharedSettingsProto.BreadBattleMpCostPerTier;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MpSharedSettingsProto.BreadBattleMpCostPerTier;
                public static toObject(message: POGOProtos.Rpc.MpSharedSettingsProto.BreadBattleMpCostPerTier, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IMultiPartQuestProto {
            sub_quests?: (POGOProtos.Rpc.IQuestProto[]|null);
        }

        class MultiPartQuestProto implements IMultiPartQuestProto {
            constructor(properties?: POGOProtos.Rpc.IMultiPartQuestProto);
            public sub_quests: POGOProtos.Rpc.IQuestProto[];
            public static encode(message: POGOProtos.Rpc.IMultiPartQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MultiPartQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MultiPartQuestProto;
            public static toObject(message: POGOProtos.Rpc.MultiPartQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMultiSelectorProto {
            keys?: (string[]|null);
            next_steps?: (string[]|null);
        }

        class MultiSelectorProto implements IMultiSelectorProto {
            constructor(properties?: POGOProtos.Rpc.IMultiSelectorProto);
            public keys: string[];
            public next_steps: string[];
            public static encode(message: POGOProtos.Rpc.IMultiSelectorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MultiSelectorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MultiSelectorProto;
            public static toObject(message: POGOProtos.Rpc.MultiSelectorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IMusicSettingsProto {
            map_music_day_override?: (string|null);
            map_music_night_override?: (string|null);
            encounter_music_day_override?: (string|null);
            encounter_music_night_override?: (string|null);
            map_music_meloetta_buddy_override?: (string|null);
            start_times_enabled?: (boolean|null);
            encounter_raid_music_day_override?: (string|null);
            encounter_raid_music_night_override?: (string|null);
        }

        class MusicSettingsProto implements IMusicSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IMusicSettingsProto);
            public map_music_day_override: string;
            public map_music_night_override: string;
            public encounter_music_day_override: string;
            public encounter_music_night_override: string;
            public map_music_meloetta_buddy_override: string;
            public start_times_enabled: boolean;
            public encounter_raid_music_day_override: string;
            public encounter_raid_music_night_override: string;
            public static encode(message: POGOProtos.Rpc.IMusicSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.MusicSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.MusicSettingsProto;
            public static toObject(message: POGOProtos.Rpc.MusicSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAClientPlayerProto {
            player_id?: (string|null);
            creation_time_ms?: (number|Long|null);
            email?: (string|null);
            roles?: (POGOProtos.Rpc.NMARole[]|null);
            developer_keys?: (string[]|null);
            accounts?: (POGOProtos.Rpc.INMAThe8thWallAccountProto[]|null);
            onboarding_complete?: (POGOProtos.Rpc.NMAOnboardingCompletion[]|null);
        }

        class NMAClientPlayerProto implements INMAClientPlayerProto {
            constructor(properties?: POGOProtos.Rpc.INMAClientPlayerProto);
            public player_id: string;
            public creation_time_ms: (number|Long);
            public email: string;
            public roles: POGOProtos.Rpc.NMARole[];
            public developer_keys: string[];
            public accounts: POGOProtos.Rpc.INMAThe8thWallAccountProto[];
            public onboarding_complete: POGOProtos.Rpc.NMAOnboardingCompletion[];
            public static encode(message: POGOProtos.Rpc.INMAClientPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAClientPlayerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAClientPlayerProto;
            public static toObject(message: POGOProtos.Rpc.NMAClientPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAGetPlayerOutProto {
            status?: (POGOProtos.Rpc.NMAGetPlayerOutProto.Status|null);
            error_message?: (string|null);
            player?: (POGOProtos.Rpc.INMAClientPlayerProto|null);
            was_created?: (boolean|null);
            jwt?: (string|null);
        }

        class NMAGetPlayerOutProto implements INMAGetPlayerOutProto {
            constructor(properties?: POGOProtos.Rpc.INMAGetPlayerOutProto);
            public status: POGOProtos.Rpc.NMAGetPlayerOutProto.Status;
            public error_message: string;
            public player?: (POGOProtos.Rpc.INMAClientPlayerProto|null);
            public was_created: boolean;
            public jwt: string;
            public static encode(message: POGOProtos.Rpc.INMAGetPlayerOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAGetPlayerOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAGetPlayerOutProto;
            public static toObject(message: POGOProtos.Rpc.NMAGetPlayerOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMAGetPlayerOutProto {

            enum Status {
                UNKNOWN_STATUS = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface INMAGetPlayerProto {
            lightship_token?: (POGOProtos.Rpc.INMALightshipTokenProto|null);
            the8_th_wall_token?: (POGOProtos.Rpc.INMAThe8thWallTokenProto|null);
        }

        class NMAGetPlayerProto implements INMAGetPlayerProto {
            constructor(properties?: POGOProtos.Rpc.INMAGetPlayerProto);
            public lightship_token?: (POGOProtos.Rpc.INMALightshipTokenProto|null);
            public the8_th_wall_token?: (POGOProtos.Rpc.INMAThe8thWallTokenProto|null);
            public UserToken?: ("lightship_token"|"the8_th_wall_token");
            public static encode(message: POGOProtos.Rpc.INMAGetPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAGetPlayerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAGetPlayerProto;
            public static toObject(message: POGOProtos.Rpc.NMAGetPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAGetServerConfigOutProto {
            status?: (POGOProtos.Rpc.NMAGetServerConfigOutProto.Status|null);
            error_message?: (string|null);
            vps_url?: (string|null);
            use_legacy_scanning_system?: (boolean|null);
        }

        class NMAGetServerConfigOutProto implements INMAGetServerConfigOutProto {
            constructor(properties?: POGOProtos.Rpc.INMAGetServerConfigOutProto);
            public status: POGOProtos.Rpc.NMAGetServerConfigOutProto.Status;
            public error_message: string;
            public vps_url: string;
            public use_legacy_scanning_system: boolean;
            public static encode(message: POGOProtos.Rpc.INMAGetServerConfigOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAGetServerConfigOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAGetServerConfigOutProto;
            public static toObject(message: POGOProtos.Rpc.NMAGetServerConfigOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMAGetServerConfigOutProto {

            enum Status {
                UNKNOWN_STATUS = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface INMAGetServerConfigProto {
        }

        class NMAGetServerConfigProto implements INMAGetServerConfigProto {
            constructor(properties?: POGOProtos.Rpc.INMAGetServerConfigProto);
            public static encode(message: POGOProtos.Rpc.INMAGetServerConfigProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAGetServerConfigProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAGetServerConfigProto;
            public static toObject(message: POGOProtos.Rpc.NMAGetServerConfigProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAGetSurveyorProjectsOutProto {
            error_status?: (POGOProtos.Rpc.NMAGetSurveyorProjectsOutProto.ErrorStatus|null);
            error_msg?: (string|null);
            projects?: (POGOProtos.Rpc.INMASurveyorProjectProto[]|null);
        }

        class NMAGetSurveyorProjectsOutProto implements INMAGetSurveyorProjectsOutProto {
            constructor(properties?: POGOProtos.Rpc.INMAGetSurveyorProjectsOutProto);
            public error_status: POGOProtos.Rpc.NMAGetSurveyorProjectsOutProto.ErrorStatus;
            public error_msg: string;
            public projects: POGOProtos.Rpc.INMASurveyorProjectProto[];
            public static encode(message: POGOProtos.Rpc.INMAGetSurveyorProjectsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAGetSurveyorProjectsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAGetSurveyorProjectsOutProto;
            public static toObject(message: POGOProtos.Rpc.NMAGetSurveyorProjectsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMAGetSurveyorProjectsOutProto {

            enum ErrorStatus {
                UNDEFINED = 0,
                ERROR = 1,
                SUCCESS = 2
            }
        }

        interface INMAGetSurveyorProjectsProto {
        }

        class NMAGetSurveyorProjectsProto implements INMAGetSurveyorProjectsProto {
            constructor(properties?: POGOProtos.Rpc.INMAGetSurveyorProjectsProto);
            public static encode(message: POGOProtos.Rpc.INMAGetSurveyorProjectsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAGetSurveyorProjectsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAGetSurveyorProjectsProto;
            public static toObject(message: POGOProtos.Rpc.NMAGetSurveyorProjectsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMALightshipTokenProto {
            authorization_token?: (string|null);
            code_verifier?: (string|null);
        }

        class NMALightshipTokenProto implements INMALightshipTokenProto {
            constructor(properties?: POGOProtos.Rpc.INMALightshipTokenProto);
            public authorization_token: string;
            public code_verifier: string;
            public static encode(message: POGOProtos.Rpc.INMALightshipTokenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMALightshipTokenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMALightshipTokenProto;
            public static toObject(message: POGOProtos.Rpc.NMALightshipTokenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAProjectTaskProto {
            task_id?: (string|null);
            is_completed?: (boolean|null);
            task_type?: (POGOProtos.Rpc.NMAProjectTaskProto.TaskType|null);
            poi?: (POGOProtos.Rpc.INMASlimPoiProto|null);
        }

        class NMAProjectTaskProto implements INMAProjectTaskProto {
            constructor(properties?: POGOProtos.Rpc.INMAProjectTaskProto);
            public task_id: string;
            public is_completed: boolean;
            public task_type: POGOProtos.Rpc.NMAProjectTaskProto.TaskType;
            public poi?: (POGOProtos.Rpc.INMASlimPoiProto|null);
            public static encode(message: POGOProtos.Rpc.INMAProjectTaskProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAProjectTaskProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAProjectTaskProto;
            public static toObject(message: POGOProtos.Rpc.NMAProjectTaskProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMAProjectTaskProto {

            enum TaskType {
                UNDEFINED = 0,
                MAPPING = 1,
                VALIDATION = 2
            }
        }

        interface INMASlimPoiImageData {
            image_id?: (string|null);
            image_url?: (string|null);
        }

        class NMASlimPoiImageData implements INMASlimPoiImageData {
            constructor(properties?: POGOProtos.Rpc.INMASlimPoiImageData);
            public image_id: string;
            public image_url: string;
            public static encode(message: POGOProtos.Rpc.INMASlimPoiImageData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMASlimPoiImageData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMASlimPoiImageData;
            public static toObject(message: POGOProtos.Rpc.NMASlimPoiImageData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMASlimPoiProto {
            poi_id?: (string|null);
            title?: (string|null);
            images?: (POGOProtos.Rpc.INMASlimPoiImageData[]|null);
        }

        class NMASlimPoiProto implements INMASlimPoiProto {
            constructor(properties?: POGOProtos.Rpc.INMASlimPoiProto);
            public poi_id: string;
            public title: string;
            public images: POGOProtos.Rpc.INMASlimPoiImageData[];
            public static encode(message: POGOProtos.Rpc.INMASlimPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMASlimPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMASlimPoiProto;
            public static toObject(message: POGOProtos.Rpc.NMASlimPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMASurveyorProjectProto {
            project_id?: (string|null);
            project_name?: (string|null);
            status?: (POGOProtos.Rpc.NMASurveyorProjectProto.ProjectStatus|null);
            notes?: (string|null);
            estimated_completion_timestamp_ms?: (number|Long|null);
            tasks?: (POGOProtos.Rpc.INMAProjectTaskProto[]|null);
        }

        class NMASurveyorProjectProto implements INMASurveyorProjectProto {
            constructor(properties?: POGOProtos.Rpc.INMASurveyorProjectProto);
            public project_id: string;
            public project_name: string;
            public status: POGOProtos.Rpc.NMASurveyorProjectProto.ProjectStatus;
            public notes: string;
            public estimated_completion_timestamp_ms: (number|Long);
            public tasks: POGOProtos.Rpc.INMAProjectTaskProto[];
            public static encode(message: POGOProtos.Rpc.INMASurveyorProjectProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMASurveyorProjectProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMASurveyorProjectProto;
            public static toObject(message: POGOProtos.Rpc.NMASurveyorProjectProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMASurveyorProjectProto {

            enum ProjectStatus {
                UNDEFINED = 0,
                ACTIVE = 1,
                INACTIVE = 2
            }
        }

        interface INMAThe8thWallAccessTokenProto {
            uid?: (string|null);
            name?: (string|null);
            email?: (string|null);
            email_verified?: (boolean|null);
            metadata?: (POGOProtos.Rpc.INMAThe8thWallMetadataProto|null);
            disabled?: (boolean|null);
            accounts?: (POGOProtos.Rpc.INMAThe8thWallAccountProto[]|null);
        }

        class NMAThe8thWallAccessTokenProto implements INMAThe8thWallAccessTokenProto {
            constructor(properties?: POGOProtos.Rpc.INMAThe8thWallAccessTokenProto);
            public uid: string;
            public name: string;
            public email: string;
            public email_verified: boolean;
            public metadata?: (POGOProtos.Rpc.INMAThe8thWallMetadataProto|null);
            public disabled: boolean;
            public accounts: POGOProtos.Rpc.INMAThe8thWallAccountProto[];
            public static encode(message: POGOProtos.Rpc.INMAThe8thWallAccessTokenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAThe8thWallAccessTokenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAThe8thWallAccessTokenProto;
            public static toObject(message: POGOProtos.Rpc.NMAThe8thWallAccessTokenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAThe8thWallAccountProto {
            name?: (string|null);
            uid?: (string|null);
            status?: (string|null);
            account_type?: (string|null);
            violation_status?: (string|null);
        }

        class NMAThe8thWallAccountProto implements INMAThe8thWallAccountProto {
            constructor(properties?: POGOProtos.Rpc.INMAThe8thWallAccountProto);
            public name: string;
            public uid: string;
            public status: string;
            public account_type: string;
            public violation_status: string;
            public static encode(message: POGOProtos.Rpc.INMAThe8thWallAccountProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAThe8thWallAccountProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAThe8thWallAccountProto;
            public static toObject(message: POGOProtos.Rpc.NMAThe8thWallAccountProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAThe8thWallMetadataProto {
        }

        class NMAThe8thWallMetadataProto implements INMAThe8thWallMetadataProto {
            constructor(properties?: POGOProtos.Rpc.INMAThe8thWallMetadataProto);
            public static encode(message: POGOProtos.Rpc.INMAThe8thWallMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAThe8thWallMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAThe8thWallMetadataProto;
            public static toObject(message: POGOProtos.Rpc.NMAThe8thWallMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAThe8thWallTokenProto {
            authorization_token?: (string|null);
            code_verifier?: (string|null);
        }

        class NMAThe8thWallTokenProto implements INMAThe8thWallTokenProto {
            constructor(properties?: POGOProtos.Rpc.INMAThe8thWallTokenProto);
            public authorization_token: string;
            public code_verifier: string;
            public static encode(message: POGOProtos.Rpc.INMAThe8thWallTokenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAThe8thWallTokenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAThe8thWallTokenProto;
            public static toObject(message: POGOProtos.Rpc.NMAThe8thWallTokenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAUpdateSurveyorProjectOutProto {
            error_status?: (POGOProtos.Rpc.NMAUpdateSurveyorProjectOutProto.ErrorStatus|null);
            error_msg?: (string|null);
        }

        class NMAUpdateSurveyorProjectOutProto implements INMAUpdateSurveyorProjectOutProto {
            constructor(properties?: POGOProtos.Rpc.INMAUpdateSurveyorProjectOutProto);
            public error_status: POGOProtos.Rpc.NMAUpdateSurveyorProjectOutProto.ErrorStatus;
            public error_msg: string;
            public static encode(message: POGOProtos.Rpc.INMAUpdateSurveyorProjectOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAUpdateSurveyorProjectOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAUpdateSurveyorProjectOutProto;
            public static toObject(message: POGOProtos.Rpc.NMAUpdateSurveyorProjectOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMAUpdateSurveyorProjectOutProto {

            enum ErrorStatus {
                UNDEFINED = 0,
                ERROR = 1,
                SUCCESS = 2
            }
        }

        interface INMAUpdateSurveyorProjectProto {
            project_task_id?: (string|null);
            completed?: (boolean|null);
        }

        class NMAUpdateSurveyorProjectProto implements INMAUpdateSurveyorProjectProto {
            constructor(properties?: POGOProtos.Rpc.INMAUpdateSurveyorProjectProto);
            public project_task_id: string;
            public completed: boolean;
            public static encode(message: POGOProtos.Rpc.INMAUpdateSurveyorProjectProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAUpdateSurveyorProjectProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAUpdateSurveyorProjectProto;
            public static toObject(message: POGOProtos.Rpc.NMAUpdateSurveyorProjectProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INMAUpdateUserOnboardingOutProto {
            status?: (POGOProtos.Rpc.NMAUpdateUserOnboardingOutProto.Status|null);
            error_message?: (string|null);
            player?: (POGOProtos.Rpc.INMAClientPlayerProto|null);
        }

        class NMAUpdateUserOnboardingOutProto implements INMAUpdateUserOnboardingOutProto {
            constructor(properties?: POGOProtos.Rpc.INMAUpdateUserOnboardingOutProto);
            public status: POGOProtos.Rpc.NMAUpdateUserOnboardingOutProto.Status;
            public error_message: string;
            public player?: (POGOProtos.Rpc.INMAClientPlayerProto|null);
            public static encode(message: POGOProtos.Rpc.INMAUpdateUserOnboardingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAUpdateUserOnboardingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAUpdateUserOnboardingOutProto;
            public static toObject(message: POGOProtos.Rpc.NMAUpdateUserOnboardingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NMAUpdateUserOnboardingOutProto {

            enum Status {
                UNKNOWN_STATUS = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface INMAUpdateUserOnboardingProto {
            onboarding_complete?: (POGOProtos.Rpc.NMAOnboardingCompletion[]|null);
        }

        class NMAUpdateUserOnboardingProto implements INMAUpdateUserOnboardingProto {
            constructor(properties?: POGOProtos.Rpc.INMAUpdateUserOnboardingProto);
            public onboarding_complete: POGOProtos.Rpc.NMAOnboardingCompletion[];
            public static encode(message: POGOProtos.Rpc.INMAUpdateUserOnboardingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NMAUpdateUserOnboardingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NMAUpdateUserOnboardingProto;
            public static toObject(message: POGOProtos.Rpc.NMAUpdateUserOnboardingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INameSharingPreferencesProto {
            preference?: (POGOProtos.Rpc.NameSharingPreferencesProto.Preference|null);
            context?: (POGOProtos.Rpc.NameSharingPreferencesProto.Context|null);
        }

        class NameSharingPreferencesProto implements INameSharingPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.INameSharingPreferencesProto);
            public preference: POGOProtos.Rpc.NameSharingPreferencesProto.Preference;
            public context: POGOProtos.Rpc.NameSharingPreferencesProto.Context;
            public static encode(message: POGOProtos.Rpc.INameSharingPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NameSharingPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NameSharingPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.NameSharingPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NameSharingPreferencesProto {

            enum Context {
                DEFAULT = 0,
                EVENT_PLANNER_ATTENDANCE = 1
            }

            enum Preference {
                UNSET = 0,
                FRIENDS = 1,
                NO_ONE = 2,
                EVERYONE = 3
            }
        }

        interface INativeAdUnitSettingsProto {
            ios_ad_unit_id?: (string|null);
            android_ad_unit_id?: (string|null);
            other_ad_unit_id?: (string|null);
            ad_template_id?: (string|null);
        }

        class NativeAdUnitSettingsProto implements INativeAdUnitSettingsProto {
            constructor(properties?: POGOProtos.Rpc.INativeAdUnitSettingsProto);
            public ios_ad_unit_id: string;
            public android_ad_unit_id: string;
            public other_ad_unit_id: string;
            public ad_template_id: string;
            public static encode(message: POGOProtos.Rpc.INativeAdUnitSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NativeAdUnitSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NativeAdUnitSettingsProto;
            public static toObject(message: POGOProtos.Rpc.NativeAdUnitSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INearbyPokemonProto {
            pokedex_number?: (number|null);
            distance_meters?: (number|null);
            encounter_id?: (number|Long|null);
            fort_id?: (string|null);
            fort_image_url?: (string|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class NearbyPokemonProto implements INearbyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.INearbyPokemonProto);
            public pokedex_number: number;
            public distance_meters: number;
            public encounter_id: (number|Long);
            public fort_id: string;
            public fort_image_url: string;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.INearbyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NearbyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NearbyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.NearbyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INearbyPokemonSettings {
            ob_enabled?: (boolean|null);
            ob_bool?: (boolean|null);
            pokemon_priorities?: (POGOProtos.Rpc.NearbyPokemonSettings.IPokemonPriority[]|null);
        }

        class NearbyPokemonSettings implements INearbyPokemonSettings {
            constructor(properties?: POGOProtos.Rpc.INearbyPokemonSettings);
            public ob_enabled: boolean;
            public ob_bool: boolean;
            public pokemon_priorities: POGOProtos.Rpc.NearbyPokemonSettings.IPokemonPriority[];
            public static encode(message: POGOProtos.Rpc.INearbyPokemonSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NearbyPokemonSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NearbyPokemonSettings;
            public static toObject(message: POGOProtos.Rpc.NearbyPokemonSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NearbyPokemonSettings {

            interface IPokemonPriority {
                pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
                form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
                costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
                priority?: (number|null);
                max_duplicates?: (number|null);
            }

            class PokemonPriority implements IPokemonPriority {
                constructor(properties?: POGOProtos.Rpc.NearbyPokemonSettings.IPokemonPriority);
                public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
                public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
                public costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
                public priority: number;
                public max_duplicates: number;
                public static encode(message: POGOProtos.Rpc.NearbyPokemonSettings.IPokemonPriority, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NearbyPokemonSettings.PokemonPriority;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NearbyPokemonSettings.PokemonPriority;
                public static toObject(message: POGOProtos.Rpc.NearbyPokemonSettings.PokemonPriority, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface INetworkTelemetry {
            network_type?: (string|null);
        }

        class NetworkTelemetry implements INetworkTelemetry {
            constructor(properties?: POGOProtos.Rpc.INetworkTelemetry);
            public network_type: string;
            public static encode(message: POGOProtos.Rpc.INetworkTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NetworkTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NetworkTelemetry;
            public static toObject(message: POGOProtos.Rpc.NetworkTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarBadgeRewardOutProto {
            result?: (POGOProtos.Rpc.NeutralAvatarBadgeRewardOutProto.Result|null);
            avatar_customization_proto?: (POGOProtos.Rpc.IAvatarCustomizationProto[]|null);
            avatar_badge_display?: (POGOProtos.Rpc.IAvatarItemBadgeRewardDisplayProto[]|null);
        }

        class NeutralAvatarBadgeRewardOutProto implements INeutralAvatarBadgeRewardOutProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarBadgeRewardOutProto);
            public result: POGOProtos.Rpc.NeutralAvatarBadgeRewardOutProto.Result;
            public avatar_customization_proto: POGOProtos.Rpc.IAvatarCustomizationProto[];
            public avatar_badge_display: POGOProtos.Rpc.IAvatarItemBadgeRewardDisplayProto[];
            public static encode(message: POGOProtos.Rpc.INeutralAvatarBadgeRewardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarBadgeRewardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarBadgeRewardOutProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarBadgeRewardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NeutralAvatarBadgeRewardOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface INeutralAvatarBadgeRewardProto {
        }

        class NeutralAvatarBadgeRewardProto implements INeutralAvatarBadgeRewardProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarBadgeRewardProto);
            public static encode(message: POGOProtos.Rpc.INeutralAvatarBadgeRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarBadgeRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarBadgeRewardProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarBadgeRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarBodySliderSettingsTemplateProto {
            size_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            muscle_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            hips_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            shoulders_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            bust_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
        }

        class NeutralAvatarBodySliderSettingsTemplateProto implements INeutralAvatarBodySliderSettingsTemplateProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarBodySliderSettingsTemplateProto);
            public size_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            public muscle_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            public hips_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            public shoulders_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            public bust_slider?: (POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto|null);
            public static encode(message: POGOProtos.Rpc.INeutralAvatarBodySliderSettingsTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarBodySliderSettingsTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarBodySliderSettingsTemplateProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarBodySliderSettingsTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarBodySliderTemplateProto {
            max_bounds?: (number|null);
            min_bounds?: (number|null);
        }

        class NeutralAvatarBodySliderTemplateProto implements INeutralAvatarBodySliderTemplateProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto);
            public max_bounds: number;
            public min_bounds: number;
            public static encode(message: POGOProtos.Rpc.INeutralAvatarBodySliderTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarBodySliderTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarBodySliderTemplateProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarBodySliderTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarItemMappingProto {
            purchased_item_display_id?: (string|null);
            reward_item_display_id?: (string|null);
        }

        class NeutralAvatarItemMappingProto implements INeutralAvatarItemMappingProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarItemMappingProto);
            public purchased_item_display_id: string;
            public reward_item_display_id: string;
            public static encode(message: POGOProtos.Rpc.INeutralAvatarItemMappingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarItemMappingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarItemMappingProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarItemMappingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarItemProto {
            neutral_avatar_article_template_id?: (string|null);
            gained_ms?: (number|Long|null);
        }

        class NeutralAvatarItemProto implements INeutralAvatarItemProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarItemProto);
            public neutral_avatar_article_template_id: string;
            public gained_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.INeutralAvatarItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarItemProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarLootItemDisplayProto {
            display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            link?: (POGOProtos.Rpc.IAvatarStoreLinkProto|null);
        }

        class NeutralAvatarLootItemDisplayProto implements INeutralAvatarLootItemDisplayProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarLootItemDisplayProto);
            public display?: (POGOProtos.Rpc.IAvatarItemDisplayProto|null);
            public link?: (POGOProtos.Rpc.IAvatarStoreLinkProto|null);
            public static encode(message: POGOProtos.Rpc.INeutralAvatarLootItemDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarLootItemDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarLootItemDisplayProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarLootItemDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarLootItemTemplateProto {
            item_template_id?: (string|null);
            display_template_id?: (string|null);
        }

        class NeutralAvatarLootItemTemplateProto implements INeutralAvatarLootItemTemplateProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto);
            public item_template_id: string;
            public display_template_id: string;
            public static encode(message: POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarLootItemTemplateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarLootItemTemplateProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarLootItemTemplateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarMappingProto {
            item_unique_key?: (string|null);
            neutral_item_template_id?: (string|null);
        }

        class NeutralAvatarMappingProto implements INeutralAvatarMappingProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarMappingProto);
            public item_unique_key: string;
            public neutral_item_template_id: string;
            public static encode(message: POGOProtos.Rpc.INeutralAvatarMappingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarMappingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarMappingProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarMappingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INeutralAvatarSettingsProto {
            neutral_avatar_settings_enabled?: (boolean|null);
            neutral_avatar_settings_sentinel_value?: (number|null);
            default_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            female_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            male_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            body_slider_settings?: (POGOProtos.Rpc.INeutralAvatarBodySliderSettingsTemplateProto|null);
            neutral_avatar_legacy_mapping_version?: (number|null);
            enable_gradient_conversion_suppression?: (boolean|null);
            appearance_monetization_enabled?: (boolean|null);
            bottom_sheet_test_b?: (boolean|null);
            bottom_sheet_test_c?: (boolean|null);
            owned_article_filtering_enabled?: (boolean|null);
            item_grouping_enabled?: (boolean|null);
        }

        class NeutralAvatarSettingsProto implements INeutralAvatarSettingsProto {
            constructor(properties?: POGOProtos.Rpc.INeutralAvatarSettingsProto);
            public neutral_avatar_settings_enabled: boolean;
            public neutral_avatar_settings_sentinel_value: number;
            public default_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public female_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public male_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public body_slider_settings?: (POGOProtos.Rpc.INeutralAvatarBodySliderSettingsTemplateProto|null);
            public neutral_avatar_legacy_mapping_version: number;
            public enable_gradient_conversion_suppression: boolean;
            public appearance_monetization_enabled: boolean;
            public bottom_sheet_test_b: boolean;
            public bottom_sheet_test_c: boolean;
            public owned_article_filtering_enabled: boolean;
            public item_grouping_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.INeutralAvatarSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NeutralAvatarSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NeutralAvatarSettingsProto;
            public static toObject(message: POGOProtos.Rpc.NeutralAvatarSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewInboxMessage {
        }

        class NewInboxMessage implements INewInboxMessage {
            constructor(properties?: POGOProtos.Rpc.INewInboxMessage);
            public static encode(message: POGOProtos.Rpc.INewInboxMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewInboxMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewInboxMessage;
            public static toObject(message: POGOProtos.Rpc.NewInboxMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsArticleProto {
            id?: (string|null);
            image_url?: (string[]|null);
            header_key?: (string|null);
            subheader_key?: (string|null);
            main_text_key?: (string|null);
            timestamp?: (number|Long|null);
            template?: (POGOProtos.Rpc.NewsArticleProto.NewsTemplate|null);
            enabled?: (boolean|null);
            article_read?: (boolean|null);
        }

        class NewsArticleProto implements INewsArticleProto {
            constructor(properties?: POGOProtos.Rpc.INewsArticleProto);
            public id: string;
            public image_url: string[];
            public header_key: string;
            public subheader_key: string;
            public main_text_key: string;
            public timestamp: (number|Long);
            public template: POGOProtos.Rpc.NewsArticleProto.NewsTemplate;
            public enabled: boolean;
            public article_read: boolean;
            public static encode(message: POGOProtos.Rpc.INewsArticleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsArticleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsArticleProto;
            public static toObject(message: POGOProtos.Rpc.NewsArticleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NewsArticleProto {

            enum NewsTemplate {
                UNSET = 0,
                DEFAULT_TEMPLATE = 1
            }
        }

        interface INewsGlobalSettingsProto {
            enable_news?: (boolean|null);
        }

        class NewsGlobalSettingsProto implements INewsGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.INewsGlobalSettingsProto);
            public enable_news: boolean;
            public static encode(message: POGOProtos.Rpc.INewsGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.NewsGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsPageTelemetry {
            news_page_click_id?: (POGOProtos.Rpc.NewsPageTelemetryIds|null);
        }

        class NewsPageTelemetry implements INewsPageTelemetry {
            constructor(properties?: POGOProtos.Rpc.INewsPageTelemetry);
            public news_page_click_id: POGOProtos.Rpc.NewsPageTelemetryIds;
            public static encode(message: POGOProtos.Rpc.INewsPageTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsPageTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsPageTelemetry;
            public static toObject(message: POGOProtos.Rpc.NewsPageTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsProto {
            news_bundle_id?: (string|null);
            exclusive_countries?: (string[]|null);
        }

        class NewsProto implements INewsProto {
            constructor(properties?: POGOProtos.Rpc.INewsProto);
            public news_bundle_id: string;
            public exclusive_countries: string[];
            public static encode(message: POGOProtos.Rpc.INewsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsProto;
            public static toObject(message: POGOProtos.Rpc.NewsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsSettingProto {
            news_protos?: (POGOProtos.Rpc.INewsProto[]|null);
        }

        class NewsSettingProto implements INewsSettingProto {
            constructor(properties?: POGOProtos.Rpc.INewsSettingProto);
            public news_protos: POGOProtos.Rpc.INewsProto[];
            public static encode(message: POGOProtos.Rpc.INewsSettingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsSettingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsSettingProto;
            public static toObject(message: POGOProtos.Rpc.NewsSettingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsfeedMetadata {
            created_time_ms?: (number|Long|null);
            expired_time_ms?: (number|Long|null);
            send_to_player_in_local_tz?: (boolean|null);
            start_date_time?: (POGOProtos.Rpc.ILocalDateTimeProto|null);
            end_date_time?: (POGOProtos.Rpc.ILocalDateTimeProto|null);
        }

        class NewsfeedMetadata implements INewsfeedMetadata {
            constructor(properties?: POGOProtos.Rpc.INewsfeedMetadata);
            public created_time_ms: (number|Long);
            public expired_time_ms: (number|Long);
            public send_to_player_in_local_tz: boolean;
            public start_date_time?: (POGOProtos.Rpc.ILocalDateTimeProto|null);
            public end_date_time?: (POGOProtos.Rpc.ILocalDateTimeProto|null);
            public static encode(message: POGOProtos.Rpc.INewsfeedMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsfeedMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsfeedMetadata;
            public static toObject(message: POGOProtos.Rpc.NewsfeedMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsfeedPost {
            title?: (string|null);
            preview_text?: (string|null);
            thumbnail_image_url?: (string|null);
            newsfeed_channel?: (POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel[]|null);
            post_content?: (string|null);
            newsfeed_metadata?: (POGOProtos.Rpc.INewsfeedMetadata|null);
            key_value_pairs?: ({ [k: string]: string }|null);
            config_name?: (string|null);
            priority_flag?: (boolean|null);
            read_flag?: (boolean|null);
            preview_metadata?: (POGOProtos.Rpc.NewsfeedPost.IPreviewMetadata|null);
        }

        class NewsfeedPost implements INewsfeedPost {
            constructor(properties?: POGOProtos.Rpc.INewsfeedPost);
            public title: string;
            public preview_text: string;
            public thumbnail_image_url: string;
            public newsfeed_channel: POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel[];
            public post_content: string;
            public newsfeed_metadata?: (POGOProtos.Rpc.INewsfeedMetadata|null);
            public key_value_pairs: { [k: string]: string };
            public config_name: string;
            public priority_flag: boolean;
            public read_flag: boolean;
            public preview_metadata?: (POGOProtos.Rpc.NewsfeedPost.IPreviewMetadata|null);
            public static encode(message: POGOProtos.Rpc.INewsfeedPost, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsfeedPost;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsfeedPost;
            public static toObject(message: POGOProtos.Rpc.NewsfeedPost, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NewsfeedPost {

            enum NewsfeedChannel {
                NOT_DEFINED = 0,
                NEWSFEED_MESSAGE_CHANNEL = 1,
                IN_APP_MESSAGE_CHANNEL = 2
            }

            interface IPreviewMetadata {
                attributes?: ({ [k: string]: string }|null);
                player_hashed_id?: (string|null);
                rendered_title?: (string|null);
                rendered_preview_text?: (string|null);
                rendered_post_content?: (string|null);
            }

            class PreviewMetadata implements IPreviewMetadata {
                constructor(properties?: POGOProtos.Rpc.NewsfeedPost.IPreviewMetadata);
                public attributes: { [k: string]: string };
                public player_hashed_id: string;
                public rendered_title: string;
                public rendered_preview_text: string;
                public rendered_post_content: string;
                public static encode(message: POGOProtos.Rpc.NewsfeedPost.IPreviewMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsfeedPost.PreviewMetadata;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsfeedPost.PreviewMetadata;
                public static toObject(message: POGOProtos.Rpc.NewsfeedPost.PreviewMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface INewsfeedPostRecord {
            newsfeed_post?: (POGOProtos.Rpc.INewsfeedPost|null);
            newsfeed_post_id?: (string|null);
            newsfeed_post_campaign_id?: (number|Long|null);
        }

        class NewsfeedPostRecord implements INewsfeedPostRecord {
            constructor(properties?: POGOProtos.Rpc.INewsfeedPostRecord);
            public newsfeed_post?: (POGOProtos.Rpc.INewsfeedPost|null);
            public newsfeed_post_id: string;
            public newsfeed_post_campaign_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.INewsfeedPostRecord, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsfeedPostRecord;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsfeedPostRecord;
            public static toObject(message: POGOProtos.Rpc.NewsfeedPostRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsfeedSource {
            campaign_id?: (number|Long|null);
            channel?: (POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel|null);
            language?: (string|null);
        }

        class NewsfeedSource implements INewsfeedSource {
            constructor(properties?: POGOProtos.Rpc.INewsfeedSource);
            public campaign_id: (number|Long);
            public channel: POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel;
            public language: string;
            public static encode(message: POGOProtos.Rpc.INewsfeedSource, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsfeedSource;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsfeedSource;
            public static toObject(message: POGOProtos.Rpc.NewsfeedSource, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INewsfeedTrackingRecordsMetadata {
            environment_id?: (string|null);
            campaign_id?: (number|Long|null);
        }

        class NewsfeedTrackingRecordsMetadata implements INewsfeedTrackingRecordsMetadata {
            constructor(properties?: POGOProtos.Rpc.INewsfeedTrackingRecordsMetadata);
            public environment_id: string;
            public campaign_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.INewsfeedTrackingRecordsMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NewsfeedTrackingRecordsMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NewsfeedTrackingRecordsMetadata;
            public static toObject(message: POGOProtos.Rpc.NewsfeedTrackingRecordsMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INiaAny {
            type_url?: (string|null);
            value?: (Uint8Array|null);
        }

        class NiaAny implements INiaAny {
            constructor(properties?: POGOProtos.Rpc.INiaAny);
            public type_url: string;
            public value: Uint8Array;
            public static encode(message: POGOProtos.Rpc.INiaAny, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NiaAny;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NiaAny;
            public static toObject(message: POGOProtos.Rpc.NiaAny, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INiaAuthAuthenticateAppleSignInRequestProto {
            apple_id_token?: (Uint8Array|null);
            auth_code?: (Uint8Array|null);
        }

        class NiaAuthAuthenticateAppleSignInRequestProto implements INiaAuthAuthenticateAppleSignInRequestProto {
            constructor(properties?: POGOProtos.Rpc.INiaAuthAuthenticateAppleSignInRequestProto);
            public apple_id_token: Uint8Array;
            public auth_code: Uint8Array;
            public static encode(message: POGOProtos.Rpc.INiaAuthAuthenticateAppleSignInRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInRequestProto;
            public static toObject(message: POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INiaAuthAuthenticateAppleSignInResponseProto {
            status?: (POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInResponseProto.Status|null);
            nia_apple_auth_token?: (Uint8Array|null);
        }

        class NiaAuthAuthenticateAppleSignInResponseProto implements INiaAuthAuthenticateAppleSignInResponseProto {
            constructor(properties?: POGOProtos.Rpc.INiaAuthAuthenticateAppleSignInResponseProto);
            public status: POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInResponseProto.Status;
            public nia_apple_auth_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.INiaAuthAuthenticateAppleSignInResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInResponseProto;
            public static toObject(message: POGOProtos.Rpc.NiaAuthAuthenticateAppleSignInResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NiaAuthAuthenticateAppleSignInResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_AUTH = 2,
                SERVER_ERROR = 3
            }
        }

        interface INiaAuthValidateNiaAppleAuthTokenRequestProto {
            nia_apple_auth_token?: (Uint8Array|null);
        }

        class NiaAuthValidateNiaAppleAuthTokenRequestProto implements INiaAuthValidateNiaAppleAuthTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.INiaAuthValidateNiaAppleAuthTokenRequestProto);
            public nia_apple_auth_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.INiaAuthValidateNiaAppleAuthTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INiaAuthValidateNiaAppleAuthTokenResponseProto {
            status?: (POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenResponseProto.Status|null);
            apple_user_id?: (string|null);
            apple_email?: (string|null);
            apple_client_id?: (string|null);
        }

        class NiaAuthValidateNiaAppleAuthTokenResponseProto implements INiaAuthValidateNiaAppleAuthTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.INiaAuthValidateNiaAppleAuthTokenResponseProto);
            public status: POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenResponseProto.Status;
            public apple_user_id: string;
            public apple_email: string;
            public apple_client_id: string;
            public static encode(message: POGOProtos.Rpc.INiaAuthValidateNiaAppleAuthTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.NiaAuthValidateNiaAppleAuthTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NiaAuthValidateNiaAppleAuthTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_AUTH = 2,
                EXPIRED_AUTH = 3,
                SERVER_ERROR = 4
            }
        }

        interface INiaIdMigrationSettingsProto {
            use_nia_account_id?: (boolean|null);
        }

        class NiaIdMigrationSettingsProto implements INiaIdMigrationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.INiaIdMigrationSettingsProto);
            public use_nia_account_id: boolean;
            public static encode(message: POGOProtos.Rpc.INiaIdMigrationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NiaIdMigrationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NiaIdMigrationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.NiaIdMigrationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INianticProfileTelemetry {
            niantic_profile_telemetry_id?: (POGOProtos.Rpc.NianticProfileTelemetry.NianticProfileTelemetryIds|null);
        }

        class NianticProfileTelemetry implements INianticProfileTelemetry {
            constructor(properties?: POGOProtos.Rpc.INianticProfileTelemetry);
            public niantic_profile_telemetry_id: POGOProtos.Rpc.NianticProfileTelemetry.NianticProfileTelemetryIds;
            public static encode(message: POGOProtos.Rpc.INianticProfileTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticProfileTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticProfileTelemetry;
            public static toObject(message: POGOProtos.Rpc.NianticProfileTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NianticProfileTelemetry {

            enum NianticProfileTelemetryIds {
                UNDEFINED = 0,
                OPEN_MY_PROFILE = 1,
                OPEN_FRIEND_PROFILE = 2
            }
        }

        interface INianticSharedLoginProto {
            token?: (Uint8Array|null);
            device_id?: (string|null);
        }

        class NianticSharedLoginProto implements INianticSharedLoginProto {
            constructor(properties?: POGOProtos.Rpc.INianticSharedLoginProto);
            public token: Uint8Array;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.INianticSharedLoginProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticSharedLoginProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticSharedLoginProto;
            public static toObject(message: POGOProtos.Rpc.NianticSharedLoginProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INianticThirdPartyAuthProtobufRequest {
            provider_token?: (Uint8Array|null);
            auth_provider_id?: (string|null);
            audience?: (string|null);
            app_key?: (string|null);
            should_create?: (boolean|null);
            client_id?: (string|null);
        }

        class NianticThirdPartyAuthProtobufRequest implements INianticThirdPartyAuthProtobufRequest {
            constructor(properties?: POGOProtos.Rpc.INianticThirdPartyAuthProtobufRequest);
            public provider_token: Uint8Array;
            public auth_provider_id: string;
            public audience: string;
            public app_key: string;
            public should_create: boolean;
            public client_id: string;
            public static encode(message: POGOProtos.Rpc.INianticThirdPartyAuthProtobufRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticThirdPartyAuthProtobufRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticThirdPartyAuthProtobufRequest;
            public static toObject(message: POGOProtos.Rpc.NianticThirdPartyAuthProtobufRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INianticThirdPartyAuthProtobufResponse {
            niantic_token?: (string|null);
            niantic_refresh_token?: (string|null);
        }

        class NianticThirdPartyAuthProtobufResponse implements INianticThirdPartyAuthProtobufResponse {
            constructor(properties?: POGOProtos.Rpc.INianticThirdPartyAuthProtobufResponse);
            public niantic_token: string;
            public niantic_refresh_token: string;
            public static encode(message: POGOProtos.Rpc.INianticThirdPartyAuthProtobufResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticThirdPartyAuthProtobufResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticThirdPartyAuthProtobufResponse;
            public static toObject(message: POGOProtos.Rpc.NianticThirdPartyAuthProtobufResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INianticToken {
            token?: (Uint8Array|null);
            token_v2?: (Uint8Array|null);
            expiration_time?: (number|Long|null);
            iv?: (Uint8Array|null);
        }

        class NianticToken implements INianticToken {
            constructor(properties?: POGOProtos.Rpc.INianticToken);
            public token: Uint8Array;
            public token_v2: Uint8Array;
            public expiration_time: (number|Long);
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.INianticToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticToken;
            public static toObject(message: POGOProtos.Rpc.NianticToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INianticTokenRequest {
            auth_id?: (string|null);
            inner_message?: (Uint8Array|null);
            options?: (POGOProtos.Rpc.NianticTokenRequest.ISessionOptions|null);
        }

        class NianticTokenRequest implements INianticTokenRequest {
            constructor(properties?: POGOProtos.Rpc.INianticTokenRequest);
            public auth_id: string;
            public inner_message: Uint8Array;
            public options?: (POGOProtos.Rpc.NianticTokenRequest.ISessionOptions|null);
            public static encode(message: POGOProtos.Rpc.INianticTokenRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticTokenRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticTokenRequest;
            public static toObject(message: POGOProtos.Rpc.NianticTokenRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NianticTokenRequest {

            interface ISessionOptions {
                prevent_account_creation?: (boolean|null);
            }

            class SessionOptions implements ISessionOptions {
                constructor(properties?: POGOProtos.Rpc.NianticTokenRequest.ISessionOptions);
                public prevent_account_creation: boolean;
                public static encode(message: POGOProtos.Rpc.NianticTokenRequest.ISessionOptions, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NianticTokenRequest.SessionOptions;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NianticTokenRequest.SessionOptions;
                public static toObject(message: POGOProtos.Rpc.NianticTokenRequest.SessionOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface INicknamePokemonOutProto {
            result?: (POGOProtos.Rpc.NicknamePokemonOutProto.Result|null);
        }

        class NicknamePokemonOutProto implements INicknamePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.INicknamePokemonOutProto);
            public result: POGOProtos.Rpc.NicknamePokemonOutProto.Result;
            public static encode(message: POGOProtos.Rpc.INicknamePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NicknamePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NicknamePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.NicknamePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NicknamePokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_NICKNAME = 2,
                ERROR_POKEMON_NOT_FOUND = 3,
                ERROR_POKEMON_IS_EGG = 4,
                ERROR_FILTERED_NICKNAME = 5,
                ERROR_EXCEEDED_CHANGE_LIMIT = 6
            }
        }

        interface INicknamePokemonProto {
            pokemon_id?: (number|Long|null);
            nickname?: (string|null);
        }

        class NicknamePokemonProto implements INicknamePokemonProto {
            constructor(properties?: POGOProtos.Rpc.INicknamePokemonProto);
            public pokemon_id: (number|Long);
            public nickname: string;
            public static encode(message: POGOProtos.Rpc.INicknamePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NicknamePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NicknamePokemonProto;
            public static toObject(message: POGOProtos.Rpc.NicknamePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INicknamePokemonTelemetry {
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            nickname?: (string|null);
        }

        class NicknamePokemonTelemetry implements INicknamePokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.INicknamePokemonTelemetry);
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public nickname: string;
            public static encode(message: POGOProtos.Rpc.INicknamePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NicknamePokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NicknamePokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.NicknamePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INodeAssociation {
            identifier?: (POGOProtos.Rpc.IUUID|null);
            managed_pose_to_node?: (POGOProtos.Rpc.ITransform|null);
            weight?: (number|null);
            placement_accuracy?: (POGOProtos.Rpc.IPlacementAccuracy|null);
        }

        class NodeAssociation implements INodeAssociation {
            constructor(properties?: POGOProtos.Rpc.INodeAssociation);
            public identifier?: (POGOProtos.Rpc.IUUID|null);
            public managed_pose_to_node?: (POGOProtos.Rpc.ITransform|null);
            public weight: number;
            public placement_accuracy?: (POGOProtos.Rpc.IPlacementAccuracy|null);
            public static encode(message: POGOProtos.Rpc.INodeAssociation, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NodeAssociation;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NodeAssociation;
            public static toObject(message: POGOProtos.Rpc.NodeAssociation, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INodeId {
            lower?: (number|Long|null);
            upper?: (number|Long|null);
        }

        class NodeId implements INodeId {
            constructor(properties?: POGOProtos.Rpc.INodeId);
            public lower: (number|Long);
            public upper: (number|Long);
            public static encode(message: POGOProtos.Rpc.INodeId, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NodeId;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NodeId;
            public static toObject(message: POGOProtos.Rpc.NodeId, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INonCombatMoveSettingsProto {
            unique_id?: (POGOProtos.Rpc.HoloPokemonMove|null);
            cost?: (POGOProtos.Rpc.ICostSettingsProto|null);
            bonus_effect?: (POGOProtos.Rpc.IBonusEffectSettingsProto|null);
            duration_ms?: (number|Long|null);
            bonus_type?: (POGOProtos.Rpc.PlayerBonusType|null);
            enable_multi_use?: (boolean|null);
            extra_duration_ms?: (number|Long|null);
            enable_non_combat_move?: (boolean|null);
        }

        class NonCombatMoveSettingsProto implements INonCombatMoveSettingsProto {
            constructor(properties?: POGOProtos.Rpc.INonCombatMoveSettingsProto);
            public unique_id: POGOProtos.Rpc.HoloPokemonMove;
            public cost?: (POGOProtos.Rpc.ICostSettingsProto|null);
            public bonus_effect?: (POGOProtos.Rpc.IBonusEffectSettingsProto|null);
            public duration_ms: (number|Long);
            public bonus_type: POGOProtos.Rpc.PlayerBonusType;
            public enable_multi_use: boolean;
            public extra_duration_ms: (number|Long);
            public enable_non_combat_move: boolean;
            public static encode(message: POGOProtos.Rpc.INonCombatMoveSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NonCombatMoveSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NonCombatMoveSettingsProto;
            public static toObject(message: POGOProtos.Rpc.NonCombatMoveSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INotificationPermissionsTelemetry {
            system_settings_enabled?: (boolean|null);
            events_offers_updates_email_enabled?: (boolean|null);
            combine_research_updates_in_app_enabled?: (boolean|null);
            nearby_raids_in_app_enabled?: (boolean|null);
            pokemon_return_in_app_enabled?: (boolean|null);
            opened_gift_in_app_enabled?: (boolean|null);
            gift_received_in_app_enabled?: (boolean|null);
            buddy_candies_in_app_enabled?: (boolean|null);
        }

        class NotificationPermissionsTelemetry implements INotificationPermissionsTelemetry {
            constructor(properties?: POGOProtos.Rpc.INotificationPermissionsTelemetry);
            public system_settings_enabled: boolean;
            public events_offers_updates_email_enabled: boolean;
            public combine_research_updates_in_app_enabled: boolean;
            public nearby_raids_in_app_enabled: boolean;
            public pokemon_return_in_app_enabled: boolean;
            public opened_gift_in_app_enabled: boolean;
            public gift_received_in_app_enabled: boolean;
            public buddy_candies_in_app_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.INotificationPermissionsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NotificationPermissionsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NotificationPermissionsTelemetry;
            public static toObject(message: POGOProtos.Rpc.NotificationPermissionsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INotificationSettingsProto {
            pull_notifications?: (boolean|null);
            show_notifications?: (boolean|null);
            prompt_enable_push_notifications_interval_seconds?: (number|null);
            prompt_enable_push_notifications_image_url?: (string|null);
        }

        class NotificationSettingsProto implements INotificationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.INotificationSettingsProto);
            public pull_notifications: boolean;
            public show_notifications: boolean;
            public prompt_enable_push_notifications_interval_seconds: number;
            public prompt_enable_push_notifications_image_url: string;
            public static encode(message: POGOProtos.Rpc.INotificationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NotificationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NotificationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.NotificationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INpcBattle {
        }

        class NpcBattle implements INpcBattle {
            constructor(properties?: POGOProtos.Rpc.INpcBattle);
            public static encode(message: POGOProtos.Rpc.INpcBattle, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcBattle;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcBattle;
            public static toObject(message: POGOProtos.Rpc.NpcBattle, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcBattle {

            enum Character {
                CHARACTER_UNSET = 0,
                CHARACTER_GRUNT_MALE = 1,
                CHARACTER_GRUNT_FEMALE = 2,
                CHARACTER_ARLO = 3,
                CHARACTER_CLIFF = 4,
                CHARACTER_SIERRA = 5,
                CHARACTER_GIOVANNI = 6,
                CHARACTER_JESSIE = 7,
                CHARACTER_JAMES = 8,
                CHARACTER_BLANCHE = 9,
                CHARACTER_CANDELA = 10,
                CHARACTER_SPARK = 11
            }
        }

        interface INpcEncounterProto {
            encounter_id?: (string|null);
            character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
            steps?: (POGOProtos.Rpc.NpcEncounterProto.INpcEncounterStep[]|null);
            current_step?: (string|null);
            map_character?: (POGOProtos.Rpc.QuestDialogProto.Character|null);
        }

        class NpcEncounterProto implements INpcEncounterProto {
            constructor(properties?: POGOProtos.Rpc.INpcEncounterProto);
            public encounter_id: string;
            public character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public steps: POGOProtos.Rpc.NpcEncounterProto.INpcEncounterStep[];
            public current_step: string;
            public map_character: POGOProtos.Rpc.QuestDialogProto.Character;
            public static encode(message: POGOProtos.Rpc.INpcEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcEncounterProto;
            public static toObject(message: POGOProtos.Rpc.NpcEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcEncounterProto {

            interface INpcEncounterStep {
                step_id?: (string|null);
                dialog?: (POGOProtos.Rpc.IClientDialogueLineProto[]|null);
                event?: (POGOProtos.Rpc.INpcEventProto|null);
                next_step?: (string[]|null);
                npc_dialog?: (POGOProtos.Rpc.IQuestDialogProto[]|null);
            }

            class NpcEncounterStep implements INpcEncounterStep {
                constructor(properties?: POGOProtos.Rpc.NpcEncounterProto.INpcEncounterStep);
                public step_id: string;
                public dialog: POGOProtos.Rpc.IClientDialogueLineProto[];
                public event?: (POGOProtos.Rpc.INpcEventProto|null);
                public next_step: string[];
                public npc_dialog: POGOProtos.Rpc.IQuestDialogProto[];
                public static encode(message: POGOProtos.Rpc.NpcEncounterProto.INpcEncounterStep, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcEncounterProto.NpcEncounterStep;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcEncounterProto.NpcEncounterStep;
                public static toObject(message: POGOProtos.Rpc.NpcEncounterProto.NpcEncounterStep, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface INpcEventProto {
            cached_gift_exchange_entry?: (POGOProtos.Rpc.IGiftExchangeEntryProto|null);
            cached_pokemon_exchange_entry?: (POGOProtos.Rpc.IPokemonExchangeEntryProto|null);
            yes_no_selector?: (POGOProtos.Rpc.IYesNoSelectorProto|null);
            multi_selector?: (POGOProtos.Rpc.IMultiSelectorProto|null);
            tutorial_flag?: (POGOProtos.Rpc.TutorialCompletion|null);
            event?: (POGOProtos.Rpc.NpcEventProto.Event|null);
        }

        class NpcEventProto implements INpcEventProto {
            constructor(properties?: POGOProtos.Rpc.INpcEventProto);
            public cached_gift_exchange_entry?: (POGOProtos.Rpc.IGiftExchangeEntryProto|null);
            public cached_pokemon_exchange_entry?: (POGOProtos.Rpc.IPokemonExchangeEntryProto|null);
            public yes_no_selector?: (POGOProtos.Rpc.IYesNoSelectorProto|null);
            public multi_selector?: (POGOProtos.Rpc.IMultiSelectorProto|null);
            public tutorial_flag?: (POGOProtos.Rpc.TutorialCompletion|null);
            public event: POGOProtos.Rpc.NpcEventProto.Event;
            public State?: ("cached_gift_exchange_entry"|"cached_pokemon_exchange_entry"|"yes_no_selector"|"multi_selector"|"tutorial_flag");
            public static encode(message: POGOProtos.Rpc.INpcEventProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcEventProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcEventProto;
            public static toObject(message: POGOProtos.Rpc.NpcEventProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcEventProto {

            enum Event {
                UNSET = 0,
                TERMINATE_ENCOUNTER = 1,
                GIFT_EXCHANGE = 2,
                POKEMON_TRADE = 3,
                DESPAWN_NPC = 4,
                YES_NO_SELECT = 5,
                MULTI_SELECT = 6,
                SET_TUTORIAL_FLAG = 7
            }
        }

        interface INpcOpenGiftOutProto {
            result?: (POGOProtos.Rpc.NpcOpenGiftOutProto.Result|null);
            loot?: (POGOProtos.Rpc.ILootProto|null);
            current_step?: (string|null);
        }

        class NpcOpenGiftOutProto implements INpcOpenGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.INpcOpenGiftOutProto);
            public result: POGOProtos.Rpc.NpcOpenGiftOutProto.Result;
            public loot?: (POGOProtos.Rpc.ILootProto|null);
            public current_step: string;
            public static encode(message: POGOProtos.Rpc.INpcOpenGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcOpenGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcOpenGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.NpcOpenGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcOpenGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ENCOUNTER_NOT_FOUND = 3,
                ERROR_GIFT_NOT_FOUND = 4,
                ERROR_GIFT_ALREADY_OPENED = 5,
                ERROR_PLAYER_BAG_FULL = 6
            }
        }

        interface INpcOpenGiftProto {
            encounter_id?: (string|null);
            convert_to_stardust?: (boolean|null);
        }

        class NpcOpenGiftProto implements INpcOpenGiftProto {
            constructor(properties?: POGOProtos.Rpc.INpcOpenGiftProto);
            public encounter_id: string;
            public convert_to_stardust: boolean;
            public static encode(message: POGOProtos.Rpc.INpcOpenGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcOpenGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcOpenGiftProto;
            public static toObject(message: POGOProtos.Rpc.NpcOpenGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INpcPokemonProto {
            pokemon_type?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class NpcPokemonProto implements INpcPokemonProto {
            constructor(properties?: POGOProtos.Rpc.INpcPokemonProto);
            public pokemon_type: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.INpcPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcPokemonProto;
            public static toObject(message: POGOProtos.Rpc.NpcPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INpcRouteGiftOutProto {
            route_poi_details?: (POGOProtos.Rpc.NpcRouteGiftOutProto.IRouteFortDetails[]|null);
        }

        class NpcRouteGiftOutProto implements INpcRouteGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.INpcRouteGiftOutProto);
            public route_poi_details: POGOProtos.Rpc.NpcRouteGiftOutProto.IRouteFortDetails[];
            public static encode(message: POGOProtos.Rpc.INpcRouteGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcRouteGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcRouteGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.NpcRouteGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcRouteGiftOutProto {

            interface IRouteFortDetails {
                id?: (string|null);
                name?: (string|null);
                latitude?: (number|null);
                longitude?: (number|null);
                image_url?: (string|null);
            }

            class RouteFortDetails implements IRouteFortDetails {
                constructor(properties?: POGOProtos.Rpc.NpcRouteGiftOutProto.IRouteFortDetails);
                public id: string;
                public name: string;
                public latitude: number;
                public longitude: number;
                public image_url: string;
                public static encode(message: POGOProtos.Rpc.NpcRouteGiftOutProto.IRouteFortDetails, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcRouteGiftOutProto.RouteFortDetails;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcRouteGiftOutProto.RouteFortDetails;
                public static toObject(message: POGOProtos.Rpc.NpcRouteGiftOutProto.RouteFortDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface INpcRouteGiftProto {
            encounter_id?: (string|null);
        }

        class NpcRouteGiftProto implements INpcRouteGiftProto {
            constructor(properties?: POGOProtos.Rpc.INpcRouteGiftProto);
            public encounter_id: string;
            public static encode(message: POGOProtos.Rpc.INpcRouteGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcRouteGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcRouteGiftProto;
            public static toObject(message: POGOProtos.Rpc.NpcRouteGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INpcSendGiftOutProto {
            result?: (POGOProtos.Rpc.NpcSendGiftOutProto.Result|null);
            retrived_giftbox?: (POGOProtos.Rpc.IGiftExchangeEntryProto|null);
        }

        class NpcSendGiftOutProto implements INpcSendGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.INpcSendGiftOutProto);
            public result: POGOProtos.Rpc.NpcSendGiftOutProto.Result;
            public retrived_giftbox?: (POGOProtos.Rpc.IGiftExchangeEntryProto|null);
            public static encode(message: POGOProtos.Rpc.INpcSendGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcSendGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcSendGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.NpcSendGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcSendGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_GIFT_LIMIT = 3,
                ERROR_PLAYER_HAS_NO_STICKERS = 4
            }
        }

        interface INpcSendGiftProto {
            encounter_id?: (string|null);
            fort_id?: (string|null);
            stickers_sent?: (string[]|null);
        }

        class NpcSendGiftProto implements INpcSendGiftProto {
            constructor(properties?: POGOProtos.Rpc.INpcSendGiftProto);
            public encounter_id: string;
            public fort_id: string;
            public stickers_sent: string[];
            public static encode(message: POGOProtos.Rpc.INpcSendGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcSendGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcSendGiftProto;
            public static toObject(message: POGOProtos.Rpc.NpcSendGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface INpcUpdateStateOutProto {
            state?: (POGOProtos.Rpc.NpcUpdateStateOutProto.State|null);
            current_step?: (string|null);
        }

        class NpcUpdateStateOutProto implements INpcUpdateStateOutProto {
            constructor(properties?: POGOProtos.Rpc.INpcUpdateStateOutProto);
            public state: POGOProtos.Rpc.NpcUpdateStateOutProto.State;
            public current_step: string;
            public static encode(message: POGOProtos.Rpc.INpcUpdateStateOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcUpdateStateOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcUpdateStateOutProto;
            public static toObject(message: POGOProtos.Rpc.NpcUpdateStateOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace NpcUpdateStateOutProto {

            enum State {
                UNSET = 0,
                SUCCESS = 1,
                NPC_NOT_FOUND = 2,
                STEP_INVALID = 3
            }
        }

        interface INpcUpdateStateProto {
            encounter_id?: (string|null);
            set_current_step?: (string|null);
        }

        class NpcUpdateStateProto implements INpcUpdateStateProto {
            constructor(properties?: POGOProtos.Rpc.INpcUpdateStateProto);
            public encounter_id: string;
            public set_current_step: string;
            public static encode(message: POGOProtos.Rpc.INpcUpdateStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.NpcUpdateStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.NpcUpdateStateProto;
            public static toObject(message: POGOProtos.Rpc.NpcUpdateStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOAuthTokenRequest {
            access_token?: (string|null);
        }

        class OAuthTokenRequest implements IOAuthTokenRequest {
            constructor(properties?: POGOProtos.Rpc.IOAuthTokenRequest);
            public access_token: string;
            public static encode(message: POGOProtos.Rpc.IOAuthTokenRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OAuthTokenRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OAuthTokenRequest;
            public static toObject(message: POGOProtos.Rpc.OAuthTokenRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IObjectDetectionStartEvent {
            empty_field?: (boolean|null);
        }

        class ObjectDetectionStartEvent implements IObjectDetectionStartEvent {
            constructor(properties?: POGOProtos.Rpc.IObjectDetectionStartEvent);
            public empty_field: boolean;
            public static encode(message: POGOProtos.Rpc.IObjectDetectionStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ObjectDetectionStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ObjectDetectionStartEvent;
            public static toObject(message: POGOProtos.Rpc.ObjectDetectionStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IObjectDetectionStopEvent {
            time_elapsed_ms?: (number|null);
        }

        class ObjectDetectionStopEvent implements IObjectDetectionStopEvent {
            constructor(properties?: POGOProtos.Rpc.IObjectDetectionStopEvent);
            public time_elapsed_ms: number;
            public static encode(message: POGOProtos.Rpc.IObjectDetectionStopEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ObjectDetectionStopEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ObjectDetectionStopEvent;
            public static toObject(message: POGOProtos.Rpc.ObjectDetectionStopEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOnApplicationFocusData {
            has_focus?: (boolean|null);
        }

        class OnApplicationFocusData implements IOnApplicationFocusData {
            constructor(properties?: POGOProtos.Rpc.IOnApplicationFocusData);
            public has_focus: boolean;
            public static encode(message: POGOProtos.Rpc.IOnApplicationFocusData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OnApplicationFocusData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OnApplicationFocusData;
            public static toObject(message: POGOProtos.Rpc.OnApplicationFocusData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOnApplicationPauseData {
            pause_status?: (boolean|null);
        }

        class OnApplicationPauseData implements IOnApplicationPauseData {
            constructor(properties?: POGOProtos.Rpc.IOnApplicationPauseData);
            public pause_status: boolean;
            public static encode(message: POGOProtos.Rpc.IOnApplicationPauseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OnApplicationPauseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OnApplicationPauseData;
            public static toObject(message: POGOProtos.Rpc.OnApplicationPauseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOnApplicationQuitData {
        }

        class OnApplicationQuitData implements IOnApplicationQuitData {
            constructor(properties?: POGOProtos.Rpc.IOnApplicationQuitData);
            public static encode(message: POGOProtos.Rpc.IOnApplicationQuitData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OnApplicationQuitData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OnApplicationQuitData;
            public static toObject(message: POGOProtos.Rpc.OnApplicationQuitData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOnboardingSettingsProto {
            skip_avatar_customization?: (boolean|null);
            disable_initial_ar_prompt?: (boolean|null);
            ar_prompt_player_level?: (number|null);
            adventure_sync_prompt_step?: (number|null);
            adventure_sync_prompt_level?: (number|null);
        }

        class OnboardingSettingsProto implements IOnboardingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IOnboardingSettingsProto);
            public skip_avatar_customization: boolean;
            public disable_initial_ar_prompt: boolean;
            public ar_prompt_player_level: number;
            public adventure_sync_prompt_step: number;
            public adventure_sync_prompt_level: number;
            public static encode(message: POGOProtos.Rpc.IOnboardingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OnboardingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OnboardingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.OnboardingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOnboardingTelemetry {
            onboarding_path?: (POGOProtos.Rpc.OnboardingPathIds|null);
            event_id?: (POGOProtos.Rpc.OnboardingEventIds|null);
            data?: (number|null);
            conversation?: (string|null);
            ar_status?: (POGOProtos.Rpc.OnboardingArStatus|null);
        }

        class OnboardingTelemetry implements IOnboardingTelemetry {
            constructor(properties?: POGOProtos.Rpc.IOnboardingTelemetry);
            public onboarding_path: POGOProtos.Rpc.OnboardingPathIds;
            public event_id: POGOProtos.Rpc.OnboardingEventIds;
            public data: number;
            public conversation: string;
            public ar_status: POGOProtos.Rpc.OnboardingArStatus;
            public static encode(message: POGOProtos.Rpc.IOnboardingTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OnboardingTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OnboardingTelemetry;
            public static toObject(message: POGOProtos.Rpc.OnboardingTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOneWaySharedFriendshipDataProto {
            giftbox_details?: (POGOProtos.Rpc.IGiftBoxDetailsProto[]|null);
            open_trade_expire_ms?: (number|Long|null);
        }

        class OneWaySharedFriendshipDataProto implements IOneWaySharedFriendshipDataProto {
            constructor(properties?: POGOProtos.Rpc.IOneWaySharedFriendshipDataProto);
            public giftbox_details: POGOProtos.Rpc.IGiftBoxDetailsProto[];
            public open_trade_expire_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IOneWaySharedFriendshipDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OneWaySharedFriendshipDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OneWaySharedFriendshipDataProto;
            public static toObject(message: POGOProtos.Rpc.OneWaySharedFriendshipDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOneofDescriptorProto {
            name?: (string|null);
            options?: (POGOProtos.Rpc.IOneofOptions|null);
        }

        class OneofDescriptorProto implements IOneofDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IOneofDescriptorProto);
            public name: string;
            public options?: (POGOProtos.Rpc.IOneofOptions|null);
            public static encode(message: POGOProtos.Rpc.IOneofDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OneofDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OneofDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.OneofDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOneofOptions {
        }

        class OneofOptions implements IOneofOptions {
            constructor(properties?: POGOProtos.Rpc.IOneofOptions);
            public static encode(message: POGOProtos.Rpc.IOneofOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OneofOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OneofOptions;
            public static toObject(message: POGOProtos.Rpc.OneofOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenBuddyGiftOutProto {
            result?: (POGOProtos.Rpc.OpenBuddyGiftOutProto.Result|null);
            buddy_gift?: (POGOProtos.Rpc.IBuddyGiftProto|null);
            observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            shown_hearts?: (POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType|null);
        }

        class OpenBuddyGiftOutProto implements IOpenBuddyGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenBuddyGiftOutProto);
            public result: POGOProtos.Rpc.OpenBuddyGiftOutProto.Result;
            public buddy_gift?: (POGOProtos.Rpc.IBuddyGiftProto|null);
            public observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public shown_hearts: POGOProtos.Rpc.BuddyStatsShownHearts.BuddyShownHeartType;
            public static encode(message: POGOProtos.Rpc.IOpenBuddyGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenBuddyGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenBuddyGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenBuddyGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenBuddyGiftOutProto {

            enum Result {
                UNSET = 0,
                ERROR_BUDDY_NOT_VALID = 1,
                SUCCESS_ADDED_LOOT_TO_INVENTORY = 2,
                SUCCESS_ADDED_SOUVENIR_TO_COLLECTIONS = 3,
                ERROR_BUDDY_HAS_NOT_PICKED_UP_ANY_SOUVENIRS = 4,
                ERROR_INVENTORY_IS_FULL = 5,
                ERROR_BUDDY_NOT_ON_MAP = 6
            }
        }

        interface IOpenBuddyGiftProto {
        }

        class OpenBuddyGiftProto implements IOpenBuddyGiftProto {
            constructor(properties?: POGOProtos.Rpc.IOpenBuddyGiftProto);
            public static encode(message: POGOProtos.Rpc.IOpenBuddyGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenBuddyGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenBuddyGiftProto;
            public static toObject(message: POGOProtos.Rpc.OpenBuddyGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenCampfireMapTelemetry {
            source?: (POGOProtos.Rpc.OpenCampfireMapTelemetry.SourcePage|null);
            is_standalone?: (boolean|null);
        }

        class OpenCampfireMapTelemetry implements IOpenCampfireMapTelemetry {
            constructor(properties?: POGOProtos.Rpc.IOpenCampfireMapTelemetry);
            public source: POGOProtos.Rpc.OpenCampfireMapTelemetry.SourcePage;
            public is_standalone: boolean;
            public static encode(message: POGOProtos.Rpc.IOpenCampfireMapTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCampfireMapTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCampfireMapTelemetry;
            public static toObject(message: POGOProtos.Rpc.OpenCampfireMapTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenCampfireMapTelemetry {

            enum SourcePage {
                UNKNOWN = 0,
                MAP = 1,
                NEARBY_RAIDS = 2,
                GYM_APPROACH = 3,
                RAID_APPROACH = 4,
                CATCH_CARD = 5,
                NEARBY_ROUTES = 6,
                NOTIFICATION = 8
            }
        }

        interface IOpenCombatChallengeData {
            rpc_id?: (number|null);
            type?: (POGOProtos.Rpc.CombatType|null);
            attacking_pokemon_indexes?: (number[]|null);
        }

        class OpenCombatChallengeData implements IOpenCombatChallengeData {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatChallengeData);
            public rpc_id: number;
            public type: POGOProtos.Rpc.CombatType;
            public attacking_pokemon_indexes: number[];
            public static encode(message: POGOProtos.Rpc.IOpenCombatChallengeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatChallengeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatChallengeData;
            public static toObject(message: POGOProtos.Rpc.OpenCombatChallengeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenCombatChallengeOutProto {
            result?: (POGOProtos.Rpc.OpenCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
        }

        class OpenCombatChallengeOutProto implements IOpenCombatChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatChallengeOutProto);
            public result: POGOProtos.Rpc.OpenCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenCombatChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenCombatChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenCombatChallengeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_CHALLENGE_STATE = 2,
                ERROR_CHALLENGE_NOT_FOUND = 3,
                ERROR_POKEMON_NOT_IN_INVENTORY = 4,
                ERROR_NOT_ELIGIBLE_LEAGUE = 5,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 6,
                ERROR_ALREADY_TIMEDOUT = 8,
                ERROR_ALREADY_CANCELLED = 9,
                ERROR_FRIEND_NOT_FOUND = 10,
                ERROR_FAILED_TO_SEND_NOTIFICATION = 11,
                ERROR_ACCESS_DENIED = 12,
                ERROR_INELIGIBLE_OPPONENT = 13
            }
        }

        interface IOpenCombatChallengeProto {
            type?: (POGOProtos.Rpc.CombatType|null);
            challenge_id?: (string|null);
            combat_league_template_id?: (string|null);
            opponent_player_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            opponent_nia_id?: (string|null);
        }

        class OpenCombatChallengeProto implements IOpenCombatChallengeProto {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatChallengeProto);
            public type: POGOProtos.Rpc.CombatType;
            public challenge_id: string;
            public combat_league_template_id: string;
            public opponent_player_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public opponent_nia_id: string;
            public static encode(message: POGOProtos.Rpc.IOpenCombatChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatChallengeProto;
            public static toObject(message: POGOProtos.Rpc.OpenCombatChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenCombatChallengeResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.OpenCombatChallengeOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
        }

        class OpenCombatChallengeResponseData implements IOpenCombatChallengeResponseData {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatChallengeResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.OpenCombatChallengeOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenCombatChallengeResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatChallengeResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatChallengeResponseData;
            public static toObject(message: POGOProtos.Rpc.OpenCombatChallengeResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenCombatSessionData {
            rpc_id?: (number|null);
            attacking_pokemon_indexes?: (number[]|null);
            lobby_join_time_offset_ms?: (number|null);
            combat_type?: (POGOProtos.Rpc.CombatType|null);
        }

        class OpenCombatSessionData implements IOpenCombatSessionData {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatSessionData);
            public rpc_id: number;
            public attacking_pokemon_indexes: number[];
            public lobby_join_time_offset_ms: number;
            public combat_type: POGOProtos.Rpc.CombatType;
            public static encode(message: POGOProtos.Rpc.IOpenCombatSessionData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatSessionData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatSessionData;
            public static toObject(message: POGOProtos.Rpc.OpenCombatSessionData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenCombatSessionOutProto {
            result?: (POGOProtos.Rpc.OpenCombatSessionOutProto.Result|null);
            combat?: (POGOProtos.Rpc.ICombatProto|null);
            should_debug_log?: (boolean|null);
            combat_experiment?: (POGOProtos.Rpc.CombatExperiment[]|null);
            realm?: (string|null);
        }

        class OpenCombatSessionOutProto implements IOpenCombatSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatSessionOutProto);
            public result: POGOProtos.Rpc.OpenCombatSessionOutProto.Result;
            public combat?: (POGOProtos.Rpc.ICombatProto|null);
            public should_debug_log: boolean;
            public combat_experiment: POGOProtos.Rpc.CombatExperiment[];
            public realm: string;
            public static encode(message: POGOProtos.Rpc.IOpenCombatSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenCombatSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenCombatSessionOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_COMBAT_STATE = 2,
                ERROR_COMBAT_SESSION_FULL = 3,
                ERROR_POKEMON_NOT_IN_INVENTORY = 4,
                ERROR_OPPONENT_NOT_IN_RANGE = 5,
                ERROR_CHALLENGE_EXPIRED = 6,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 7,
                ERROR_OPPONENT_QUIT = 8,
                ERROR_POKEMON_LINEUP_INELIGIBLE_FOR_LEAGUE = 9,
                ERROR_COMBAT_LEAGUE_UNSPECIFIED = 10,
                ERROR_ACCESS_DENIED = 11,
                ERROR_PLAYER_HAS_NO_BATTLE_PASSES = 12
            }
        }

        interface IOpenCombatSessionProto {
            combat_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            combat_league_template_id?: (string|null);
            lobby_join_time_ms?: (number|Long|null);
            combat_type?: (POGOProtos.Rpc.CombatType|null);
        }

        class OpenCombatSessionProto implements IOpenCombatSessionProto {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatSessionProto);
            public combat_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public combat_league_template_id: string;
            public lobby_join_time_ms: (number|Long);
            public combat_type: POGOProtos.Rpc.CombatType;
            public static encode(message: POGOProtos.Rpc.IOpenCombatSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatSessionProto;
            public static toObject(message: POGOProtos.Rpc.OpenCombatSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenCombatSessionResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            open_combat_session_out_proto?: (POGOProtos.Rpc.IOpenCombatSessionOutProto|null);
        }

        class OpenCombatSessionResponseData implements IOpenCombatSessionResponseData {
            constructor(properties?: POGOProtos.Rpc.IOpenCombatSessionResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public open_combat_session_out_proto?: (POGOProtos.Rpc.IOpenCombatSessionOutProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenCombatSessionResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenCombatSessionResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenCombatSessionResponseData;
            public static toObject(message: POGOProtos.Rpc.OpenCombatSessionResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenGiftLogEntry {
            result?: (POGOProtos.Rpc.OpenGiftLogEntry.Result|null);
            friend_codename?: (string|null);
            items?: (POGOProtos.Rpc.ILootProto|null);
            pokemon_eggs?: (POGOProtos.Rpc.IPokemonProto[]|null);
        }

        class OpenGiftLogEntry implements IOpenGiftLogEntry {
            constructor(properties?: POGOProtos.Rpc.IOpenGiftLogEntry);
            public result: POGOProtos.Rpc.OpenGiftLogEntry.Result;
            public friend_codename: string;
            public items?: (POGOProtos.Rpc.ILootProto|null);
            public pokemon_eggs: POGOProtos.Rpc.IPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IOpenGiftLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenGiftLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenGiftLogEntry;
            public static toObject(message: POGOProtos.Rpc.OpenGiftLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenGiftLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NPC_TRADE = 2
            }
        }

        interface IOpenGiftOutProto {
            result?: (POGOProtos.Rpc.OpenGiftOutProto.Result|null);
            items?: (POGOProtos.Rpc.ILootProto|null);
            egg_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            updated_friendship_data?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            friend_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
        }

        class OpenGiftOutProto implements IOpenGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenGiftOutProto);
            public result: POGOProtos.Rpc.OpenGiftOutProto.Result;
            public items?: (POGOProtos.Rpc.ILootProto|null);
            public egg_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public updated_friendship_data?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            public friend_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_BAG_FULL = 3,
                ERROR_PLAYER_LIMIT_REACHED = 4,
                ERROR_GIFT_DOES_NOT_EXIST = 5,
                ERROR_FRIEND_NOT_FOUND = 6,
                ERROR_INVALID_PLAYER_ID = 7,
                ERROR_FRIEND_UPDATE = 8
            }
        }

        interface IOpenGiftProto {
            player_id?: (string|null);
            giftbox_id?: (number|Long|null);
            convert_to_stardust?: (boolean|null);
        }

        class OpenGiftProto implements IOpenGiftProto {
            constructor(properties?: POGOProtos.Rpc.IOpenGiftProto);
            public player_id: string;
            public giftbox_id: (number|Long);
            public convert_to_stardust: boolean;
            public static encode(message: POGOProtos.Rpc.IOpenGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenGiftProto;
            public static toObject(message: POGOProtos.Rpc.OpenGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenInvasionCombatSessionOutProto {
            status?: (POGOProtos.Rpc.InvasionStatus.Status|null);
            combat?: (POGOProtos.Rpc.ICombatProto|null);
        }

        class OpenInvasionCombatSessionOutProto implements IOpenInvasionCombatSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenInvasionCombatSessionOutProto);
            public status: POGOProtos.Rpc.InvasionStatus.Status;
            public combat?: (POGOProtos.Rpc.ICombatProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenInvasionCombatSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenInvasionCombatSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenInvasionCombatSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenInvasionCombatSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenInvasionCombatSessionProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            step?: (number|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            lobby_join_time_ms?: (number|Long|null);
        }

        class OpenInvasionCombatSessionProto implements IOpenInvasionCombatSessionProto {
            constructor(properties?: POGOProtos.Rpc.IOpenInvasionCombatSessionProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public step: number;
            public attacking_pokemon_id: (number|Long)[];
            public lobby_join_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IOpenInvasionCombatSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenInvasionCombatSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenInvasionCombatSessionProto;
            public static toObject(message: POGOProtos.Rpc.OpenInvasionCombatSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenNpcCombatSessionData {
            rpc_id?: (number|null);
            attacking_pokemon_indexes?: (number[]|null);
            lobby_join_time_offset_ms?: (number|null);
        }

        class OpenNpcCombatSessionData implements IOpenNpcCombatSessionData {
            constructor(properties?: POGOProtos.Rpc.IOpenNpcCombatSessionData);
            public rpc_id: number;
            public attacking_pokemon_indexes: number[];
            public lobby_join_time_offset_ms: number;
            public static encode(message: POGOProtos.Rpc.IOpenNpcCombatSessionData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenNpcCombatSessionData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenNpcCombatSessionData;
            public static toObject(message: POGOProtos.Rpc.OpenNpcCombatSessionData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenNpcCombatSessionOutProto {
            result?: (POGOProtos.Rpc.OpenNpcCombatSessionOutProto.Result|null);
            combat?: (POGOProtos.Rpc.ICombatProto|null);
        }

        class OpenNpcCombatSessionOutProto implements IOpenNpcCombatSessionOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenNpcCombatSessionOutProto);
            public result: POGOProtos.Rpc.OpenNpcCombatSessionOutProto.Result;
            public combat?: (POGOProtos.Rpc.ICombatProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenNpcCombatSessionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenNpcCombatSessionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenNpcCombatSessionOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenNpcCombatSessionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenNpcCombatSessionOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 2,
                ERROR_POKEMON_LINEUP_INELIGIBLE_FOR_LEAGUE = 3,
                ERROR_ACCESS_DENIED = 4
            }
        }

        interface IOpenNpcCombatSessionProto {
            attacking_pokemon_id?: ((number|Long)[]|null);
            combat_npc_template_id?: (string|null);
            lobby_join_time_ms?: (number|Long|null);
        }

        class OpenNpcCombatSessionProto implements IOpenNpcCombatSessionProto {
            constructor(properties?: POGOProtos.Rpc.IOpenNpcCombatSessionProto);
            public attacking_pokemon_id: (number|Long)[];
            public combat_npc_template_id: string;
            public lobby_join_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IOpenNpcCombatSessionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenNpcCombatSessionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenNpcCombatSessionProto;
            public static toObject(message: POGOProtos.Rpc.OpenNpcCombatSessionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenNpcCombatSessionResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.OpenNpcCombatSessionOutProto.Result|null);
            combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
        }

        class OpenNpcCombatSessionResponseData implements IOpenNpcCombatSessionResponseData {
            constructor(properties?: POGOProtos.Rpc.IOpenNpcCombatSessionResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.OpenNpcCombatSessionOutProto.Result;
            public combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenNpcCombatSessionResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenNpcCombatSessionResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenNpcCombatSessionResponseData;
            public static toObject(message: POGOProtos.Rpc.OpenNpcCombatSessionResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenSponsoredGiftOutProto {
            result?: (POGOProtos.Rpc.OpenSponsoredGiftOutProto.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class OpenSponsoredGiftOutProto implements IOpenSponsoredGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenSponsoredGiftOutProto);
            public result: POGOProtos.Rpc.OpenSponsoredGiftOutProto.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenSponsoredGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenSponsoredGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenSponsoredGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenSponsoredGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenSponsoredGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_BAG_FULL = 3,
                ERROR_GIFT_REDEEMED = 4
            }
        }

        interface IOpenSponsoredGiftProto {
            encrypted_ad_token?: (Uint8Array|null);
            gift_token?: (Uint8Array|null);
        }

        class OpenSponsoredGiftProto implements IOpenSponsoredGiftProto {
            constructor(properties?: POGOProtos.Rpc.IOpenSponsoredGiftProto);
            public encrypted_ad_token: Uint8Array;
            public gift_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IOpenSponsoredGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenSponsoredGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenSponsoredGiftProto;
            public static toObject(message: POGOProtos.Rpc.OpenSponsoredGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOpenTradingOutProto {
            result?: (POGOProtos.Rpc.OpenTradingOutProto.Result|null);
            trading?: (POGOProtos.Rpc.ITradingProto|null);
        }

        class OpenTradingOutProto implements IOpenTradingOutProto {
            constructor(properties?: POGOProtos.Rpc.IOpenTradingOutProto);
            public result: POGOProtos.Rpc.OpenTradingOutProto.Result;
            public trading?: (POGOProtos.Rpc.ITradingProto|null);
            public static encode(message: POGOProtos.Rpc.IOpenTradingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenTradingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenTradingOutProto;
            public static toObject(message: POGOProtos.Rpc.OpenTradingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace OpenTradingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FRIEND_NOT_FOUND = 3,
                ERROR_INVALID_PLAYER_ID = 4,
                ERROR_INVALID_STATE = 5,
                ERROR_STATE_HANDLER = 6,
                ERROR_TRADING_EXPIRED = 7,
                ERROR_TRADING_COOLDOWN = 8,
                ERROR_PLAYER_ALREADY_OPENED = 9,
                ERROR_FRIEND_OUT_OF_RANGE = 10,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 11,
                ERROR_PLAYER_REACHED_DAILY_LIMIT = 12,
                ERROR_FRIEND_REACHED_DAILY_LIMIT = 13,
                ERROR_PLAYER_NOT_ENOUGH_STARDUST = 14,
                ERROR_FRIEND_NOT_ENOUGH_STARDUST = 15,
                ERROR_FRIEND_BELOW_MINIMUM_LEVEL = 16
            }
        }

        interface IOpenTradingProto {
            player_id?: (string|null);
        }

        class OpenTradingProto implements IOpenTradingProto {
            constructor(properties?: POGOProtos.Rpc.IOpenTradingProto);
            public player_id: string;
            public static encode(message: POGOProtos.Rpc.IOpenTradingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OpenTradingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OpenTradingProto;
            public static toObject(message: POGOProtos.Rpc.OpenTradingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOptOutProto {
            categories?: (string[]|null);
        }

        class OptOutProto implements IOptOutProto {
            constructor(properties?: POGOProtos.Rpc.IOptOutProto);
            public categories: string[];
            public static encode(message: POGOProtos.Rpc.IOptOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OptOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OptOutProto;
            public static toObject(message: POGOProtos.Rpc.OptOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOptimizationsProto {
            optimization_physics_toggle_enabled?: (boolean|null);
            optimization_adaptive_performance_enabled?: (boolean|null);
            adaptive_performance_update_interval?: (number|null);
            adaptive_performance_frame_rate?: (boolean|null);
            adaptive_performance_resolution?: (boolean|null);
            adaptive_performance_min_frame_rate?: (number|null);
            adaptive_performance_max_frame_rate?: (number|null);
            adaptive_performance_min_resolution_scale?: (number|null);
            optimization_resolution_update_interval?: (number|null);
        }

        class OptimizationsProto implements IOptimizationsProto {
            constructor(properties?: POGOProtos.Rpc.IOptimizationsProto);
            public optimization_physics_toggle_enabled: boolean;
            public optimization_adaptive_performance_enabled: boolean;
            public adaptive_performance_update_interval: number;
            public adaptive_performance_frame_rate: boolean;
            public adaptive_performance_resolution: boolean;
            public adaptive_performance_min_frame_rate: number;
            public adaptive_performance_max_frame_rate: number;
            public adaptive_performance_min_resolution_scale: number;
            public optimization_resolution_update_interval: number;
            public static encode(message: POGOProtos.Rpc.IOptimizationsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OptimizationsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OptimizationsProto;
            public static toObject(message: POGOProtos.Rpc.OptimizationsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOption {
            name?: (string|null);
            value?: (POGOProtos.Rpc.INiaAny|null);
        }

        class Option implements IOption {
            constructor(properties?: POGOProtos.Rpc.IOption);
            public name: string;
            public value?: (POGOProtos.Rpc.INiaAny|null);
            public static encode(message: POGOProtos.Rpc.IOption, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Option;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Option;
            public static toObject(message: POGOProtos.Rpc.Option, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IOptionalMoveOverrideProto {
            override?: (boolean|null);
            move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class OptionalMoveOverrideProto implements IOptionalMoveOverrideProto {
            constructor(properties?: POGOProtos.Rpc.IOptionalMoveOverrideProto);
            public override: boolean;
            public move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IOptionalMoveOverrideProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.OptionalMoveOverrideProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.OptionalMoveOverrideProto;
            public static toObject(message: POGOProtos.Rpc.OptionalMoveOverrideProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IParticipantConsumptionAccounting {
            participant_id?: (string|null);
            consume_count?: (number|null);
        }

        class ParticipantConsumptionAccounting implements IParticipantConsumptionAccounting {
            constructor(properties?: POGOProtos.Rpc.IParticipantConsumptionAccounting);
            public participant_id: string;
            public consume_count: number;
            public static encode(message: POGOProtos.Rpc.IParticipantConsumptionAccounting, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ParticipantConsumptionAccounting;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ParticipantConsumptionAccounting;
            public static toObject(message: POGOProtos.Rpc.ParticipantConsumptionAccounting, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IParticipationProto {
            individual_damage_pokeballs?: (number|null);
            team_damage_pokeballs?: (number|null);
            gym_ownership_pokeballs?: (number|null);
            base_pokeballs?: (number|null);
            blue_percentage?: (number|null);
            red_percentage?: (number|null);
            yellow_percentage?: (number|null);
            bonus_item_multiplier?: (number|null);
            highest_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
            highest_friendship_pokeballs?: (number|null);
            speed_completion_pokeballs?: (number|null);
            speed_completion_mega_resource?: (number|null);
            mega_resource_capped?: (boolean|null);
            fort_powerup_pokeballs?: (number|null);
            rsvp_follow_through_pokeballs?: (number|null);
        }

        class ParticipationProto implements IParticipationProto {
            constructor(properties?: POGOProtos.Rpc.IParticipationProto);
            public individual_damage_pokeballs: number;
            public team_damage_pokeballs: number;
            public gym_ownership_pokeballs: number;
            public base_pokeballs: number;
            public blue_percentage: number;
            public red_percentage: number;
            public yellow_percentage: number;
            public bonus_item_multiplier: number;
            public highest_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public highest_friendship_pokeballs: number;
            public speed_completion_pokeballs: number;
            public speed_completion_mega_resource: number;
            public mega_resource_capped: boolean;
            public fort_powerup_pokeballs: number;
            public rsvp_follow_through_pokeballs: number;
            public static encode(message: POGOProtos.Rpc.IParticipationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ParticipationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ParticipationProto;
            public static toObject(message: POGOProtos.Rpc.ParticipationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyActivityStatProto {
            activity_stat_id?: (number|null);
            quest_type?: (POGOProtos.Rpc.QuestType|null);
            conditions?: (POGOProtos.Rpc.IQuestConditionProto[]|null);
            category_id?: (number|null);
            icon_id?: (number|null);
            scale_down?: (number|null);
        }

        class PartyActivityStatProto implements IPartyActivityStatProto {
            constructor(properties?: POGOProtos.Rpc.IPartyActivityStatProto);
            public activity_stat_id: number;
            public quest_type: POGOProtos.Rpc.QuestType;
            public conditions: POGOProtos.Rpc.IQuestConditionProto[];
            public category_id: number;
            public icon_id: number;
            public scale_down: number;
            public static encode(message: POGOProtos.Rpc.IPartyActivityStatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyActivityStatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyActivityStatProto;
            public static toObject(message: POGOProtos.Rpc.PartyActivityStatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyActivitySummaryProto {
            player_summary_map?: ({ [k: string]: POGOProtos.Rpc.IPlayerActivitySummaryProto }|null);
        }

        class PartyActivitySummaryProto implements IPartyActivitySummaryProto {
            constructor(properties?: POGOProtos.Rpc.IPartyActivitySummaryProto);
            public player_summary_map: { [k: string]: POGOProtos.Rpc.IPlayerActivitySummaryProto };
            public static encode(message: POGOProtos.Rpc.IPartyActivitySummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyActivitySummaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyActivitySummaryProto;
            public static toObject(message: POGOProtos.Rpc.PartyActivitySummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyActivitySummaryRpcProto {
            player_activity?: (POGOProtos.Rpc.PartyActivitySummaryRpcProto.IPlayerActivityRpcProto[]|null);
        }

        class PartyActivitySummaryRpcProto implements IPartyActivitySummaryRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyActivitySummaryRpcProto);
            public player_activity: POGOProtos.Rpc.PartyActivitySummaryRpcProto.IPlayerActivityRpcProto[];
            public static encode(message: POGOProtos.Rpc.IPartyActivitySummaryRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyActivitySummaryRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyActivitySummaryRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyActivitySummaryRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyActivitySummaryRpcProto {

            interface IPlayerActivityRpcProto {
                player_id?: (string|null);
                player_activity?: (POGOProtos.Rpc.IPlayerActivitySummaryProto|null);
            }

            class PlayerActivityRpcProto implements IPlayerActivityRpcProto {
                constructor(properties?: POGOProtos.Rpc.PartyActivitySummaryRpcProto.IPlayerActivityRpcProto);
                public player_id: string;
                public player_activity?: (POGOProtos.Rpc.IPlayerActivitySummaryProto|null);
                public static encode(message: POGOProtos.Rpc.PartyActivitySummaryRpcProto.IPlayerActivityRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyActivitySummaryRpcProto.PlayerActivityRpcProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyActivitySummaryRpcProto.PlayerActivityRpcProto;
                public static toObject(message: POGOProtos.Rpc.PartyActivitySummaryRpcProto.PlayerActivityRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPartyDarkLaunchLogMessageProto {
            log_level?: (POGOProtos.Rpc.PartyDarkLaunchLogMessageProto.LogLevel|null);
            timestamp_ms?: (number|Long|null);
            log_string?: (string|null);
        }

        class PartyDarkLaunchLogMessageProto implements IPartyDarkLaunchLogMessageProto {
            constructor(properties?: POGOProtos.Rpc.IPartyDarkLaunchLogMessageProto);
            public log_level: POGOProtos.Rpc.PartyDarkLaunchLogMessageProto.LogLevel;
            public timestamp_ms: (number|Long);
            public log_string: string;
            public static encode(message: POGOProtos.Rpc.IPartyDarkLaunchLogMessageProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyDarkLaunchLogMessageProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyDarkLaunchLogMessageProto;
            public static toObject(message: POGOProtos.Rpc.PartyDarkLaunchLogMessageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyDarkLaunchLogMessageProto {

            enum LogLevel {
                UNKNOWN = 0,
                INFO = 1,
                WARNING = 2,
                SEVERE = 3
            }
        }

        interface IPartyDarkLaunchSettingsProto {
            dark_launch_enabled?: (boolean|null);
            rollout_players_per_billion?: (number|null);
            create_or_join_wait_probability?: (POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ICreateOrJoinWaitProbabilityProto[]|null);
            probability_to_create_percent?: (number|null);
            leave_party_probability?: (POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ILeavePartyProbabilityProto[]|null);
            update_location_enabled?: (boolean|null);
            update_location_override_period_ms?: (number|null);
        }

        class PartyDarkLaunchSettingsProto implements IPartyDarkLaunchSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartyDarkLaunchSettingsProto);
            public dark_launch_enabled: boolean;
            public rollout_players_per_billion: number;
            public create_or_join_wait_probability: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ICreateOrJoinWaitProbabilityProto[];
            public probability_to_create_percent: number;
            public leave_party_probability: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ILeavePartyProbabilityProto[];
            public update_location_enabled: boolean;
            public update_location_override_period_ms: number;
            public static encode(message: POGOProtos.Rpc.IPartyDarkLaunchSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyDarkLaunchSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyDarkLaunchSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartyDarkLaunchSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyDarkLaunchSettingsProto {

            interface ICreateOrJoinWaitProbabilityProto {
                weight?: (number|null);
                wait_time_ms?: (number|null);
            }

            class CreateOrJoinWaitProbabilityProto implements ICreateOrJoinWaitProbabilityProto {
                constructor(properties?: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ICreateOrJoinWaitProbabilityProto);
                public weight: number;
                public wait_time_ms: number;
                public static encode(message: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ICreateOrJoinWaitProbabilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyDarkLaunchSettingsProto.CreateOrJoinWaitProbabilityProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyDarkLaunchSettingsProto.CreateOrJoinWaitProbabilityProto;
                public static toObject(message: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.CreateOrJoinWaitProbabilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ILeavePartyProbabilityProto {
                weight?: (number|null);
                max_duration_ms?: (number|null);
            }

            class LeavePartyProbabilityProto implements ILeavePartyProbabilityProto {
                constructor(properties?: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ILeavePartyProbabilityProto);
                public weight: number;
                public max_duration_ms: number;
                public static encode(message: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.ILeavePartyProbabilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyDarkLaunchSettingsProto.LeavePartyProbabilityProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyDarkLaunchSettingsProto.LeavePartyProbabilityProto;
                public static toObject(message: POGOProtos.Rpc.PartyDarkLaunchSettingsProto.LeavePartyProbabilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPartyHistoryRpcProto {
            party_id?: (number|Long|null);
            party_seed?: (number|Long|null);
            party_started_ms?: (number|Long|null);
            party_expiry_ms?: (number|Long|null);
            party_concluded_ms?: (number|Long|null);
            party_formed_ms?: (number|Long|null);
            players_participated?: (POGOProtos.Rpc.IPartyParticipantHistoryRpcProto[]|null);
        }

        class PartyHistoryRpcProto implements IPartyHistoryRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyHistoryRpcProto);
            public party_id: (number|Long);
            public party_seed: (number|Long);
            public party_started_ms: (number|Long);
            public party_expiry_ms: (number|Long);
            public party_concluded_ms: (number|Long);
            public party_formed_ms: (number|Long);
            public players_participated: POGOProtos.Rpc.IPartyParticipantHistoryRpcProto[];
            public static encode(message: POGOProtos.Rpc.IPartyHistoryRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyHistoryRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyHistoryRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyHistoryRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyIapBoostsSettingsProto {
            boost?: (POGOProtos.Rpc.PartyIapBoostsSettingsProto.IPartyIapBoostProto[]|null);
        }

        class PartyIapBoostsSettingsProto implements IPartyIapBoostsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartyIapBoostsSettingsProto);
            public boost: POGOProtos.Rpc.PartyIapBoostsSettingsProto.IPartyIapBoostProto[];
            public static encode(message: POGOProtos.Rpc.IPartyIapBoostsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyIapBoostsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyIapBoostsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartyIapBoostsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyIapBoostsSettingsProto {

            interface IPartyIapBoostProto {
                supported_item_types?: (POGOProtos.Rpc.Item|null);
                percentage_duration?: (number|null);
                duration_multiplier?: (number|null);
                daily_contribution_limit?: (number|null);
            }

            class PartyIapBoostProto implements IPartyIapBoostProto {
                constructor(properties?: POGOProtos.Rpc.PartyIapBoostsSettingsProto.IPartyIapBoostProto);
                public supported_item_types: POGOProtos.Rpc.Item;
                public percentage_duration: number;
                public duration_multiplier: number;
                public daily_contribution_limit: number;
                public static encode(message: POGOProtos.Rpc.PartyIapBoostsSettingsProto.IPartyIapBoostProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyIapBoostsSettingsProto.PartyIapBoostProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyIapBoostsSettingsProto.PartyIapBoostProto;
                public static toObject(message: POGOProtos.Rpc.PartyIapBoostsSettingsProto.PartyIapBoostProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPartyInviteRpcProto {
            party_id?: (number|Long|null);
            sender_id?: (string|null);
            party_members?: (POGOProtos.Rpc.IPartyParticipantProto[]|null);
            quest_id?: (string|null);
            invite_expiration_ms?: (number|Long|null);
            party_end_ms?: (number|Long|null);
        }

        class PartyInviteRpcProto implements IPartyInviteRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyInviteRpcProto);
            public party_id: (number|Long);
            public sender_id: string;
            public party_members: POGOProtos.Rpc.IPartyParticipantProto[];
            public quest_id: string;
            public invite_expiration_ms: (number|Long);
            public party_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPartyInviteRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyInviteRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyInviteRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyInviteRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyItemProto {
            player_id?: (string|null);
            party_item?: (POGOProtos.Rpc.IItemProto|null);
            usage_start_ms?: (number|Long|null);
            item?: (POGOProtos.Rpc.Item|null);
            contributor_id?: (string|null);
        }

        class PartyItemProto implements IPartyItemProto {
            constructor(properties?: POGOProtos.Rpc.IPartyItemProto);
            public player_id: string;
            public party_item?: (POGOProtos.Rpc.IItemProto|null);
            public usage_start_ms: (number|Long);
            public item: POGOProtos.Rpc.Item;
            public contributor_id: string;
            public static encode(message: POGOProtos.Rpc.IPartyItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyItemProto;
            public static toObject(message: POGOProtos.Rpc.PartyItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyLocationPushProto {
            player_id?: (string|null);
            untrusted_sample_list?: (POGOProtos.Rpc.IPartyLocationSampleProto[]|null);
        }

        class PartyLocationPushProto implements IPartyLocationPushProto {
            constructor(properties?: POGOProtos.Rpc.IPartyLocationPushProto);
            public player_id: string;
            public untrusted_sample_list: POGOProtos.Rpc.IPartyLocationSampleProto[];
            public static encode(message: POGOProtos.Rpc.IPartyLocationPushProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyLocationPushProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyLocationPushProto;
            public static toObject(message: POGOProtos.Rpc.PartyLocationPushProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyLocationSampleProto {
            timestamp_ms?: (number|Long|null);
            lat?: (number|null);
            lng?: (number|null);
        }

        class PartyLocationSampleProto implements IPartyLocationSampleProto {
            constructor(properties?: POGOProtos.Rpc.IPartyLocationSampleProto);
            public timestamp_ms: (number|Long);
            public lat: number;
            public lng: number;
            public static encode(message: POGOProtos.Rpc.IPartyLocationSampleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyLocationSampleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyLocationSampleProto;
            public static toObject(message: POGOProtos.Rpc.PartyLocationSampleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyLocationsRpcProto {
            player_location?: (POGOProtos.Rpc.PartyLocationsRpcProto.IPlayerLocationRpcProto[]|null);
        }

        class PartyLocationsRpcProto implements IPartyLocationsRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyLocationsRpcProto);
            public player_location: POGOProtos.Rpc.PartyLocationsRpcProto.IPlayerLocationRpcProto[];
            public static encode(message: POGOProtos.Rpc.IPartyLocationsRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyLocationsRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyLocationsRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyLocationsRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyLocationsRpcProto {

            interface IPlayerLocationRpcProto {
                trusted_lat?: (number|null);
                trusted_lng?: (number|null);
                player_zone?: (POGOProtos.Rpc.PlayerZoneCompliance|null);
                untrusted_samples?: (POGOProtos.Rpc.IPartyLocationSampleProto[]|null);
                last_update_timestamp_ms?: (number|Long|null);
                player_id?: (string|null);
            }

            class PlayerLocationRpcProto implements IPlayerLocationRpcProto {
                constructor(properties?: POGOProtos.Rpc.PartyLocationsRpcProto.IPlayerLocationRpcProto);
                public trusted_lat: number;
                public trusted_lng: number;
                public player_zone: POGOProtos.Rpc.PlayerZoneCompliance;
                public untrusted_samples: POGOProtos.Rpc.IPartyLocationSampleProto[];
                public last_update_timestamp_ms: (number|Long);
                public player_id: string;
                public static encode(message: POGOProtos.Rpc.PartyLocationsRpcProto.IPlayerLocationRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyLocationsRpcProto.PlayerLocationRpcProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyLocationsRpcProto.PlayerLocationRpcProto;
                public static toObject(message: POGOProtos.Rpc.PartyLocationsRpcProto.PlayerLocationRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPartyParticipantHistoryRpcProto {
            player_id?: (string|null);
            party_joined_ms?: (number|Long|null);
            party_left_ms?: (number|Long|null);
            avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class PartyParticipantHistoryRpcProto implements IPartyParticipantHistoryRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyParticipantHistoryRpcProto);
            public player_id: string;
            public party_joined_ms: (number|Long);
            public party_left_ms: (number|Long);
            public avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.IPartyParticipantHistoryRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyParticipantHistoryRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyParticipantHistoryRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyParticipantHistoryRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyParticipantProto {
            player_id?: (string|null);
            player_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            buddy_pokedex_id?: (number|null);
            buddy_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            position_index?: (number|null);
            is_host?: (boolean|null);
            nia_account_id?: (string|null);
            untrusted_location_samples?: (POGOProtos.Rpc.IPartyLocationSampleProto[]|null);
            is_minor?: (boolean|null);
            player_join_time_ms?: (number|Long|null);
            participant_raid_info?: (POGOProtos.Rpc.IPartyParticipantRaidInfoProto|null);
            participant_status?: (POGOProtos.Rpc.PartyParticipantProto.ParticipantStatus|null);
            inviter_id?: (string|null);
            invite_expiration_ms?: (number|Long|null);
        }

        class PartyParticipantProto implements IPartyParticipantProto {
            constructor(properties?: POGOProtos.Rpc.IPartyParticipantProto);
            public player_id: string;
            public player_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public buddy_pokedex_id: number;
            public buddy_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public position_index: number;
            public is_host: boolean;
            public nia_account_id: string;
            public untrusted_location_samples: POGOProtos.Rpc.IPartyLocationSampleProto[];
            public is_minor: boolean;
            public player_join_time_ms: (number|Long);
            public participant_raid_info?: (POGOProtos.Rpc.IPartyParticipantRaidInfoProto|null);
            public participant_status: POGOProtos.Rpc.PartyParticipantProto.ParticipantStatus;
            public inviter_id: string;
            public invite_expiration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPartyParticipantProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyParticipantProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyParticipantProto;
            public static toObject(message: POGOProtos.Rpc.PartyParticipantProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyParticipantProto {

            enum ParticipantStatus {
                PARTICIPANT_STATUS_UNSET = 0,
                PARTICIPANT_STATUS_PARTICIPANT_INVITED = 1,
                PARTICIPANT_STATUS_PARTICIPANT_ACTIVE = 2,
                PARTICIPANT_STATUS_PARTICIPANT_LEFT = 3
            }
        }

        interface IPartyParticipantRaidInfoProto {
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            latitude?: (number|null);
            longitude?: (number|null);
            lobby_creation_ms?: (number|Long|null);
            lobby_end_join_ms?: (number|Long|null);
        }

        class PartyParticipantRaidInfoProto implements IPartyParticipantRaidInfoProto {
            constructor(properties?: POGOProtos.Rpc.IPartyParticipantRaidInfoProto);
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            public latitude: number;
            public longitude: number;
            public lobby_creation_ms: (number|Long);
            public lobby_end_join_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPartyParticipantRaidInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyParticipantRaidInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyParticipantRaidInfoProto;
            public static toObject(message: POGOProtos.Rpc.PartyParticipantRaidInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyPlayGeneralSettingsProto {
            enabled?: (boolean|null);
            min_player_level?: (number|null);
            creation_to_start_timeout_ms?: (number|Long|null);
            compliance_zones_enabled?: (boolean|null);
            enable_party_raid_information?: (boolean|null);
            fallback_stardust_count?: (number|null);
            friend_requests_enabled?: (boolean|null);
            party_expiry_duration_ms?: (number|Long|null);
            party_expiry_warning_minutes?: (number|null);
            pokemon_catch_tags_enabled?: (boolean|null);
            enabled_friend_status_increase?: (boolean|null);
            restart_party_rejoin_prompt_enabled?: (boolean|null);
            party_iap_boosts_enabled?: (boolean|null);
            party_new_quest_notification_v2_enabled?: (boolean|null);
            pg_delivery_mechanic?: (POGOProtos.Rpc.PartyPlayGeneralSettingsProto.PgDeliveryMechanic|null);
            party_catch_tags_enabled?: (boolean|null);
            party_quest_encounter_reward_enabled?: (boolean|null);
            max_stacked_encounter_reward?: (number|null);
            remove_other_players_enabled?: (boolean|null);
            challenge_reward_display_enabled?: (boolean|null);
            fallback_party_quest_enabled?: (boolean|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
            min_num_players_to_start_party?: (number|null);
            max_party_size?: (number|null);
            daily_progress_heuristic?: (POGOProtos.Rpc.PartyPlayGeneralSettingsProto.DailyProgressHeuristic|null);
            party_scheduling_settings?: (POGOProtos.Rpc.PartyPlayGeneralSettingsProto.IPartySchedulingSettingsProto|null);
            concurent_party_limit?: (number|null);
            send_invite_enabled?: (boolean|null);
        }

        class PartyPlayGeneralSettingsProto implements IPartyPlayGeneralSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartyPlayGeneralSettingsProto);
            public enabled: boolean;
            public min_player_level: number;
            public creation_to_start_timeout_ms: (number|Long);
            public compliance_zones_enabled: boolean;
            public enable_party_raid_information: boolean;
            public fallback_stardust_count: number;
            public friend_requests_enabled: boolean;
            public party_expiry_duration_ms: (number|Long);
            public party_expiry_warning_minutes: number;
            public pokemon_catch_tags_enabled: boolean;
            public enabled_friend_status_increase: boolean;
            public restart_party_rejoin_prompt_enabled: boolean;
            public party_iap_boosts_enabled: boolean;
            public party_new_quest_notification_v2_enabled: boolean;
            public pg_delivery_mechanic: POGOProtos.Rpc.PartyPlayGeneralSettingsProto.PgDeliveryMechanic;
            public party_catch_tags_enabled: boolean;
            public party_quest_encounter_reward_enabled: boolean;
            public max_stacked_encounter_reward: number;
            public remove_other_players_enabled: boolean;
            public challenge_reward_display_enabled: boolean;
            public fallback_party_quest_enabled: boolean;
            public party_type: POGOProtos.Rpc.PartyType;
            public min_num_players_to_start_party: number;
            public max_party_size: number;
            public daily_progress_heuristic: POGOProtos.Rpc.PartyPlayGeneralSettingsProto.DailyProgressHeuristic;
            public party_scheduling_settings?: (POGOProtos.Rpc.PartyPlayGeneralSettingsProto.IPartySchedulingSettingsProto|null);
            public concurent_party_limit: number;
            public send_invite_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPartyPlayGeneralSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyPlayGeneralSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyPlayGeneralSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartyPlayGeneralSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyPlayGeneralSettingsProto {

            enum PgDeliveryMechanic {
                UNSET = 0,
                FULL_PARTY = 1,
                POLLING_BIT = 2,
                NON_AVATAR = 3
            }

            enum DailyProgressHeuristic {
                DAILY_PROGRESS_HEURISTIC_MECHANIC_UNSET = 0,
                DAILY_PROGRESS_HEURISTIC_COMMON_TWENTY_FOUR_HOUR_BUCKETS = 1,
                DAILY_PROGRESS_HEURISTIC_CALENDAR_DAY = 2
            }

            interface IPartySchedulingSettingsProto {
                recurring_challenge_schedule?: (POGOProtos.Rpc.IRecurringChallengeScheduleProto|null);
                party_expiry_duration_ms?: (number|Long|null);
            }

            class PartySchedulingSettingsProto implements IPartySchedulingSettingsProto {
                constructor(properties?: POGOProtos.Rpc.PartyPlayGeneralSettingsProto.IPartySchedulingSettingsProto);
                public recurring_challenge_schedule?: (POGOProtos.Rpc.IRecurringChallengeScheduleProto|null);
                public party_expiry_duration_ms?: (number|Long|null);
                public ScheduleType?: ("recurring_challenge_schedule"|"party_expiry_duration_ms");
                public static encode(message: POGOProtos.Rpc.PartyPlayGeneralSettingsProto.IPartySchedulingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyPlayGeneralSettingsProto.PartySchedulingSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyPlayGeneralSettingsProto.PartySchedulingSettingsProto;
                public static toObject(message: POGOProtos.Rpc.PartyPlayGeneralSettingsProto.PartySchedulingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPartyPlayGlobalSettingsProto {
            enable_parties?: (boolean|null);
            num_digits_in_id?: (number|null);
            push_gateway_enabled?: (boolean|null);
            push_gateway_namespace?: (string|null);
            max_party_members?: (number|null);
            enable_location_updates?: (boolean|null);
            client_location_min_distance_to_flush_mm?: (number|null);
            client_location_min_time_to_flush_ms?: (number|null);
            client_location_max_samples_per_request?: (number|null);
            location_sample_expiry_time_ms?: (number|null);
            enable_assembled_party_name_creator?: (boolean|null);
        }

        class PartyPlayGlobalSettingsProto implements IPartyPlayGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartyPlayGlobalSettingsProto);
            public enable_parties: boolean;
            public num_digits_in_id: number;
            public push_gateway_enabled: boolean;
            public push_gateway_namespace: string;
            public max_party_members: number;
            public enable_location_updates: boolean;
            public client_location_min_distance_to_flush_mm: number;
            public client_location_min_time_to_flush_ms: number;
            public client_location_max_samples_per_request: number;
            public location_sample_expiry_time_ms: number;
            public enable_assembled_party_name_creator: boolean;
            public static encode(message: POGOProtos.Rpc.IPartyPlayGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyPlayGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyPlayGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartyPlayGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyPlayInvitationDetails {
            party_id?: (number[]|null);
            inviter_id?: (string|null);
            inviter_nickname?: (string|null);
            inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            party_seed?: (number|Long|null);
            inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            id?: (number|Long|null);
        }

        class PartyPlayInvitationDetails implements IPartyPlayInvitationDetails {
            constructor(properties?: POGOProtos.Rpc.IPartyPlayInvitationDetails);
            public party_id: number[];
            public inviter_id: string;
            public inviter_nickname: string;
            public inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public party_seed: (number|Long);
            public inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPartyPlayInvitationDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyPlayInvitationDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyPlayInvitationDetails;
            public static toObject(message: POGOProtos.Rpc.PartyPlayInvitationDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyPlayPreferences {
            share_location?: (boolean|null);
            show_map_avatars?: (boolean|null);
        }

        class PartyPlayPreferences implements IPartyPlayPreferences {
            constructor(properties?: POGOProtos.Rpc.IPartyPlayPreferences);
            public share_location: boolean;
            public show_map_avatars: boolean;
            public static encode(message: POGOProtos.Rpc.IPartyPlayPreferences, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyPlayPreferences;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyPlayPreferences;
            public static toObject(message: POGOProtos.Rpc.PartyPlayPreferences, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyPlayerProfilePushProto {
            player_id?: (string|null);
            player_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
        }

        class PartyPlayerProfilePushProto implements IPartyPlayerProfilePushProto {
            constructor(properties?: POGOProtos.Rpc.IPartyPlayerProfilePushProto);
            public player_id: string;
            public player_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public static encode(message: POGOProtos.Rpc.IPartyPlayerProfilePushProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyPlayerProfilePushProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyPlayerProfilePushProto;
            public static toObject(message: POGOProtos.Rpc.PartyPlayerProfilePushProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyQuestRpcProto {
            status?: (POGOProtos.Rpc.PartyQuestStatus|null);
            party_quest_candidates?: (POGOProtos.Rpc.IClientQuestProto[]|null);
            active_quest_state?: (POGOProtos.Rpc.IPartyQuestStateProto|null);
            player_unclaimed_quest_ids?: (POGOProtos.Rpc.IPlayerUnclaimedPartyQuestIdsProto[]|null);
            completed_quest_states?: (POGOProtos.Rpc.IPartyQuestStateProto[]|null);
            quest_selection_end_ms?: (number|Long|null);
        }

        class PartyQuestRpcProto implements IPartyQuestRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyQuestRpcProto);
            public status: POGOProtos.Rpc.PartyQuestStatus;
            public party_quest_candidates: POGOProtos.Rpc.IClientQuestProto[];
            public active_quest_state?: (POGOProtos.Rpc.IPartyQuestStateProto|null);
            public player_unclaimed_quest_ids: POGOProtos.Rpc.IPlayerUnclaimedPartyQuestIdsProto[];
            public completed_quest_states: POGOProtos.Rpc.IPartyQuestStateProto[];
            public quest_selection_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPartyQuestRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyQuestRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyQuestRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyQuestRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyQuestStateProto {
            client_quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            shared_progress?: (number|null);
            player_quest_state?: ({ [k: string]: POGOProtos.Rpc.PartyQuestStateProto.IPlayerPartyQuestStateProto }|null);
            claim_rewards_deadline_ms?: (number|Long|null);
            player_quest_states?: (POGOProtos.Rpc.PartyQuestStateProto.IPlayerPartyQuestStateProto[]|null);
        }

        class PartyQuestStateProto implements IPartyQuestStateProto {
            constructor(properties?: POGOProtos.Rpc.IPartyQuestStateProto);
            public client_quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            public shared_progress: number;
            public player_quest_state: { [k: string]: POGOProtos.Rpc.PartyQuestStateProto.IPlayerPartyQuestStateProto };
            public claim_rewards_deadline_ms: (number|Long);
            public player_quest_states: POGOProtos.Rpc.PartyQuestStateProto.IPlayerPartyQuestStateProto[];
            public static encode(message: POGOProtos.Rpc.IPartyQuestStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyQuestStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyQuestStateProto;
            public static toObject(message: POGOProtos.Rpc.PartyQuestStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyQuestStateProto {

            interface IPlayerPartyQuestStateProto {
                player_status?: (POGOProtos.Rpc.PartyQuestStateProto.PlayerPartyQuestStateProto.PlayerStatus|null);
                individual_progress?: (number|null);
                player_id?: (string|null);
                update_timestamp_ms?: (number|Long|null);
                daily_progress?: (number|null);
                nia_account_id?: (string|null);
            }

            class PlayerPartyQuestStateProto implements IPlayerPartyQuestStateProto {
                constructor(properties?: POGOProtos.Rpc.PartyQuestStateProto.IPlayerPartyQuestStateProto);
                public player_status: POGOProtos.Rpc.PartyQuestStateProto.PlayerPartyQuestStateProto.PlayerStatus;
                public individual_progress: number;
                public player_id: string;
                public update_timestamp_ms: (number|Long);
                public daily_progress: number;
                public nia_account_id: string;
                public static encode(message: POGOProtos.Rpc.PartyQuestStateProto.IPlayerPartyQuestStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyQuestStateProto.PlayerPartyQuestStateProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyQuestStateProto.PlayerPartyQuestStateProto;
                public static toObject(message: POGOProtos.Rpc.PartyQuestStateProto.PlayerPartyQuestStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PlayerPartyQuestStateProto {

                enum PlayerStatus {
                    PLAYER_UNKNOWN = 0,
                    PLAYER_WAITING_PARTY_QUEST_TO_START = 1,
                    PLAYER_ACTIVE = 2,
                    PLAYER_COMPLETED_PARTY_QUEST_AND_AWARDED = 3,
                    PLAYER_ABANDONED_PARTY_QUEST = 4,
                    PLAYER_COMPLETED_PARTY_QUEST = 5,
                    PLAYER_AWARDED = 6
                }
            }
        }

        interface IPartyRecommendationSettingsProto {
            mode?: (POGOProtos.Rpc.PartyRecommendationSettingsProto.PartyRcommendationMode|null);
            variance?: (number|null);
            third_move_weight?: (number|null);
            mega_evo_combat_rating_scale?: (number|null);
            max_variance_count?: (number|null);
            allow_reroll?: (boolean|null);
        }

        class PartyRecommendationSettingsProto implements IPartyRecommendationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartyRecommendationSettingsProto);
            public mode: POGOProtos.Rpc.PartyRecommendationSettingsProto.PartyRcommendationMode;
            public variance: number;
            public third_move_weight: number;
            public mega_evo_combat_rating_scale: number;
            public max_variance_count: number;
            public allow_reroll: boolean;
            public static encode(message: POGOProtos.Rpc.IPartyRecommendationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyRecommendationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyRecommendationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartyRecommendationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyRecommendationSettingsProto {

            enum PartyRcommendationMode {
                UNSET = 0,
                PARTY_RECOMMENDATION_MODE_1 = 1,
                PARTY_RECOMMENDATION_MODE_2 = 2,
                PARTY_RECOMMENDATION_MODE_3 = 3,
                PARTY_RECOMMENDATION_MODE_4 = 4
            }
        }

        interface IPartyRpcProto {
            party_id?: (number[]|null);
            party_start_ms?: (number|Long|null);
            party_end_ms?: (number|Long|null);
            party_creation_ms?: (number|Long|null);
            party_seed?: (number|Long|null);
            id?: (number|Long|null);
            status?: (POGOProtos.Rpc.PartyStatus|null);
            party_summary_stats?: (POGOProtos.Rpc.IPartyActivityStatProto[]|null);
            party_start_deadline_ms?: (number|Long|null);
            party_quest_settings_snapshot?: (POGOProtos.Rpc.IPartySharedQuestSettingsProto|null);
            party_quest?: (POGOProtos.Rpc.IPartyQuestRpcProto|null);
            participant_list?: (POGOProtos.Rpc.IPartyParticipantProto[]|null);
            party_activity_summary_proto?: (POGOProtos.Rpc.IPartyActivitySummaryProto|null);
            participant_obfuscation_map?: (POGOProtos.Rpc.IPlayerObfuscationMapEntryProto[]|null);
            client_display_host_index?: (number|null);
            consummable_party_items?: (POGOProtos.Rpc.IPartyItemProto[]|null);
            removed_participants?: (POGOProtos.Rpc.IRemovedParticipant[]|null);
            banned_participants?: (string[]|null);
            consumed_party_items?: (POGOProtos.Rpc.IPartyItemProto[]|null);
            group_type?: (POGOProtos.Rpc.GroupType|null);
        }

        class PartyRpcProto implements IPartyRpcProto {
            constructor(properties?: POGOProtos.Rpc.IPartyRpcProto);
            public party_id: number[];
            public party_start_ms: (number|Long);
            public party_end_ms: (number|Long);
            public party_creation_ms: (number|Long);
            public party_seed: (number|Long);
            public id: (number|Long);
            public status: POGOProtos.Rpc.PartyStatus;
            public party_summary_stats: POGOProtos.Rpc.IPartyActivityStatProto[];
            public party_start_deadline_ms: (number|Long);
            public party_quest_settings_snapshot?: (POGOProtos.Rpc.IPartySharedQuestSettingsProto|null);
            public party_quest?: (POGOProtos.Rpc.IPartyQuestRpcProto|null);
            public participant_list: POGOProtos.Rpc.IPartyParticipantProto[];
            public party_activity_summary_proto?: (POGOProtos.Rpc.IPartyActivitySummaryProto|null);
            public participant_obfuscation_map: POGOProtos.Rpc.IPlayerObfuscationMapEntryProto[];
            public client_display_host_index: number;
            public consummable_party_items: POGOProtos.Rpc.IPartyItemProto[];
            public removed_participants: POGOProtos.Rpc.IRemovedParticipant[];
            public banned_participants: string[];
            public consumed_party_items: POGOProtos.Rpc.IPartyItemProto[];
            public group_type: POGOProtos.Rpc.GroupType;
            public static encode(message: POGOProtos.Rpc.IPartyRpcProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyRpcProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyRpcProto;
            public static toObject(message: POGOProtos.Rpc.PartyRpcProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartySendDarkLaunchLogOutProto {
            result?: (POGOProtos.Rpc.PartySendDarkLaunchLogOutProto.Result|null);
        }

        class PartySendDarkLaunchLogOutProto implements IPartySendDarkLaunchLogOutProto {
            constructor(properties?: POGOProtos.Rpc.IPartySendDarkLaunchLogOutProto);
            public result: POGOProtos.Rpc.PartySendDarkLaunchLogOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IPartySendDarkLaunchLogOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartySendDarkLaunchLogOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartySendDarkLaunchLogOutProto;
            public static toObject(message: POGOProtos.Rpc.PartySendDarkLaunchLogOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartySendDarkLaunchLogOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DARK_LAUNCH_NOT_ENABLED_FOR_PLAYER = 2
            }
        }

        interface IPartySendDarkLaunchLogProto {
            log_messages?: (POGOProtos.Rpc.IPartyDarkLaunchLogMessageProto[]|null);
        }

        class PartySendDarkLaunchLogProto implements IPartySendDarkLaunchLogProto {
            constructor(properties?: POGOProtos.Rpc.IPartySendDarkLaunchLogProto);
            public log_messages: POGOProtos.Rpc.IPartyDarkLaunchLogMessageProto[];
            public static encode(message: POGOProtos.Rpc.IPartySendDarkLaunchLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartySendDarkLaunchLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartySendDarkLaunchLogProto;
            public static toObject(message: POGOProtos.Rpc.PartySendDarkLaunchLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartySharedQuestSettingsProto {
            num_generated_shared_quests?: (number|null);
            num_candidate_shared_quests?: (number|null);
            shared_quest_selection_timeout_s?: (number|null);
            shared_quest_claim_rewards_timeout_s?: (number|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
            party_quest_context_type?: (POGOProtos.Rpc.QuestProto.Context|null);
        }

        class PartySharedQuestSettingsProto implements IPartySharedQuestSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartySharedQuestSettingsProto);
            public num_generated_shared_quests: number;
            public num_candidate_shared_quests: number;
            public shared_quest_selection_timeout_s: number;
            public shared_quest_claim_rewards_timeout_s: number;
            public party_type: POGOProtos.Rpc.PartyType;
            public party_quest_context_type: POGOProtos.Rpc.QuestProto.Context;
            public static encode(message: POGOProtos.Rpc.IPartySharedQuestSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartySharedQuestSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartySharedQuestSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartySharedQuestSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartySummarySettingsProto {
            player_activities?: (POGOProtos.Rpc.IPartyActivityStatProto[]|null);
        }

        class PartySummarySettingsProto implements IPartySummarySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPartySummarySettingsProto);
            public player_activities: POGOProtos.Rpc.IPartyActivityStatProto[];
            public static encode(message: POGOProtos.Rpc.IPartySummarySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartySummarySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartySummarySettingsProto;
            public static toObject(message: POGOProtos.Rpc.PartySummarySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyUpdateLocationOutProto {
            result?: (POGOProtos.Rpc.PartyUpdateLocationOutProto.Result|null);
        }

        class PartyUpdateLocationOutProto implements IPartyUpdateLocationOutProto {
            constructor(properties?: POGOProtos.Rpc.IPartyUpdateLocationOutProto);
            public result: POGOProtos.Rpc.PartyUpdateLocationOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IPartyUpdateLocationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyUpdateLocationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyUpdateLocationOutProto;
            public static toObject(message: POGOProtos.Rpc.PartyUpdateLocationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PartyUpdateLocationOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FEATURE_DISABLED = 3,
                ERROR_NOT_IN_PARTY = 4,
                ERROR_REDIS_EXCEPTION = 5,
                ERROR_LOCATION_RECORD_NOT_FOUND = 6,
                ERROR_PLFE_REDIRECT_NEEDED = 7,
                ERROR_UNEXPECTED_PARTY_TYPE = 8
            }
        }

        interface IPartyUpdateLocationProto {
            untrusted_sample_list?: (POGOProtos.Rpc.IPartyLocationSampleProto[]|null);
            is_dark_launch_request?: (boolean|null);
            is_location_sharing_disabled?: (boolean|null);
        }

        class PartyUpdateLocationProto implements IPartyUpdateLocationProto {
            constructor(properties?: POGOProtos.Rpc.IPartyUpdateLocationProto);
            public untrusted_sample_list: POGOProtos.Rpc.IPartyLocationSampleProto[];
            public is_dark_launch_request: boolean;
            public is_location_sharing_disabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPartyUpdateLocationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyUpdateLocationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyUpdateLocationProto;
            public static toObject(message: POGOProtos.Rpc.PartyUpdateLocationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyZoneDefinitionProto {
            zone?: (POGOProtos.Rpc.PlayerZoneCompliance|null);
            zone_radius_m?: (number|null);
            party_status?: (POGOProtos.Rpc.PartyStatus|null);
        }

        class PartyZoneDefinitionProto implements IPartyZoneDefinitionProto {
            constructor(properties?: POGOProtos.Rpc.IPartyZoneDefinitionProto);
            public zone: POGOProtos.Rpc.PlayerZoneCompliance;
            public zone_radius_m: number;
            public party_status: POGOProtos.Rpc.PartyStatus;
            public static encode(message: POGOProtos.Rpc.IPartyZoneDefinitionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyZoneDefinitionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyZoneDefinitionProto;
            public static toObject(message: POGOProtos.Rpc.PartyZoneDefinitionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPartyZonePushProto {
            player_id?: (string|null);
            player_compliance_zone?: (POGOProtos.Rpc.PlayerZoneCompliance|null);
            zone_update_timestamp_ms?: (number|Long|null);
        }

        class PartyZonePushProto implements IPartyZonePushProto {
            constructor(properties?: POGOProtos.Rpc.IPartyZonePushProto);
            public player_id: string;
            public player_compliance_zone: POGOProtos.Rpc.PlayerZoneCompliance;
            public zone_update_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPartyZonePushProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PartyZonePushProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PartyZonePushProto;
            public static toObject(message: POGOProtos.Rpc.PartyZonePushProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPasscodeRedeemTelemetry {
            result?: (string|null);
            passcode?: (string|null);
            country_code?: (string|null);
            language_code?: (string|null);
            bundle_version?: (string|null);
        }

        class PasscodeRedeemTelemetry implements IPasscodeRedeemTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPasscodeRedeemTelemetry);
            public result: string;
            public passcode: string;
            public country_code: string;
            public language_code: string;
            public bundle_version: string;
            public static encode(message: POGOProtos.Rpc.IPasscodeRedeemTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PasscodeRedeemTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PasscodeRedeemTelemetry;
            public static toObject(message: POGOProtos.Rpc.PasscodeRedeemTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPasscodeRedemptionFlowRequest {
            passcode?: (string|null);
            poi_guid?: (string|null);
            device_platform?: (POGOProtos.Rpc.PasscodeRedemptionFlowRequest.DevicePlatform|null);
            carrier?: (string|null);
        }

        class PasscodeRedemptionFlowRequest implements IPasscodeRedemptionFlowRequest {
            constructor(properties?: POGOProtos.Rpc.IPasscodeRedemptionFlowRequest);
            public passcode: string;
            public poi_guid: string;
            public device_platform: POGOProtos.Rpc.PasscodeRedemptionFlowRequest.DevicePlatform;
            public carrier: string;
            public static encode(message: POGOProtos.Rpc.IPasscodeRedemptionFlowRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PasscodeRedemptionFlowRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PasscodeRedemptionFlowRequest;
            public static toObject(message: POGOProtos.Rpc.PasscodeRedemptionFlowRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PasscodeRedemptionFlowRequest {

            enum DevicePlatform {
                PLATFORM_UNKNOWN = 0,
                PLATFORM_ANDROID = 1,
                PLATFORM_IOS = 2,
                PLATFORM_WEB = 3
            }
        }

        interface IPasscodeRedemptionFlowResponse {
            status?: (POGOProtos.Rpc.PasscodeRedemptionFlowResponse.Status|null);
            inventory_check_failed_reason?: (number|null);
            rewards?: (POGOProtos.Rpc.PasscodeRedemptionFlowResponse.IReward[]|null);
            passcode_batch_id?: (string|null);
            in_game_reward?: (Uint8Array|null);
        }

        class PasscodeRedemptionFlowResponse implements IPasscodeRedemptionFlowResponse {
            constructor(properties?: POGOProtos.Rpc.IPasscodeRedemptionFlowResponse);
            public status: POGOProtos.Rpc.PasscodeRedemptionFlowResponse.Status;
            public inventory_check_failed_reason: number;
            public rewards: POGOProtos.Rpc.PasscodeRedemptionFlowResponse.IReward[];
            public passcode_batch_id: string;
            public in_game_reward: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IPasscodeRedemptionFlowResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PasscodeRedemptionFlowResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PasscodeRedemptionFlowResponse;
            public static toObject(message: POGOProtos.Rpc.PasscodeRedemptionFlowResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PasscodeRedemptionFlowResponse {

            enum Status {
                STATUS_UNKNOWN = 0,
                STATUS_SUCCESS = 1,
                STATUS_ALREADY_REDEEMED = 2,
                STATUS_FAILED_INVENTORY_CHECK = 3,
                STATUS_OUT_OF_RANGE = 4,
                STATUS_WRONG_LOCATION = 5,
                STATUS_RATE_LIMITED = 6,
                STATUS_INVALID = 7,
                STATUS_FULLY_REDEEMED = 8,
                STATUS_EXPIRED = 9
            }

            interface IReward {
                item?: (string|null);
                count?: (number|null);
            }

            class Reward implements IReward {
                constructor(properties?: POGOProtos.Rpc.PasscodeRedemptionFlowResponse.IReward);
                public item: string;
                public count: number;
                public static encode(message: POGOProtos.Rpc.PasscodeRedemptionFlowResponse.IReward, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PasscodeRedemptionFlowResponse.Reward;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PasscodeRedemptionFlowResponse.Reward;
                public static toObject(message: POGOProtos.Rpc.PasscodeRedemptionFlowResponse.Reward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPasscodeRewardsLogEntry {
            result?: (POGOProtos.Rpc.PasscodeRewardsLogEntry.Result|null);
            passcode?: (string|null);
            rewards?: (POGOProtos.Rpc.IRedeemPasscodeRewardProto|null);
        }

        class PasscodeRewardsLogEntry implements IPasscodeRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IPasscodeRewardsLogEntry);
            public result: POGOProtos.Rpc.PasscodeRewardsLogEntry.Result;
            public passcode: string;
            public rewards?: (POGOProtos.Rpc.IRedeemPasscodeRewardProto|null);
            public static encode(message: POGOProtos.Rpc.IPasscodeRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PasscodeRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PasscodeRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.PasscodeRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PasscodeRewardsLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IPasscodeSettingsProto {
            show_passcode_in_store?: (boolean|null);
            use_passcode_v2?: (boolean|null);
        }

        class PasscodeSettingsProto implements IPasscodeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPasscodeSettingsProto);
            public show_passcode_in_store: boolean;
            public use_passcode_v2: boolean;
            public static encode(message: POGOProtos.Rpc.IPasscodeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PasscodeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PasscodeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PasscodeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPerStatTrainingCourseQuestProto {
            quest?: (POGOProtos.Rpc.IQuestProto|null);
            associated_stat_level?: (number|null);
            quest_display?: (POGOProtos.Rpc.IQuestDisplayProto|null);
        }

        class PerStatTrainingCourseQuestProto implements IPerStatTrainingCourseQuestProto {
            constructor(properties?: POGOProtos.Rpc.IPerStatTrainingCourseQuestProto);
            public quest?: (POGOProtos.Rpc.IQuestProto|null);
            public associated_stat_level: number;
            public quest_display?: (POGOProtos.Rpc.IQuestDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IPerStatTrainingCourseQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PerStatTrainingCourseQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PerStatTrainingCourseQuestProto;
            public static toObject(message: POGOProtos.Rpc.PerStatTrainingCourseQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPercentScrolledTelemetry {
            percent?: (number|null);
            menu_name?: (string|null);
        }

        class PercentScrolledTelemetry implements IPercentScrolledTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPercentScrolledTelemetry);
            public percent: number;
            public menu_name: string;
            public static encode(message: POGOProtos.Rpc.IPercentScrolledTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PercentScrolledTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PercentScrolledTelemetry;
            public static toObject(message: POGOProtos.Rpc.PercentScrolledTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPermissionsFlowTelemetry {
            permission_context_telemetry_ids?: (POGOProtos.Rpc.PermissionContextTelemetryIds|null);
            device_service_telemetry_ids?: (POGOProtos.Rpc.DeviceServiceTelemetryIds|null);
            permission_flow_step_telemetry_ids?: (POGOProtos.Rpc.PermissionFlowStepTelemetryIds|null);
            success?: (boolean|null);
        }

        class PermissionsFlowTelemetry implements IPermissionsFlowTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPermissionsFlowTelemetry);
            public permission_context_telemetry_ids: POGOProtos.Rpc.PermissionContextTelemetryIds;
            public device_service_telemetry_ids: POGOProtos.Rpc.DeviceServiceTelemetryIds;
            public permission_flow_step_telemetry_ids: POGOProtos.Rpc.PermissionFlowStepTelemetryIds;
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.IPermissionsFlowTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PermissionsFlowTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PermissionsFlowTelemetry;
            public static toObject(message: POGOProtos.Rpc.PermissionsFlowTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPgoAsyncFileUploadCompleteProto {
            power_up_points_added?: (number|null);
            power_up_progress_points?: (number|null);
            power_up_level_expiration_ms?: (number|Long|null);
            next_fort_close_ms?: (number|Long|null);
        }

        class PgoAsyncFileUploadCompleteProto implements IPgoAsyncFileUploadCompleteProto {
            constructor(properties?: POGOProtos.Rpc.IPgoAsyncFileUploadCompleteProto);
            public power_up_points_added: number;
            public power_up_progress_points: number;
            public power_up_level_expiration_ms: (number|Long);
            public next_fort_close_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPgoAsyncFileUploadCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PgoAsyncFileUploadCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PgoAsyncFileUploadCompleteProto;
            public static toObject(message: POGOProtos.Rpc.PgoAsyncFileUploadCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPhotoSetPokemonInfoProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class PhotoSetPokemonInfoProto implements IPhotoSetPokemonInfoProto {
            constructor(properties?: POGOProtos.Rpc.IPhotoSetPokemonInfoProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IPhotoSetPokemonInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PhotoSetPokemonInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PhotoSetPokemonInfoProto;
            public static toObject(message: POGOProtos.Rpc.PhotoSetPokemonInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPhotoSettingsProto {
            screen_capture_size?: (number|null);
            is_iris_enabled?: (boolean|null);
            is_iris_autoplace_enabled?: (boolean|null);
            is_iris_social_enabled?: (boolean|null);
            iris_flags?: (number|null);
            playback_cloud_id?: (string|null);
            playback_cloud_secret?: (string|null);
            playback_could_bucket_name?: (string|null);
            banner_image_url?: (string[]|null);
            banner_image_text?: (string[]|null);
            ftue_version?: (POGOProtos.Rpc.IrisFtueVersion|null);
            thermal_monitor_enabled?: (boolean|null);
        }

        class PhotoSettingsProto implements IPhotoSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPhotoSettingsProto);
            public screen_capture_size: number;
            public is_iris_enabled: boolean;
            public is_iris_autoplace_enabled: boolean;
            public is_iris_social_enabled: boolean;
            public iris_flags: number;
            public playback_cloud_id: string;
            public playback_cloud_secret: string;
            public playback_could_bucket_name: string;
            public banner_image_url: string[];
            public banner_image_text: string[];
            public ftue_version: POGOProtos.Rpc.IrisFtueVersion;
            public thermal_monitor_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPhotoSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PhotoSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PhotoSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PhotoSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPhotobombCreateDetail {
            caught_in_photobomb?: (boolean|null);
        }

        class PhotobombCreateDetail implements IPhotobombCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IPhotobombCreateDetail);
            public caught_in_photobomb: boolean;
            public static encode(message: POGOProtos.Rpc.IPhotobombCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PhotobombCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PhotobombCreateDetail;
            public static toObject(message: POGOProtos.Rpc.PhotobombCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPinData {
            pin_id?: (string|null);
            view_timestamp?: (number|Long|null);
            liked_timestamp?: (number|Long|null);
            sticker_timestamp?: (number|Long|null);
        }

        class PinData implements IPinData {
            constructor(properties?: POGOProtos.Rpc.IPinData);
            public pin_id: string;
            public view_timestamp: (number|Long);
            public liked_timestamp: (number|Long);
            public sticker_timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPinData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PinData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PinData;
            public static toObject(message: POGOProtos.Rpc.PinData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPinMessage {
            key?: (string|null);
            category?: (POGOProtos.Rpc.PinCategory[]|null);
            level_required?: (number|null);
        }

        class PinMessage implements IPinMessage {
            constructor(properties?: POGOProtos.Rpc.IPinMessage);
            public key: string;
            public category: POGOProtos.Rpc.PinCategory[];
            public level_required: number;
            public static encode(message: POGOProtos.Rpc.IPinMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PinMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PinMessage;
            public static toObject(message: POGOProtos.Rpc.PinMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPingRequestProto {
            response_size_bytes?: (number|null);
            random_request_bytes?: (string|null);
            use_cache_for_random_request_bytes?: (boolean|null);
            return_value?: (string|null);
        }

        class PingRequestProto implements IPingRequestProto {
            constructor(properties?: POGOProtos.Rpc.IPingRequestProto);
            public response_size_bytes: number;
            public random_request_bytes: string;
            public use_cache_for_random_request_bytes: boolean;
            public return_value: string;
            public static encode(message: POGOProtos.Rpc.IPingRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PingRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PingRequestProto;
            public static toObject(message: POGOProtos.Rpc.PingRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPingResponseProto {
            user_info?: (string|null);
            server_info?: (string|null);
            random_response_bytes?: (string|null);
            return_value?: (string|null);
        }

        class PingResponseProto implements IPingResponseProto {
            constructor(properties?: POGOProtos.Rpc.IPingResponseProto);
            public user_info: string;
            public server_info: string;
            public random_response_bytes: string;
            public return_value: string;
            public static encode(message: POGOProtos.Rpc.IPingResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PingResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PingResponseProto;
            public static toObject(message: POGOProtos.Rpc.PingResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlaceProto {
            names?: (string[]|null);
            street?: (string|null);
            neighborhood?: (string|null);
            city?: (string|null);
            state?: (string|null);
            postal_code?: (string|null);
            country?: (string|null);
            country_code?: (string|null);
        }

        class PlaceProto implements IPlaceProto {
            constructor(properties?: POGOProtos.Rpc.IPlaceProto);
            public names: string[];
            public street: string;
            public neighborhood: string;
            public city: string;
            public state: string;
            public postal_code: string;
            public country: string;
            public country_code: string;
            public static encode(message: POGOProtos.Rpc.IPlaceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlaceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlaceProto;
            public static toObject(message: POGOProtos.Rpc.PlaceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlacedPokemonUpdateProto {
            update_type?: (POGOProtos.Rpc.PlacedPokemonUpdateProto.PlacementUpdateType|null);
            updated_pokemon_placement?: (POGOProtos.Rpc.IIrisPokemonObjectProto|null);
        }

        class PlacedPokemonUpdateProto implements IPlacedPokemonUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IPlacedPokemonUpdateProto);
            public update_type: POGOProtos.Rpc.PlacedPokemonUpdateProto.PlacementUpdateType;
            public updated_pokemon_placement?: (POGOProtos.Rpc.IIrisPokemonObjectProto|null);
            public static encode(message: POGOProtos.Rpc.IPlacedPokemonUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlacedPokemonUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlacedPokemonUpdateProto;
            public static toObject(message: POGOProtos.Rpc.PlacedPokemonUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlacedPokemonUpdateProto {

            enum PlacementUpdateType {
                UNSET = 0,
                ADD = 1,
                EDIT = 2,
                REMOVE = 3
            }
        }

        interface IPlaceholderMessage {
            placeholder?: (string|null);
        }

        class PlaceholderMessage implements IPlaceholderMessage {
            constructor(properties?: POGOProtos.Rpc.IPlaceholderMessage);
            public placeholder: string;
            public static encode(message: POGOProtos.Rpc.IPlaceholderMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlaceholderMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlaceholderMessage;
            public static toObject(message: POGOProtos.Rpc.PlaceholderMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlacementAccuracy {
            horizontal_sdmeters?: (number|null);
            vertical_sdmeters?: (number|null);
            horizontal_angle_sdrads?: (number|null);
            vertical_angle_sdrads?: (number|null);
        }

        class PlacementAccuracy implements IPlacementAccuracy {
            constructor(properties?: POGOProtos.Rpc.IPlacementAccuracy);
            public horizontal_sdmeters: number;
            public vertical_sdmeters: number;
            public horizontal_angle_sdrads: number;
            public vertical_angle_sdrads: number;
            public static encode(message: POGOProtos.Rpc.IPlacementAccuracy, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlacementAccuracy;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlacementAccuracy;
            public static toObject(message: POGOProtos.Rpc.PlacementAccuracy, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlannedDowntimeSettingsProto {
            downtime_timestamp_ms?: (number|Long|null);
            no_actions_window_sec_from_downtime?: (number|Long|null);
        }

        class PlannedDowntimeSettingsProto implements IPlannedDowntimeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPlannedDowntimeSettingsProto);
            public downtime_timestamp_ms: (number|Long);
            public no_actions_window_sec_from_downtime: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlannedDowntimeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlannedDowntimeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlannedDowntimeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PlannedDowntimeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlannedEventSettingsProto {
            event_type?: (POGOProtos.Rpc.PlannedEventSettingsProto.EventType|null);
            timeslot_gap_seconds?: (number|null);
            rsvp_timeslot_duration_seconds?: (number|null);
            rsvp_closes_before_event_seconds?: (number|null);
            new_nearby_menu_enabled?: (boolean|null);
            upcoming_rsvp_warning_seconds?: (number|null);
            max_timeslots?: (number|null);
            rsvp_closes_before_timeslot_seconds?: (number|null);
            rsvp_clear_inventory_minutes?: (number|null);
            message_timing?: (POGOProtos.Rpc.PlannedEventSettingsProto.IEventMessageTimingProto[]|null);
            rsvp_bonus_time_window_minutes?: (number|null);
        }

        class PlannedEventSettingsProto implements IPlannedEventSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPlannedEventSettingsProto);
            public event_type: POGOProtos.Rpc.PlannedEventSettingsProto.EventType;
            public timeslot_gap_seconds: number;
            public rsvp_timeslot_duration_seconds: number;
            public rsvp_closes_before_event_seconds: number;
            public new_nearby_menu_enabled: boolean;
            public upcoming_rsvp_warning_seconds: number;
            public max_timeslots: number;
            public rsvp_closes_before_timeslot_seconds: number;
            public rsvp_clear_inventory_minutes: number;
            public message_timing: POGOProtos.Rpc.PlannedEventSettingsProto.IEventMessageTimingProto[];
            public rsvp_bonus_time_window_minutes: number;
            public static encode(message: POGOProtos.Rpc.IPlannedEventSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlannedEventSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlannedEventSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PlannedEventSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlannedEventSettingsProto {

            enum EventType {
                RAID = 0,
                GMAX = 1
            }

            enum MessagingTimingType {
                UNSET = 0,
                TIMESLOT_START = 1,
                TIMESLOT_EARLY = 2
            }

            interface IEventMessageTimingProto {
                message_send_before_event_seconds?: (number|null);
                message_send_time?: (POGOProtos.Rpc.PlannedEventSettingsProto.MessagingTimingType|null);
            }

            class EventMessageTimingProto implements IEventMessageTimingProto {
                constructor(properties?: POGOProtos.Rpc.PlannedEventSettingsProto.IEventMessageTimingProto);
                public message_send_before_event_seconds: number;
                public message_send_time: POGOProtos.Rpc.PlannedEventSettingsProto.MessagingTimingType;
                public static encode(message: POGOProtos.Rpc.PlannedEventSettingsProto.IEventMessageTimingProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlannedEventSettingsProto.EventMessageTimingProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlannedEventSettingsProto.EventMessageTimingProto;
                public static toObject(message: POGOProtos.Rpc.PlannedEventSettingsProto.EventMessageTimingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPlannerSettingsProto {
            enabled?: (boolean|null);
            event_settings?: (POGOProtos.Rpc.IPlannedEventSettingsProto[]|null);
            new_nearby_menu_enabled?: (boolean|null);
            max_rsvps_per_trainer?: (number|null);
            max_rsvp_invites?: (number|null);
            max_pending_rsvp_invites?: (number|null);
            nearby_rsvp_tab_enabled?: (boolean|null);
            rsvp_count_push_gateway_namespace?: (string|null);
            send_rsvp_invite_enabled?: (boolean|null);
            max_rsvp_display_distance_m?: (number|null);
            active_reminder_time_seconds?: (number|null);
            rsvp_count_geo_push_gateway_namespace?: (string|null);
            rsvp_count_update_time_seconds?: (number|null);
            rsvp_count_topper_polling_time_seconds?: (number|null);
        }

        class PlannerSettingsProto implements IPlannerSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPlannerSettingsProto);
            public enabled: boolean;
            public event_settings: POGOProtos.Rpc.IPlannedEventSettingsProto[];
            public new_nearby_menu_enabled: boolean;
            public max_rsvps_per_trainer: number;
            public max_rsvp_invites: number;
            public max_pending_rsvp_invites: number;
            public nearby_rsvp_tab_enabled: boolean;
            public rsvp_count_push_gateway_namespace: string;
            public send_rsvp_invite_enabled: boolean;
            public max_rsvp_display_distance_m: number;
            public active_reminder_time_seconds: number;
            public rsvp_count_geo_push_gateway_namespace: string;
            public rsvp_count_update_time_seconds: number;
            public rsvp_count_topper_polling_time_seconds: number;
            public static encode(message: POGOProtos.Rpc.IPlannerSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlannerSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlannerSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PlannerSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformClientTelemetryOmniProto {
            socket_connection_telemetry?: (POGOProtos.Rpc.ISocketConnectionEvent|null);
            rpc_latency_telemetry?: (POGOProtos.Rpc.IRpcLatencyEvent|null);
            inbox_route_error_telemetry?: (POGOProtos.Rpc.IInboxRouteErrorEvent|null);
            core_handshake_telemetry?: (POGOProtos.Rpc.ICoreHandshakeTelemetryEvent|null);
            core_safetynet_telemetry?: (POGOProtos.Rpc.ICoreSafetynetTelemetryEvent|null);
            server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
        }

        class PlatformClientTelemetryOmniProto implements IPlatformClientTelemetryOmniProto {
            constructor(properties?: POGOProtos.Rpc.IPlatformClientTelemetryOmniProto);
            public socket_connection_telemetry?: (POGOProtos.Rpc.ISocketConnectionEvent|null);
            public rpc_latency_telemetry?: (POGOProtos.Rpc.IRpcLatencyEvent|null);
            public inbox_route_error_telemetry?: (POGOProtos.Rpc.IInboxRouteErrorEvent|null);
            public core_handshake_telemetry?: (POGOProtos.Rpc.ICoreHandshakeTelemetryEvent|null);
            public core_safetynet_telemetry?: (POGOProtos.Rpc.ICoreSafetynetTelemetryEvent|null);
            public server_data?: (POGOProtos.Rpc.IServerRecordMetadata|null);
            public PlatformClientTelemetryData?: ("socket_connection_telemetry"|"rpc_latency_telemetry"|"inbox_route_error_telemetry"|"core_handshake_telemetry"|"core_safetynet_telemetry");
            public static encode(message: POGOProtos.Rpc.IPlatformClientTelemetryOmniProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformClientTelemetryOmniProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformClientTelemetryOmniProto;
            public static toObject(message: POGOProtos.Rpc.PlatformClientTelemetryOmniProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformCommonFilterProto {
            application_identifier?: (string|null);
            operating_system_name?: (string|null);
            device_model?: (string|null);
            locale_country_code?: (string|null);
            locale_language_code?: (string|null);
            sampling_probability?: (number|null);
            quality_level?: (string|null);
            network_connectivity_type?: (string|null);
            game_context?: (string|null);
            language_code?: (string|null);
            timezone?: (string|null);
            ip_country_code?: (string|null);
            client_version?: (string|null);
            graphics_device_vendor?: (string|null);
            graphics_device_name?: (string|null);
            graphics_device_type?: (string|null);
            graphics_shader_level?: (string|null);
        }

        class PlatformCommonFilterProto implements IPlatformCommonFilterProto {
            constructor(properties?: POGOProtos.Rpc.IPlatformCommonFilterProto);
            public application_identifier: string;
            public operating_system_name: string;
            public device_model: string;
            public locale_country_code: string;
            public locale_language_code: string;
            public sampling_probability: number;
            public quality_level: string;
            public network_connectivity_type: string;
            public game_context: string;
            public language_code: string;
            public timezone: string;
            public ip_country_code: string;
            public client_version: string;
            public graphics_device_vendor: string;
            public graphics_device_name: string;
            public graphics_device_type: string;
            public graphics_shader_level: string;
            public static encode(message: POGOProtos.Rpc.IPlatformCommonFilterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformCommonFilterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformCommonFilterProto;
            public static toObject(message: POGOProtos.Rpc.PlatformCommonFilterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformFetchNewsfeedOutResponse {
            status?: (POGOProtos.Rpc.PlatformFetchNewsfeedOutResponse.Status|null);
            post_record?: (POGOProtos.Rpc.INewsfeedPostRecord[]|null);
        }

        class PlatformFetchNewsfeedOutResponse implements IPlatformFetchNewsfeedOutResponse {
            constructor(properties?: POGOProtos.Rpc.IPlatformFetchNewsfeedOutResponse);
            public status: POGOProtos.Rpc.PlatformFetchNewsfeedOutResponse.Status;
            public post_record: POGOProtos.Rpc.INewsfeedPostRecord[];
            public static encode(message: POGOProtos.Rpc.IPlatformFetchNewsfeedOutResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformFetchNewsfeedOutResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformFetchNewsfeedOutResponse;
            public static toObject(message: POGOProtos.Rpc.PlatformFetchNewsfeedOutResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlatformFetchNewsfeedOutResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IPlatformFetchNewsfeedRequest {
            newsfeed_channel?: (POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel[]|null);
            language_version?: (string|null);
            country_code?: (string|null);
            local_timezone?: (string|null);
        }

        class PlatformFetchNewsfeedRequest implements IPlatformFetchNewsfeedRequest {
            constructor(properties?: POGOProtos.Rpc.IPlatformFetchNewsfeedRequest);
            public newsfeed_channel: POGOProtos.Rpc.NewsfeedPost.NewsfeedChannel[];
            public language_version: string;
            public country_code: string;
            public local_timezone: string;
            public static encode(message: POGOProtos.Rpc.IPlatformFetchNewsfeedRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformFetchNewsfeedRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformFetchNewsfeedRequest;
            public static toObject(message: POGOProtos.Rpc.PlatformFetchNewsfeedRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformMarkNewsfeedReadOutResponse {
            status?: (POGOProtos.Rpc.PlatformMarkNewsfeedReadOutResponse.Status|null);
            post_record?: (POGOProtos.Rpc.INewsfeedPostRecord[]|null);
        }

        class PlatformMarkNewsfeedReadOutResponse implements IPlatformMarkNewsfeedReadOutResponse {
            constructor(properties?: POGOProtos.Rpc.IPlatformMarkNewsfeedReadOutResponse);
            public status: POGOProtos.Rpc.PlatformMarkNewsfeedReadOutResponse.Status;
            public post_record: POGOProtos.Rpc.INewsfeedPostRecord[];
            public static encode(message: POGOProtos.Rpc.IPlatformMarkNewsfeedReadOutResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformMarkNewsfeedReadOutResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformMarkNewsfeedReadOutResponse;
            public static toObject(message: POGOProtos.Rpc.PlatformMarkNewsfeedReadOutResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlatformMarkNewsfeedReadOutResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IPlatformMarkNewsfeedReadRequest {
            newsfeed_post_id?: (string[]|null);
        }

        class PlatformMarkNewsfeedReadRequest implements IPlatformMarkNewsfeedReadRequest {
            constructor(properties?: POGOProtos.Rpc.IPlatformMarkNewsfeedReadRequest);
            public newsfeed_post_id: string[];
            public static encode(message: POGOProtos.Rpc.IPlatformMarkNewsfeedReadRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformMarkNewsfeedReadRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformMarkNewsfeedReadRequest;
            public static toObject(message: POGOProtos.Rpc.PlatformMarkNewsfeedReadRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformMetricData {
            long_value?: (number|Long|null);
            double_value?: (number|null);
            boolean_value?: (boolean|null);
            distribution?: (POGOProtos.Rpc.IDistribution|null);
            common_telemetry?: (POGOProtos.Rpc.ITelemetryCommon|null);
            metric_kind?: (POGOProtos.Rpc.PlatformMetricData.Kind|null);
        }

        class PlatformMetricData implements IPlatformMetricData {
            constructor(properties?: POGOProtos.Rpc.IPlatformMetricData);
            public long_value?: (number|Long|null);
            public double_value?: (number|null);
            public boolean_value?: (boolean|null);
            public distribution?: (POGOProtos.Rpc.IDistribution|null);
            public common_telemetry?: (POGOProtos.Rpc.ITelemetryCommon|null);
            public metric_kind: POGOProtos.Rpc.PlatformMetricData.Kind;
            public DatapointValue?: ("long_value"|"double_value"|"boolean_value"|"distribution");
            public static encode(message: POGOProtos.Rpc.IPlatformMetricData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformMetricData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformMetricData;
            public static toObject(message: POGOProtos.Rpc.PlatformMetricData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlatformMetricData {

            enum Kind {
                UNSPECIFIED = 0,
                GAUGE = 1,
                DELTA = 2,
                CUMULATIVE = 3
            }
        }

        interface IPlatformPlayerInfo {
            identity_provider?: (string|null);
            profile_creation_timestamp_ms?: (number|Long|null);
            player_level?: (number|null);
            team_id?: (number|null);
            lifetime_km_walked?: (number|null);
            lifetime_steps_walked?: (number|Long|null);
        }

        class PlatformPlayerInfo implements IPlatformPlayerInfo {
            constructor(properties?: POGOProtos.Rpc.IPlatformPlayerInfo);
            public identity_provider: string;
            public profile_creation_timestamp_ms: (number|Long);
            public player_level: number;
            public team_id: number;
            public lifetime_km_walked: number;
            public lifetime_steps_walked: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlatformPlayerInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformPlayerInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformPlayerInfo;
            public static toObject(message: POGOProtos.Rpc.PlatformPlayerInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformPreAgeGateTrackingOmniproto {
            age_gate_startup?: (POGOProtos.Rpc.IAgeGateStartup|null);
            age_gate_result?: (POGOProtos.Rpc.IAgeGateResult|null);
            pre_age_gate_metadata?: (POGOProtos.Rpc.IPreAgeGateMetadata|null);
            common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
        }

        class PlatformPreAgeGateTrackingOmniproto implements IPlatformPreAgeGateTrackingOmniproto {
            constructor(properties?: POGOProtos.Rpc.IPlatformPreAgeGateTrackingOmniproto);
            public age_gate_startup?: (POGOProtos.Rpc.IAgeGateStartup|null);
            public age_gate_result?: (POGOProtos.Rpc.IAgeGateResult|null);
            public pre_age_gate_metadata?: (POGOProtos.Rpc.IPreAgeGateMetadata|null);
            public common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
            public PlatformPreAgeGateEvent?: ("age_gate_startup"|"age_gate_result");
            public static encode(message: POGOProtos.Rpc.IPlatformPreAgeGateTrackingOmniproto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformPreAgeGateTrackingOmniproto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformPreAgeGateTrackingOmniproto;
            public static toObject(message: POGOProtos.Rpc.PlatformPreAgeGateTrackingOmniproto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformPreLoginTrackingOmniproto {
            login_startup?: (POGOProtos.Rpc.ILoginStartup|null);
            login_new_player?: (POGOProtos.Rpc.ILoginNewPlayer|null);
            login_returning_player?: (POGOProtos.Rpc.ILoginReturningPlayer|null);
            login_new_player_create_account?: (POGOProtos.Rpc.ILoginNewPlayerCreateAccount|null);
            login_returning_player_sign_in?: (POGOProtos.Rpc.ILoginReturningPlayerSignIn|null);
            pre_login_metadata?: (POGOProtos.Rpc.IPreLoginMetadata|null);
            common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
        }

        class PlatformPreLoginTrackingOmniproto implements IPlatformPreLoginTrackingOmniproto {
            constructor(properties?: POGOProtos.Rpc.IPlatformPreLoginTrackingOmniproto);
            public login_startup?: (POGOProtos.Rpc.ILoginStartup|null);
            public login_new_player?: (POGOProtos.Rpc.ILoginNewPlayer|null);
            public login_returning_player?: (POGOProtos.Rpc.ILoginReturningPlayer|null);
            public login_new_player_create_account?: (POGOProtos.Rpc.ILoginNewPlayerCreateAccount|null);
            public login_returning_player_sign_in?: (POGOProtos.Rpc.ILoginReturningPlayerSignIn|null);
            public pre_login_metadata?: (POGOProtos.Rpc.IPreLoginMetadata|null);
            public common_filters?: (POGOProtos.Rpc.IClientTelemetryCommonFilterProto|null);
            public PlatformPreLoginEvent?: ("login_startup"|"login_new_player"|"login_returning_player"|"login_new_player_create_account"|"login_returning_player_sign_in");
            public static encode(message: POGOProtos.Rpc.IPlatformPreLoginTrackingOmniproto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformPreLoginTrackingOmniproto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformPreLoginTrackingOmniproto;
            public static toObject(message: POGOProtos.Rpc.PlatformPreLoginTrackingOmniproto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatformServerData {
            user_id?: (string|null);
            telemetry_id?: (string|null);
            session_id?: (string|null);
            experiment_ids?: (number[]|null);
            event_request_id?: (string|null);
            server_timestamp_ms?: (number|Long|null);
        }

        class PlatformServerData implements IPlatformServerData {
            constructor(properties?: POGOProtos.Rpc.IPlatformServerData);
            public user_id: string;
            public telemetry_id: string;
            public session_id: string;
            public experiment_ids: number[];
            public event_request_id: string;
            public server_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlatformServerData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatformServerData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatformServerData;
            public static toObject(message: POGOProtos.Rpc.PlatformServerData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlatypusRolloutSettingsProto {
            enable_monodepth?: (boolean|null);
            wallaby_settings?: (POGOProtos.Rpc.IWallabySettingsProto|null);
        }

        class PlatypusRolloutSettingsProto implements IPlatypusRolloutSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPlatypusRolloutSettingsProto);
            public enable_monodepth: boolean;
            public wallaby_settings?: (POGOProtos.Rpc.IWallabySettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IPlatypusRolloutSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlatypusRolloutSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlatypusRolloutSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PlatypusRolloutSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerActivitySummaryProto {
            activity_summary_map?: ({ [k: string]: number }|null);
        }

        class PlayerActivitySummaryProto implements IPlayerActivitySummaryProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerActivitySummaryProto);
            public activity_summary_map: { [k: string]: number };
            public static encode(message: POGOProtos.Rpc.IPlayerActivitySummaryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerActivitySummaryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerActivitySummaryProto;
            public static toObject(message: POGOProtos.Rpc.PlayerActivitySummaryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerAttributeMetadataProto {
            start_time_ms?: (number|Long|null);
            end_time_ms?: (number|Long|null);
        }

        class PlayerAttributeMetadataProto implements IPlayerAttributeMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerAttributeMetadataProto);
            public start_time_ms: (number|Long);
            public end_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlayerAttributeMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerAttributeMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerAttributeMetadataProto;
            public static toObject(message: POGOProtos.Rpc.PlayerAttributeMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerAttributeRewardProto {
            key?: (string|null);
            value?: (string|null);
            overwrite_existing_attribute?: (boolean|null);
            duration_mins?: (number|null);
        }

        class PlayerAttributeRewardProto implements IPlayerAttributeRewardProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerAttributeRewardProto);
            public key: string;
            public value: string;
            public overwrite_existing_attribute: boolean;
            public duration_mins: number;
            public static encode(message: POGOProtos.Rpc.IPlayerAttributeRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerAttributeRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerAttributeRewardProto;
            public static toObject(message: POGOProtos.Rpc.PlayerAttributeRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerAttributesProto {
            attributes?: ({ [k: string]: string }|null);
            attribute_metadata?: ({ [k: string]: POGOProtos.Rpc.IPlayerAttributeMetadataProto }|null);
        }

        class PlayerAttributesProto implements IPlayerAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerAttributesProto);
            public attributes: { [k: string]: string };
            public attribute_metadata: { [k: string]: POGOProtos.Rpc.IPlayerAttributeMetadataProto };
            public static encode(message: POGOProtos.Rpc.IPlayerAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PlayerAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerAvatarProto {
            skin?: (number|null);
            hair?: (number|null);
            shirt?: (number|null);
            pants?: (number|null);
            hat?: (number|null);
            shoes?: (number|null);
            avatar?: (number|null);
            eyes?: (number|null);
            backpack?: (number|null);
            avatar_hair?: (string|null);
            avatar_shirt?: (string|null);
            avatar_pants?: (string|null);
            avatar_hat?: (string|null);
            avatar_shoes?: (string|null);
            avatar_eyes?: (string|null);
            avatar_backpack?: (string|null);
            avatar_gloves?: (string|null);
            avatar_socks?: (string|null);
            avatar_belt?: (string|null);
            avatar_glasses?: (string|null);
            avatar_necklace?: (string|null);
            avatar_skin?: (string|null);
            avatar_pose?: (string|null);
            avatar_face?: (string|null);
            avatar_prop?: (string|null);
        }

        class PlayerAvatarProto implements IPlayerAvatarProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerAvatarProto);
            public skin: number;
            public hair: number;
            public shirt: number;
            public pants: number;
            public hat: number;
            public shoes: number;
            public avatar: number;
            public eyes: number;
            public backpack: number;
            public avatar_hair: string;
            public avatar_shirt: string;
            public avatar_pants: string;
            public avatar_hat: string;
            public avatar_shoes: string;
            public avatar_eyes: string;
            public avatar_backpack: string;
            public avatar_gloves: string;
            public avatar_socks: string;
            public avatar_belt: string;
            public avatar_glasses: string;
            public avatar_necklace: string;
            public avatar_skin: string;
            public avatar_pose: string;
            public avatar_face: string;
            public avatar_prop: string;
            public static encode(message: POGOProtos.Rpc.IPlayerAvatarProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerAvatarProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerAvatarProto;
            public static toObject(message: POGOProtos.Rpc.PlayerAvatarProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerBadgeProto {
            badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            rank?: (number|null);
            start_value?: (number|null);
            end_value?: (number|null);
            current_value?: (number|null);
            tiers?: (POGOProtos.Rpc.IPlayerBadgeTierProto[]|null);
        }

        class PlayerBadgeProto implements IPlayerBadgeProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerBadgeProto);
            public badge_type: POGOProtos.Rpc.HoloBadgeType;
            public rank: number;
            public start_value: number;
            public end_value: number;
            public current_value: number;
            public tiers: POGOProtos.Rpc.IPlayerBadgeTierProto[];
            public static encode(message: POGOProtos.Rpc.IPlayerBadgeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerBadgeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerBadgeProto;
            public static toObject(message: POGOProtos.Rpc.PlayerBadgeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerBadgeTierEncounterProto {
            encounter_state?: (POGOProtos.Rpc.PlayerBadgeTierEncounterProto.EncounterState|null);
            encounter_id?: (number|Long|null);
        }

        class PlayerBadgeTierEncounterProto implements IPlayerBadgeTierEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerBadgeTierEncounterProto);
            public encounter_state: POGOProtos.Rpc.PlayerBadgeTierEncounterProto.EncounterState;
            public encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlayerBadgeTierEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerBadgeTierEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerBadgeTierEncounterProto;
            public static toObject(message: POGOProtos.Rpc.PlayerBadgeTierEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerBadgeTierEncounterProto {

            enum EncounterState {
                UNSET = 0,
                UNEARNED = 1,
                AVAILABLE = 2,
                COMPLETED = 3
            }
        }

        interface IPlayerBadgeTierProto {
            encounter?: (POGOProtos.Rpc.IPlayerBadgeTierEncounterProto|null);
        }

        class PlayerBadgeTierProto implements IPlayerBadgeTierProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerBadgeTierProto);
            public encounter?: (POGOProtos.Rpc.IPlayerBadgeTierEncounterProto|null);
            public static encode(message: POGOProtos.Rpc.IPlayerBadgeTierProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerBadgeTierProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerBadgeTierProto;
            public static toObject(message: POGOProtos.Rpc.PlayerBadgeTierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerBonusSystemSettingsProto {
            max_bonus_duration_ms?: (number|Long|null);
            day_night_evo_enabled?: (boolean|null);
        }

        class PlayerBonusSystemSettingsProto implements IPlayerBonusSystemSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerBonusSystemSettingsProto);
            public max_bonus_duration_ms: (number|Long);
            public day_night_evo_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPlayerBonusSystemSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerBonusSystemSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerBonusSystemSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerBonusSystemSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerCameraProto {
            default_camera?: (boolean|null);
        }

        class PlayerCameraProto implements IPlayerCameraProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerCameraProto);
            public default_camera: boolean;
            public static encode(message: POGOProtos.Rpc.IPlayerCameraProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerCameraProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerCameraProto;
            public static toObject(message: POGOProtos.Rpc.PlayerCameraProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerClientStationedPokemonProto {
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            trainer_name?: (string|null);
            deploy_timestamp_ms?: (number|Long|null);
            player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            player_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            trainer_level?: (number|null);
        }

        class PlayerClientStationedPokemonProto implements IPlayerClientStationedPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerClientStationedPokemonProto);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public trainer_name: string;
            public deploy_timestamp_ms: (number|Long);
            public player_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public player_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public trainer_level: number;
            public static encode(message: POGOProtos.Rpc.IPlayerClientStationedPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerClientStationedPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerClientStationedPokemonProto;
            public static toObject(message: POGOProtos.Rpc.PlayerClientStationedPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerCombatBadgeStatsProto {
            num_won?: (number|null);
            num_total?: (number|null);
        }

        class PlayerCombatBadgeStatsProto implements IPlayerCombatBadgeStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerCombatBadgeStatsProto);
            public num_won: number;
            public num_total: number;
            public static encode(message: POGOProtos.Rpc.IPlayerCombatBadgeStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerCombatBadgeStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerCombatBadgeStatsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerCombatBadgeStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerCombatStatsProto {
            badges?: ({ [k: string]: POGOProtos.Rpc.IPlayerCombatBadgeStatsProto }|null);
        }

        class PlayerCombatStatsProto implements IPlayerCombatStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerCombatStatsProto);
            public badges: { [k: string]: POGOProtos.Rpc.IPlayerCombatBadgeStatsProto };
            public static encode(message: POGOProtos.Rpc.IPlayerCombatStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerCombatStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerCombatStatsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerCombatStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerContestBadgeStatsProto {
            num_won_first_place?: (number|null);
            num_total?: (number|null);
        }

        class PlayerContestBadgeStatsProto implements IPlayerContestBadgeStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerContestBadgeStatsProto);
            public num_won_first_place: number;
            public num_total: number;
            public static encode(message: POGOProtos.Rpc.IPlayerContestBadgeStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerContestBadgeStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerContestBadgeStatsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerContestBadgeStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerContestStatsProto {
            badge_stats?: ({ [k: string]: POGOProtos.Rpc.IPlayerContestBadgeStatsProto }|null);
        }

        class PlayerContestStatsProto implements IPlayerContestStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerContestStatsProto);
            public badge_stats: { [k: string]: POGOProtos.Rpc.IPlayerContestBadgeStatsProto };
            public static encode(message: POGOProtos.Rpc.IPlayerContestStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerContestStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerContestStatsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerContestStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerCurrencyProto {
            gems?: (number|null);
        }

        class PlayerCurrencyProto implements IPlayerCurrencyProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerCurrencyProto);
            public gems: number;
            public static encode(message: POGOProtos.Rpc.IPlayerCurrencyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerCurrencyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerCurrencyProto;
            public static toObject(message: POGOProtos.Rpc.PlayerCurrencyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerFriendDisplayProto {
            buddy?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            buddy_display_pokemon_id?: (number|null);
            buddy_pokemon_nickname?: (string|null);
            last_pokemon_caught?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            last_pokemon_caught_display_id?: (number|null);
            last_pokemon_caught_timestamp?: (number|Long|null);
            buddy_candy_awarded?: (number|null);
            active_mega_evo_info?: (POGOProtos.Rpc.IMegaEvoInfoProto|null);
            buddy_height_m?: (number|null);
            buddy_weight_kg?: (number|null);
            buddy_size?: (POGOProtos.Rpc.HoloPokemonSize|null);
        }

        class PlayerFriendDisplayProto implements IPlayerFriendDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerFriendDisplayProto);
            public buddy?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public buddy_display_pokemon_id: number;
            public buddy_pokemon_nickname: string;
            public last_pokemon_caught?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public last_pokemon_caught_display_id: number;
            public last_pokemon_caught_timestamp: (number|Long);
            public buddy_candy_awarded: number;
            public active_mega_evo_info?: (POGOProtos.Rpc.IMegaEvoInfoProto|null);
            public buddy_height_m: number;
            public buddy_weight_kg: number;
            public buddy_size: POGOProtos.Rpc.HoloPokemonSize;
            public static encode(message: POGOProtos.Rpc.IPlayerFriendDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerFriendDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerFriendDisplayProto;
            public static toObject(message: POGOProtos.Rpc.PlayerFriendDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerHudNotificationClickTelemetry {
            notification_category?: (string|null);
        }

        class PlayerHudNotificationClickTelemetry implements IPlayerHudNotificationClickTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPlayerHudNotificationClickTelemetry);
            public notification_category: string;
            public static encode(message: POGOProtos.Rpc.IPlayerHudNotificationClickTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerHudNotificationClickTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerHudNotificationClickTelemetry;
            public static toObject(message: POGOProtos.Rpc.PlayerHudNotificationClickTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerLevelAvatarLockProto {
            player_level?: (number|null);
        }

        class PlayerLevelAvatarLockProto implements IPlayerLevelAvatarLockProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerLevelAvatarLockProto);
            public player_level: number;
            public static encode(message: POGOProtos.Rpc.IPlayerLevelAvatarLockProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerLevelAvatarLockProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerLevelAvatarLockProto;
            public static toObject(message: POGOProtos.Rpc.PlayerLevelAvatarLockProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerLevelSettingsProto {
            rank_num?: (number[]|null);
            required_exp?: (number[]|null);
            cp_multiplier?: (number[]|null);
            max_egg_player_level?: (number|null);
            max_encounter_player_level?: (number|null);
            max_raid_encounter_player_level?: (number|null);
            max_quest_encounter_player_level?: (number|null);
            max_vs_seeker_encounter_player_level?: (number|null);
            extended_player_level_threshold?: (number|null);
            max_bread_battle_encounter_player_level?: (number|null);
        }

        class PlayerLevelSettingsProto implements IPlayerLevelSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerLevelSettingsProto);
            public rank_num: number[];
            public required_exp: number[];
            public cp_multiplier: number[];
            public max_egg_player_level: number;
            public max_encounter_player_level: number;
            public max_raid_encounter_player_level: number;
            public max_quest_encounter_player_level: number;
            public max_vs_seeker_encounter_player_level: number;
            public extended_player_level_threshold: number;
            public max_bread_battle_encounter_player_level: number;
            public static encode(message: POGOProtos.Rpc.IPlayerLevelSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerLevelSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerLevelSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerLevelSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerLocaleProto {
            country?: (string|null);
            language?: (string|null);
            timezone?: (string|null);
        }

        class PlayerLocaleProto implements IPlayerLocaleProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerLocaleProto);
            public country: string;
            public language: string;
            public timezone: string;
            public static encode(message: POGOProtos.Rpc.IPlayerLocaleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerLocaleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerLocaleProto;
            public static toObject(message: POGOProtos.Rpc.PlayerLocaleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralAvatarArticleConfiguration {
            hair?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            shirt?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            pants?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            hat?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            shoes?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            eyes?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            backpack?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            gloves?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            socks?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            belt?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            glasses?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            necklace?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            skin?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            pose?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            mask?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            prop?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            facial_hair?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            face_paint?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            onesie?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            eye_brow?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            eye_lash?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            face_preset?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            body_preset?: (POGOProtos.Rpc.IAvatarArticleProto|null);
        }

        class PlayerNeutralAvatarArticleConfiguration implements IPlayerNeutralAvatarArticleConfiguration {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarArticleConfiguration);
            public hair?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public shirt?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public pants?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public hat?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public shoes?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public eyes?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public backpack?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public gloves?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public socks?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public belt?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public glasses?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public necklace?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public skin?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public pose?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public mask?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public prop?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public facial_hair?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public face_paint?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public onesie?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public eye_brow?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public eye_lash?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public face_preset?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public body_preset?: (POGOProtos.Rpc.IAvatarArticleProto|null);
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarArticleConfiguration, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarArticleConfiguration;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarArticleConfiguration;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarArticleConfiguration, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralAvatarBodyBlendParameters {
            size?: (number|null);
            musculature?: (number|null);
            bust?: (number|null);
            hips?: (number|null);
            shoulders?: (number|null);
        }

        class PlayerNeutralAvatarBodyBlendParameters implements IPlayerNeutralAvatarBodyBlendParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarBodyBlendParameters);
            public size: number;
            public musculature: number;
            public bust: number;
            public hips: number;
            public shoulders: number;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarBodyBlendParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarBodyBlendParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarBodyBlendParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarBodyBlendParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralAvatarEarSelectionParameters {
            selection?: (POGOProtos.Rpc.PlayerNeutralAvatarEarSelectionParameters.Shape|null);
        }

        class PlayerNeutralAvatarEarSelectionParameters implements IPlayerNeutralAvatarEarSelectionParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarEarSelectionParameters);
            public selection: POGOProtos.Rpc.PlayerNeutralAvatarEarSelectionParameters.Shape;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarEarSelectionParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarEarSelectionParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarEarSelectionParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarEarSelectionParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerNeutralAvatarEarSelectionParameters {

            enum Shape {
                UNSET = 0,
                DEFAULT = 1,
                OPTION_ONE = 5000,
                OPTION_TWO = 5001
            }
        }

        interface IPlayerNeutralAvatarEyeSelectionParameters {
            selection?: (POGOProtos.Rpc.PlayerNeutralAvatarEyeSelectionParameters.Shape|null);
        }

        class PlayerNeutralAvatarEyeSelectionParameters implements IPlayerNeutralAvatarEyeSelectionParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarEyeSelectionParameters);
            public selection: POGOProtos.Rpc.PlayerNeutralAvatarEyeSelectionParameters.Shape;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarEyeSelectionParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarEyeSelectionParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarEyeSelectionParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarEyeSelectionParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerNeutralAvatarEyeSelectionParameters {

            enum Shape {
                UNSET = 0,
                DEFAULT = 1,
                OPTION_ONE = 5000,
                OPTION_TWO = 5001,
                OPTION_THREE = 5002,
                OPTION_FIVE = 5004,
                OPTION_FOUR = 50003
            }
        }

        interface IPlayerNeutralAvatarFacePositionParameters {
            brow_depth?: (number|null);
            brow_horizontal?: (number|null);
            brow_vertical?: (number|null);
            eye_depth?: (number|null);
            eye_horizontal?: (number|null);
            eye_vertical?: (number|null);
            mouth_depth?: (number|null);
            mouth_horizontal?: (number|null);
            mouth_vertical?: (number|null);
            nose_depth?: (number|null);
            nose_vertical?: (number|null);
        }

        class PlayerNeutralAvatarFacePositionParameters implements IPlayerNeutralAvatarFacePositionParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarFacePositionParameters);
            public brow_depth: number;
            public brow_horizontal: number;
            public brow_vertical: number;
            public eye_depth: number;
            public eye_horizontal: number;
            public eye_vertical: number;
            public mouth_depth: number;
            public mouth_horizontal: number;
            public mouth_vertical: number;
            public nose_depth: number;
            public nose_vertical: number;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarFacePositionParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarFacePositionParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarFacePositionParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarFacePositionParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralAvatarGradient {
            color_keys?: (POGOProtos.Rpc.IPlayerNeutralColorKey[]|null);
        }

        class PlayerNeutralAvatarGradient implements IPlayerNeutralAvatarGradient {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarGradient);
            public color_keys: POGOProtos.Rpc.IPlayerNeutralColorKey[];
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarGradient, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarGradient;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarGradient;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarGradient, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralAvatarHeadBlendParameters {
            diamond?: (number|null);
            kite?: (number|null);
            triangle?: (number|null);
            square?: (number|null);
            circle?: (number|null);
            oval?: (number|null);
        }

        class PlayerNeutralAvatarHeadBlendParameters implements IPlayerNeutralAvatarHeadBlendParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarHeadBlendParameters);
            public diamond: number;
            public kite: number;
            public triangle: number;
            public square: number;
            public circle: number;
            public oval: number;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarHeadBlendParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarHeadBlendParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarHeadBlendParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarHeadBlendParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralAvatarHeadSelectionParameters {
            selection?: (POGOProtos.Rpc.PlayerNeutralAvatarHeadSelectionParameters.Shape|null);
        }

        class PlayerNeutralAvatarHeadSelectionParameters implements IPlayerNeutralAvatarHeadSelectionParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarHeadSelectionParameters);
            public selection: POGOProtos.Rpc.PlayerNeutralAvatarHeadSelectionParameters.Shape;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarHeadSelectionParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarHeadSelectionParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarHeadSelectionParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarHeadSelectionParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerNeutralAvatarHeadSelectionParameters {

            enum Shape {
                UNSET = 0,
                DIAMOND = 1,
                KITE = 2,
                TRIANGLE = 3,
                SQUARE = 4,
                CIRCLE = 5,
                OVAL = 6,
                LEGACYFEMALE = 7,
                LEGACYMALE = 8
            }
        }

        interface IPlayerNeutralAvatarMouthSelectionParameters {
            selection?: (POGOProtos.Rpc.PlayerNeutralAvatarMouthSelectionParameters.Shape|null);
        }

        class PlayerNeutralAvatarMouthSelectionParameters implements IPlayerNeutralAvatarMouthSelectionParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarMouthSelectionParameters);
            public selection: POGOProtos.Rpc.PlayerNeutralAvatarMouthSelectionParameters.Shape;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarMouthSelectionParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarMouthSelectionParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarMouthSelectionParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarMouthSelectionParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerNeutralAvatarMouthSelectionParameters {

            enum Shape {
                UNSET = 0,
                DEFAULT = 1,
                OPTION_ONE = 5000,
                OPTION_TWO = 5001,
                OPTION_THREE = 5002,
                OPTION_FIVE = 5004,
                OPTION_FOUR = 50003
            }
        }

        interface IPlayerNeutralAvatarNoseSelectionParameters {
            selection?: (POGOProtos.Rpc.PlayerNeutralAvatarNoseSelectionParameters.Shape|null);
        }

        class PlayerNeutralAvatarNoseSelectionParameters implements IPlayerNeutralAvatarNoseSelectionParameters {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarNoseSelectionParameters);
            public selection: POGOProtos.Rpc.PlayerNeutralAvatarNoseSelectionParameters.Shape;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarNoseSelectionParameters, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarNoseSelectionParameters;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarNoseSelectionParameters;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarNoseSelectionParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerNeutralAvatarNoseSelectionParameters {

            enum Shape {
                UNSET = 0,
                DEFAULT = 1,
                OPTION_ONE = 5000,
                OPTION_TWO = 5001,
                OPTION_THREE = 5002,
                OPTION_FIVE = 5004,
                OPTION_FOUR = 50003
            }
        }

        interface IPlayerNeutralAvatarProto {
            head_blend?: (POGOProtos.Rpc.IPlayerNeutralAvatarHeadBlendParameters|null);
            head_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarHeadSelectionParameters|null);
            articles?: (POGOProtos.Rpc.IPlayerNeutralAvatarArticleConfiguration|null);
            body_blend?: (POGOProtos.Rpc.IPlayerNeutralAvatarBodyBlendParameters|null);
            skin_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            hair_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            nose_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarNoseSelectionParameters|null);
            ear_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarEarSelectionParameters|null);
            mouth_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarMouthSelectionParameters|null);
            facial_hair_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            face_positions?: (POGOProtos.Rpc.IPlayerNeutralAvatarFacePositionParameters|null);
            eye_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            eye_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarEyeSelectionParameters|null);
            skin_gradient_id?: (string|null);
            hair_gradient_id?: (string|null);
            eye_gradient_id?: (string|null);
            neutral_avatar_legacy_mapping_version?: (number|null);
        }

        class PlayerNeutralAvatarProto implements IPlayerNeutralAvatarProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralAvatarProto);
            public head_blend?: (POGOProtos.Rpc.IPlayerNeutralAvatarHeadBlendParameters|null);
            public head_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarHeadSelectionParameters|null);
            public articles?: (POGOProtos.Rpc.IPlayerNeutralAvatarArticleConfiguration|null);
            public body_blend?: (POGOProtos.Rpc.IPlayerNeutralAvatarBodyBlendParameters|null);
            public skin_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            public hair_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            public nose_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarNoseSelectionParameters|null);
            public ear_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarEarSelectionParameters|null);
            public mouth_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarMouthSelectionParameters|null);
            public facial_hair_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            public face_positions?: (POGOProtos.Rpc.IPlayerNeutralAvatarFacePositionParameters|null);
            public eye_gradient?: (POGOProtos.Rpc.IPlayerNeutralAvatarGradient|null);
            public eye_selection?: (POGOProtos.Rpc.IPlayerNeutralAvatarEyeSelectionParameters|null);
            public skin_gradient_id: string;
            public hair_gradient_id: string;
            public eye_gradient_id: string;
            public neutral_avatar_legacy_mapping_version: number;
            public Head?: ("head_blend"|"head_selection");
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralAvatarProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralAvatarProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralAvatarProto;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralAvatarProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerNeutralColorKey {
            key_position?: (number|null);
            red?: (number|null);
            green?: (number|null);
            blue?: (number|null);
        }

        class PlayerNeutralColorKey implements IPlayerNeutralColorKey {
            constructor(properties?: POGOProtos.Rpc.IPlayerNeutralColorKey);
            public key_position: number;
            public red: number;
            public green: number;
            public blue: number;
            public static encode(message: POGOProtos.Rpc.IPlayerNeutralColorKey, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerNeutralColorKey;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerNeutralColorKey;
            public static toObject(message: POGOProtos.Rpc.PlayerNeutralColorKey, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerObfuscationMapEntryProto {
            participant_player_id?: (string|null);
            participant_player_id_party_obfuscated?: (string|null);
        }

        class PlayerObfuscationMapEntryProto implements IPlayerObfuscationMapEntryProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerObfuscationMapEntryProto);
            public participant_player_id: string;
            public participant_player_id_party_obfuscated: string;
            public static encode(message: POGOProtos.Rpc.IPlayerObfuscationMapEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerObfuscationMapEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerObfuscationMapEntryProto;
            public static toObject(message: POGOProtos.Rpc.PlayerObfuscationMapEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerPokecoinCapProto {
            pokecoin_source?: (POGOProtos.Rpc.PokecoinSource|null);
            last_collection_timestamp_ms?: (number|Long|null);
            current_amount_collected?: (number|Long|null);
        }

        class PlayerPokecoinCapProto implements IPlayerPokecoinCapProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerPokecoinCapProto);
            public pokecoin_source: POGOProtos.Rpc.PokecoinSource;
            public last_collection_timestamp_ms: (number|Long);
            public current_amount_collected: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlayerPokecoinCapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerPokecoinCapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerPokecoinCapProto;
            public static toObject(message: POGOProtos.Rpc.PlayerPokecoinCapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerPreferencesProto {
            opt_out_of_sponsored_gifts?: (boolean|null);
            battle_parties?: (POGOProtos.Rpc.IBattlePartiesProto|null);
            search_filter_preference_base64?: (string|null);
            share_trainer_info_with_postcard?: (POGOProtos.Rpc.PlayerPreferencesProto.PostcardTrainerInfoSharingPreference|null);
            waina_preference?: (POGOProtos.Rpc.IWainaPreferences|null);
            opt_out_of_receiving_ticket_gifts?: (boolean|null);
            party_play_preference?: (POGOProtos.Rpc.IPartyPlayPreferences|null);
            pokedex_preference?: (POGOProtos.Rpc.IPokedexPreferencesProto|null);
            activity_sharing_preference?: (POGOProtos.Rpc.IActivitySharingPreferencesProto|null);
            opt_out_of_receiving_stamps_from_gifts?: (boolean|null);
            name_sharing_preferences?: (POGOProtos.Rpc.INameSharingPreferencesProto[]|null);
        }

        class PlayerPreferencesProto implements IPlayerPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerPreferencesProto);
            public opt_out_of_sponsored_gifts: boolean;
            public battle_parties?: (POGOProtos.Rpc.IBattlePartiesProto|null);
            public search_filter_preference_base64: string;
            public share_trainer_info_with_postcard: POGOProtos.Rpc.PlayerPreferencesProto.PostcardTrainerInfoSharingPreference;
            public waina_preference?: (POGOProtos.Rpc.IWainaPreferences|null);
            public opt_out_of_receiving_ticket_gifts: boolean;
            public party_play_preference?: (POGOProtos.Rpc.IPartyPlayPreferences|null);
            public pokedex_preference?: (POGOProtos.Rpc.IPokedexPreferencesProto|null);
            public activity_sharing_preference?: (POGOProtos.Rpc.IActivitySharingPreferencesProto|null);
            public opt_out_of_receiving_stamps_from_gifts: boolean;
            public name_sharing_preferences: POGOProtos.Rpc.INameSharingPreferencesProto[];
            public static encode(message: POGOProtos.Rpc.IPlayerPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.PlayerPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerPreferencesProto {

            enum PostcardTrainerInfoSharingPreference {
                UNSET = 0,
                SHARE_WITH_FRIENDS = 1,
                DO_NOT_SHARE = 2
            }
        }

        interface IPlayerProfileOutProto {
            result?: (POGOProtos.Rpc.PlayerProfileOutProto.Result|null);
            start_time?: (number|Long|null);
            badges?: (POGOProtos.Rpc.IPlayerBadgeProto[]|null);
            gym_badges?: (POGOProtos.Rpc.PlayerProfileOutProto.IGymBadges|null);
            route_badges?: (POGOProtos.Rpc.PlayerProfileOutProto.IRouteBadges|null);
        }

        class PlayerProfileOutProto implements IPlayerProfileOutProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerProfileOutProto);
            public result: POGOProtos.Rpc.PlayerProfileOutProto.Result;
            public start_time: (number|Long);
            public badges: POGOProtos.Rpc.IPlayerBadgeProto[];
            public gym_badges?: (POGOProtos.Rpc.PlayerProfileOutProto.IGymBadges|null);
            public route_badges?: (POGOProtos.Rpc.PlayerProfileOutProto.IRouteBadges|null);
            public static encode(message: POGOProtos.Rpc.IPlayerProfileOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerProfileOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerProfileOutProto;
            public static toObject(message: POGOProtos.Rpc.PlayerProfileOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerProfileOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }

            interface IGymBadges {
                gym_badge?: (POGOProtos.Rpc.IAwardedGymBadge[]|null);
                total?: (number|null);
            }

            class GymBadges implements IGymBadges {
                constructor(properties?: POGOProtos.Rpc.PlayerProfileOutProto.IGymBadges);
                public gym_badge: POGOProtos.Rpc.IAwardedGymBadge[];
                public total: number;
                public static encode(message: POGOProtos.Rpc.PlayerProfileOutProto.IGymBadges, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerProfileOutProto.GymBadges;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerProfileOutProto.GymBadges;
                public static toObject(message: POGOProtos.Rpc.PlayerProfileOutProto.GymBadges, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRouteBadges {
                route_badge?: (POGOProtos.Rpc.IAwardedRouteBadge[]|null);
                total?: (number|null);
            }

            class RouteBadges implements IRouteBadges {
                constructor(properties?: POGOProtos.Rpc.PlayerProfileOutProto.IRouteBadges);
                public route_badge: POGOProtos.Rpc.IAwardedRouteBadge[];
                public total: number;
                public static encode(message: POGOProtos.Rpc.PlayerProfileOutProto.IRouteBadges, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerProfileOutProto.RouteBadges;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerProfileOutProto.RouteBadges;
                public static toObject(message: POGOProtos.Rpc.PlayerProfileOutProto.RouteBadges, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPlayerProfileProto {
            player_name?: (string|null);
        }

        class PlayerProfileProto implements IPlayerProfileProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerProfileProto);
            public player_name: string;
            public static encode(message: POGOProtos.Rpc.IPlayerProfileProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerProfileProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerProfileProto;
            public static toObject(message: POGOProtos.Rpc.PlayerProfileProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerPublicProfileProto {
            name?: (string|null);
            level?: (number|null);
            avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            team?: (POGOProtos.Rpc.Team|null);
            battles_won?: (number|null);
            km_walked?: (number|null);
            caught_pokemon?: (number|null);
            gym_badge_type?: (POGOProtos.Rpc.GymBadgeType|null);
            badges?: (POGOProtos.Rpc.IPlayerBadgeProto[]|null);
            experience?: (number|Long|null);
            has_shared_ex_pass?: (boolean|null);
            combat_rank?: (number|null);
            combat_rating?: (number|null);
            timed_group_challenge_stats?: (POGOProtos.Rpc.ITimedGroupChallengePlayerStatsProto|null);
            neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class PlayerPublicProfileProto implements IPlayerPublicProfileProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerPublicProfileProto);
            public name: string;
            public level: number;
            public avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public team: POGOProtos.Rpc.Team;
            public battles_won: number;
            public km_walked: number;
            public caught_pokemon: number;
            public gym_badge_type: POGOProtos.Rpc.GymBadgeType;
            public badges: POGOProtos.Rpc.IPlayerBadgeProto[];
            public experience: (number|Long);
            public has_shared_ex_pass: boolean;
            public combat_rank: number;
            public combat_rating: number;
            public timed_group_challenge_stats?: (POGOProtos.Rpc.ITimedGroupChallengePlayerStatsProto|null);
            public neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.IPlayerPublicProfileProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerPublicProfileProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerPublicProfileProto;
            public static toObject(message: POGOProtos.Rpc.PlayerPublicProfileProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerRaidInfoProto {
            total_completed_raids?: (number|null);
            total_completed_legendary_raids?: (number|null);
            raids?: (POGOProtos.Rpc.IRaidProto[]|null);
            total_remote_raids?: (number|null);
        }

        class PlayerRaidInfoProto implements IPlayerRaidInfoProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerRaidInfoProto);
            public total_completed_raids: number;
            public total_completed_legendary_raids: number;
            public raids: POGOProtos.Rpc.IRaidProto[];
            public total_remote_raids: number;
            public static encode(message: POGOProtos.Rpc.IPlayerRaidInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerRaidInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerRaidInfoProto;
            public static toObject(message: POGOProtos.Rpc.PlayerRaidInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerReputationProto {
            account_age_ms?: (number|Long|null);
            player_level?: (number|Long|null);
            cheat_reputation?: (POGOProtos.Rpc.PlayerReputationProto.CheatReputation[]|null);
            is_minor?: (boolean|null);
        }

        class PlayerReputationProto implements IPlayerReputationProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerReputationProto);
            public account_age_ms: (number|Long);
            public player_level: (number|Long);
            public cheat_reputation: POGOProtos.Rpc.PlayerReputationProto.CheatReputation[];
            public is_minor: boolean;
            public static encode(message: POGOProtos.Rpc.IPlayerReputationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerReputationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerReputationProto;
            public static toObject(message: POGOProtos.Rpc.PlayerReputationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerReputationProto {

            enum CheatReputation {
                UNSET = 0,
                BOT = 1,
                SPOOFER = 2
            }
        }

        interface IPlayerRouteStats {
            num_completions?: (number|Long|null);
            cooldown_finish_ms?: (number|Long|null);
        }

        class PlayerRouteStats implements IPlayerRouteStats {
            constructor(properties?: POGOProtos.Rpc.IPlayerRouteStats);
            public num_completions: (number|Long);
            public cooldown_finish_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPlayerRouteStats, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerRouteStats;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerRouteStats;
            public static toObject(message: POGOProtos.Rpc.PlayerRouteStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerRpcStampCollectionProto {
            collection_id?: (string|null);
            type?: (POGOProtos.Rpc.StampCollectionType|null);
            stamps?: (POGOProtos.Rpc.IPlayerStampProto[]|null);
            paused?: (boolean|null);
            expiration_timestamp_ms?: (number|Long|null);
            last_progress_timestamp_ms?: (number|Long|null);
            seen_opening_dialog?: (boolean|null);
            overall_progress?: (number|null);
            display?: (POGOProtos.Rpc.IStampCollectionDisplayProto|null);
            reward_progress?: (POGOProtos.Rpc.IStampCollectionRewardProgressProto[]|null);
            completion_count?: (number|null);
            is_giftable?: (boolean|null);
        }

        class PlayerRpcStampCollectionProto implements IPlayerRpcStampCollectionProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerRpcStampCollectionProto);
            public collection_id: string;
            public type: POGOProtos.Rpc.StampCollectionType;
            public stamps: POGOProtos.Rpc.IPlayerStampProto[];
            public paused: boolean;
            public expiration_timestamp_ms: (number|Long);
            public last_progress_timestamp_ms: (number|Long);
            public seen_opening_dialog: boolean;
            public overall_progress: number;
            public display?: (POGOProtos.Rpc.IStampCollectionDisplayProto|null);
            public reward_progress: POGOProtos.Rpc.IStampCollectionRewardProgressProto[];
            public completion_count: number;
            public is_giftable: boolean;
            public static encode(message: POGOProtos.Rpc.IPlayerRpcStampCollectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerRpcStampCollectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerRpcStampCollectionProto;
            public static toObject(message: POGOProtos.Rpc.PlayerRpcStampCollectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerShownLevelUpShareScreenTelemetry {
            player_viewed_photo?: (boolean|null);
            player_shared_photo?: (boolean|null);
            player_level?: (number|null);
        }

        class PlayerShownLevelUpShareScreenTelemetry implements IPlayerShownLevelUpShareScreenTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPlayerShownLevelUpShareScreenTelemetry);
            public player_viewed_photo: boolean;
            public player_shared_photo: boolean;
            public player_level: number;
            public static encode(message: POGOProtos.Rpc.IPlayerShownLevelUpShareScreenTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerShownLevelUpShareScreenTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerShownLevelUpShareScreenTelemetry;
            public static toObject(message: POGOProtos.Rpc.PlayerShownLevelUpShareScreenTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerSpawnablePokemonOutProto {
            spawnable_pokemons?: (POGOProtos.Rpc.ISpawnablePokemon[]|null);
        }

        class PlayerSpawnablePokemonOutProto implements IPlayerSpawnablePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerSpawnablePokemonOutProto);
            public spawnable_pokemons: POGOProtos.Rpc.ISpawnablePokemon[];
            public static encode(message: POGOProtos.Rpc.IPlayerSpawnablePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerSpawnablePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerSpawnablePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.PlayerSpawnablePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerSpawnablePokemonProto {
        }

        class PlayerSpawnablePokemonProto implements IPlayerSpawnablePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerSpawnablePokemonProto);
            public static encode(message: POGOProtos.Rpc.IPlayerSpawnablePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerSpawnablePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerSpawnablePokemonProto;
            public static toObject(message: POGOProtos.Rpc.PlayerSpawnablePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerStampProto {
            stamp_metadata?: (POGOProtos.Rpc.IStampMetadataProto|null);
            completed_timestamp_ms?: (number|Long|null);
            state?: (POGOProtos.Rpc.PlayerStampProto.StampState|null);
            reward_collected?: (boolean|null);
            stamp_color?: (string|null);
            angle?: (number|null);
            pressure?: (number|null);
            slot?: (number|null);
            gifted_by_friend_nickname?: (string|null);
        }

        class PlayerStampProto implements IPlayerStampProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerStampProto);
            public stamp_metadata?: (POGOProtos.Rpc.IStampMetadataProto|null);
            public completed_timestamp_ms: (number|Long);
            public state: POGOProtos.Rpc.PlayerStampProto.StampState;
            public reward_collected: boolean;
            public stamp_color: string;
            public angle: number;
            public pressure: number;
            public slot: number;
            public gifted_by_friend_nickname: string;
            public static encode(message: POGOProtos.Rpc.IPlayerStampProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerStampProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerStampProto;
            public static toObject(message: POGOProtos.Rpc.PlayerStampProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerStampProto {

            enum StampState {
                UNSET = 0,
                UNSTAMPED = 1,
                STAMPED = 2,
                GIFTED = 3
            }
        }

        interface IPlayerStatsProto {
            level?: (number|null);
            experience?: (number|Long|null);
            prev_level_exp?: (number|Long|null);
            next_level_exp?: (number|Long|null);
            km_walked?: (number|null);
            num_pokemon_encountered?: (number|null);
            num_unique_pokedex_entries?: (number|null);
            num_pokemon_captured?: (number|null);
            num_evolutions?: (number|null);
            poke_stop_visits?: (number|null);
            number_of_pokeball_thrown?: (number|null);
            num_eggs_hatched?: (number|null);
            big_magikarp_caught?: (number|null);
            num_battle_attack_won?: (number|null);
            num_battle_attack_total?: (number|null);
            num_battle_defended_won?: (number|null);
            num_battle_training_won?: (number|null);
            num_battle_training_total?: (number|null);
            prestige_raised_total?: (number|null);
            prestige_dropped_total?: (number|null);
            num_pokemon_deployed?: (number|null);
            num_pokemon_caught_by_type?: (number[]|null);
            small_rattata_caught?: (number|null);
            used_km_pool?: (number|null);
            last_km_refill_ms?: (number|Long|null);
            num_raid_battle_won?: (number|null);
            num_raid_battle_total?: (number|null);
            num_legendary_battle_won?: (number|null);
            num_legendary_battle_total?: (number|null);
            num_berries_fed?: (number|null);
            total_defended_ms?: (number|Long|null);
            event_badges?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            km_walked_past_active_day?: (number|null);
            num_challenge_quests_completed?: (number|null);
            num_trades?: (number|null);
            num_max_level_friends?: (number|null);
            trade_accumulated_distance_km?: (number|Long|null);
            fitness_report_last_check_bucket?: (number|Long|null);
            combat_stats?: (POGOProtos.Rpc.IPlayerCombatStatsProto|null);
            num_npc_combats_won?: (number|null);
            num_npc_combats_total?: (number|null);
            num_photobomb_seen?: (number|null);
            num_pokemon_purified?: (number|null);
            num_grunts_defeated?: (number|null);
            num_best_buddies?: (number|null);
            level_cap?: (number|null);
            seven_day_streaks?: (number|null);
            unique_raid_bosses_defeated?: (number|null);
            unique_pokestops_visited?: (number|null);
            raids_won_with_friends?: (number|null);
            pokemon_caught_at_your_lures?: (number|null);
            num_wayfarer_agreement?: (number|null);
            wayfarer_agreement_update_ms?: (number|Long|null);
            num_total_mega_evolutions?: (number|null);
            num_unique_mega_evolutions?: (number|null);
            num_mini_collection_event_completed?: (number|null);
            num_pokemon_form_changes?: (number|null);
            num_rocket_balloon_battles_won?: (number|null);
            num_rocket_balloon_battles_total?: (number|null);
            num_routes_accepted?: (number|null);
            num_players_referred?: (number|null);
            num_pokestops_ar_video_scanned?: (number|null);
            num_on_raid_achievements_screen?: (number|null);
            num_total_route_play?: (number|null);
            num_unique_route_play?: (number|null);
            num_butterfly_collector?: (number|null);
            xxs_pokemon_caught?: (number|null);
            xxl_pokemon_caught?: (number|null);
            current_postcard_count?: (number|null);
            max_postcard_count?: (number|null);
            contest_stats?: (POGOProtos.Rpc.IPlayerContestStatsProto|null);
            route_discovery_notif_timestamp?: ((number|Long)[]|null);
            num_party_challenges_completed?: (number|null);
            num_party_boosts_contributed?: (number|null);
            num_bread_battles_entered?: (number|null);
            num_bread_battles_won?: (number|null);
            num_bread_battles_dough_won?: (number|null);
            num_check_ins?: (number|null);
        }

        class PlayerStatsProto implements IPlayerStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerStatsProto);
            public level: number;
            public experience: (number|Long);
            public prev_level_exp: (number|Long);
            public next_level_exp: (number|Long);
            public km_walked: number;
            public num_pokemon_encountered: number;
            public num_unique_pokedex_entries: number;
            public num_pokemon_captured: number;
            public num_evolutions: number;
            public poke_stop_visits: number;
            public number_of_pokeball_thrown: number;
            public num_eggs_hatched: number;
            public big_magikarp_caught: number;
            public num_battle_attack_won: number;
            public num_battle_attack_total: number;
            public num_battle_defended_won: number;
            public num_battle_training_won: number;
            public num_battle_training_total: number;
            public prestige_raised_total: number;
            public prestige_dropped_total: number;
            public num_pokemon_deployed: number;
            public num_pokemon_caught_by_type: number[];
            public small_rattata_caught: number;
            public used_km_pool: number;
            public last_km_refill_ms: (number|Long);
            public num_raid_battle_won: number;
            public num_raid_battle_total: number;
            public num_legendary_battle_won: number;
            public num_legendary_battle_total: number;
            public num_berries_fed: number;
            public total_defended_ms: (number|Long);
            public event_badges: POGOProtos.Rpc.HoloBadgeType[];
            public km_walked_past_active_day: number;
            public num_challenge_quests_completed: number;
            public num_trades: number;
            public num_max_level_friends: number;
            public trade_accumulated_distance_km: (number|Long);
            public fitness_report_last_check_bucket: (number|Long);
            public combat_stats?: (POGOProtos.Rpc.IPlayerCombatStatsProto|null);
            public num_npc_combats_won: number;
            public num_npc_combats_total: number;
            public num_photobomb_seen: number;
            public num_pokemon_purified: number;
            public num_grunts_defeated: number;
            public num_best_buddies: number;
            public level_cap: number;
            public seven_day_streaks: number;
            public unique_raid_bosses_defeated: number;
            public unique_pokestops_visited: number;
            public raids_won_with_friends: number;
            public pokemon_caught_at_your_lures: number;
            public num_wayfarer_agreement: number;
            public wayfarer_agreement_update_ms: (number|Long);
            public num_total_mega_evolutions: number;
            public num_unique_mega_evolutions: number;
            public num_mini_collection_event_completed: number;
            public num_pokemon_form_changes: number;
            public num_rocket_balloon_battles_won: number;
            public num_rocket_balloon_battles_total: number;
            public num_routes_accepted: number;
            public num_players_referred: number;
            public num_pokestops_ar_video_scanned: number;
            public num_on_raid_achievements_screen: number;
            public num_total_route_play: number;
            public num_unique_route_play: number;
            public num_butterfly_collector: number;
            public xxs_pokemon_caught: number;
            public xxl_pokemon_caught: number;
            public current_postcard_count: number;
            public max_postcard_count: number;
            public contest_stats?: (POGOProtos.Rpc.IPlayerContestStatsProto|null);
            public route_discovery_notif_timestamp: (number|Long)[];
            public num_party_challenges_completed: number;
            public num_party_boosts_contributed: number;
            public num_bread_battles_entered: number;
            public num_bread_battles_won: number;
            public num_bread_battles_dough_won: number;
            public num_check_ins: number;
            public static encode(message: POGOProtos.Rpc.IPlayerStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerStatsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerStatsSnapshotsProto {
            snap_shot?: (POGOProtos.Rpc.PlayerStatsSnapshotsProto.IPlayerStatsSnapshotProto[]|null);
        }

        class PlayerStatsSnapshotsProto implements IPlayerStatsSnapshotsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerStatsSnapshotsProto);
            public snap_shot: POGOProtos.Rpc.PlayerStatsSnapshotsProto.IPlayerStatsSnapshotProto[];
            public static encode(message: POGOProtos.Rpc.IPlayerStatsSnapshotsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerStatsSnapshotsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerStatsSnapshotsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerStatsSnapshotsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PlayerStatsSnapshotsProto {

            interface IPlayerStatsSnapshotProto {
                reason?: (POGOProtos.Rpc.PlayerStatsSnapshotsProto.PlayerStatsSnapshotProto.Reason|null);
                stats?: (POGOProtos.Rpc.IPlayerStatsProto|null);
            }

            class PlayerStatsSnapshotProto implements IPlayerStatsSnapshotProto {
                constructor(properties?: POGOProtos.Rpc.PlayerStatsSnapshotsProto.IPlayerStatsSnapshotProto);
                public reason: POGOProtos.Rpc.PlayerStatsSnapshotsProto.PlayerStatsSnapshotProto.Reason;
                public stats?: (POGOProtos.Rpc.IPlayerStatsProto|null);
                public static encode(message: POGOProtos.Rpc.PlayerStatsSnapshotsProto.IPlayerStatsSnapshotProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerStatsSnapshotsProto.PlayerStatsSnapshotProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerStatsSnapshotsProto.PlayerStatsSnapshotProto;
                public static toObject(message: POGOProtos.Rpc.PlayerStatsSnapshotsProto.PlayerStatsSnapshotProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PlayerStatsSnapshotProto {

                enum Reason {
                    UNSET = 0,
                    LEVEL_UP = 1
                }
            }
        }

        interface IPlayerUnclaimedPartyQuestIdsProto {
            player_id?: (string|null);
            unclaimed_quest_ids?: (string[]|null);
        }

        class PlayerUnclaimedPartyQuestIdsProto implements IPlayerUnclaimedPartyQuestIdsProto {
            constructor(properties?: POGOProtos.Rpc.IPlayerUnclaimedPartyQuestIdsProto);
            public player_id: string;
            public unclaimed_quest_ids: string[];
            public static encode(message: POGOProtos.Rpc.IPlayerUnclaimedPartyQuestIdsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PlayerUnclaimedPartyQuestIdsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PlayerUnclaimedPartyQuestIdsProto;
            public static toObject(message: POGOProtos.Rpc.PlayerUnclaimedPartyQuestIdsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPluginInfo {
            name?: (string|null);
            version?: (string|null);
            is_niantic_lib?: (boolean|null);
        }

        class PluginInfo implements IPluginInfo {
            constructor(properties?: POGOProtos.Rpc.IPluginInfo);
            public name: string;
            public version: string;
            public is_niantic_lib: boolean;
            public static encode(message: POGOProtos.Rpc.IPluginInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PluginInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PluginInfo;
            public static toObject(message: POGOProtos.Rpc.PluginInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPoiCategorizationEntryTelemetry {
            entry_type?: (POGOProtos.Rpc.PoiCategorizationEntryTelemetry.EntryType|null);
            session_start_time?: (number|Long|null);
            lang_country_code?: (string|null);
        }

        class PoiCategorizationEntryTelemetry implements IPoiCategorizationEntryTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiCategorizationEntryTelemetry);
            public entry_type: POGOProtos.Rpc.PoiCategorizationEntryTelemetry.EntryType;
            public session_start_time: (number|Long);
            public lang_country_code: string;
            public static encode(message: POGOProtos.Rpc.IPoiCategorizationEntryTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiCategorizationEntryTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiCategorizationEntryTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiCategorizationEntryTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PoiCategorizationEntryTelemetry {

            enum EntryType {
                UNSET = 0,
                EDIT = 1,
                NOMINATION = 2
            }
        }

        interface IPoiCategorizationOperationTelemetry {
            operation_type?: (POGOProtos.Rpc.PoiCategorizationOperationTelemetry.OperationType|null);
            session_start_time?: (number|Long|null);
            selected_ids?: (string[]|null);
            lang_country_code?: (string|null);
        }

        class PoiCategorizationOperationTelemetry implements IPoiCategorizationOperationTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiCategorizationOperationTelemetry);
            public operation_type: POGOProtos.Rpc.PoiCategorizationOperationTelemetry.OperationType;
            public session_start_time: (number|Long);
            public selected_ids: string[];
            public lang_country_code: string;
            public static encode(message: POGOProtos.Rpc.IPoiCategorizationOperationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiCategorizationOperationTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiCategorizationOperationTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiCategorizationOperationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PoiCategorizationOperationTelemetry {

            enum OperationType {
                UNSET = 0,
                EDIT_SUBMITTED = 1,
                EDIT_CANCELLED = 2,
                NOMINATION_EXIT_FORWARD = 3,
                NOMINATION_EXIT_BACKWARD = 4
            }
        }

        interface IPoiCategoryRemovedTelemetry {
            session_start_time?: (number|Long|null);
            removed_id?: (string|null);
            remaining_ids?: (string[]|null);
            lang_country_code?: (string|null);
        }

        class PoiCategoryRemovedTelemetry implements IPoiCategoryRemovedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiCategoryRemovedTelemetry);
            public session_start_time: (number|Long);
            public removed_id: string;
            public remaining_ids: string[];
            public lang_country_code: string;
            public static encode(message: POGOProtos.Rpc.IPoiCategoryRemovedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiCategoryRemovedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiCategoryRemovedTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiCategoryRemovedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPoiCategorySelectedTelemetry {
            session_start_time?: (number|Long|null);
            selected_id?: (string|null);
            selected_index?: (number|null);
            search_entered?: (boolean|null);
            parent_selected?: (boolean|null);
            lang_country_code?: (string|null);
        }

        class PoiCategorySelectedTelemetry implements IPoiCategorySelectedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiCategorySelectedTelemetry);
            public session_start_time: (number|Long);
            public selected_id: string;
            public selected_index: number;
            public search_entered: boolean;
            public parent_selected: boolean;
            public lang_country_code: string;
            public static encode(message: POGOProtos.Rpc.IPoiCategorySelectedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiCategorySelectedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiCategorySelectedTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiCategorySelectedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPoiGlobalSettingsProto {
            is_enabled?: (boolean|null);
            player_submission_type_enabled?: (string[]|null);
        }

        class PoiGlobalSettingsProto implements IPoiGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPoiGlobalSettingsProto);
            public is_enabled: boolean;
            public player_submission_type_enabled: string[];
            public static encode(message: POGOProtos.Rpc.IPoiGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PoiGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPoiInteractionTelemetry {
            poi_id?: (string|null);
            poi_type?: (POGOProtos.Rpc.PoiInteractionTelemetry.PoiType|null);
            poi_interaction?: (POGOProtos.Rpc.PoiInteractionTelemetry.PoiInteraction|null);
        }

        class PoiInteractionTelemetry implements IPoiInteractionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiInteractionTelemetry);
            public poi_id: string;
            public poi_type: POGOProtos.Rpc.PoiInteractionTelemetry.PoiType;
            public poi_interaction: POGOProtos.Rpc.PoiInteractionTelemetry.PoiInteraction;
            public static encode(message: POGOProtos.Rpc.IPoiInteractionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiInteractionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiInteractionTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiInteractionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PoiInteractionTelemetry {

            enum PoiInteraction {
                CLICK = 0,
                SPIN = 1
            }

            enum PoiType {
                POKESTOP = 0,
                GYM = 1
            }
        }

        interface IPoiSubmissionPhotoUploadErrorTelemetry {
            error_id?: (POGOProtos.Rpc.PoiSubmissionPhotoUploadErrorTelemetry.PoiSubmissionPhotoUploadErrorIds|null);
            image_type?: (POGOProtos.Rpc.PoiImageType|null);
            error_message?: (string|null);
        }

        class PoiSubmissionPhotoUploadErrorTelemetry implements IPoiSubmissionPhotoUploadErrorTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiSubmissionPhotoUploadErrorTelemetry);
            public error_id: POGOProtos.Rpc.PoiSubmissionPhotoUploadErrorTelemetry.PoiSubmissionPhotoUploadErrorIds;
            public image_type: POGOProtos.Rpc.PoiImageType;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IPoiSubmissionPhotoUploadErrorTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiSubmissionPhotoUploadErrorTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiSubmissionPhotoUploadErrorTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiSubmissionPhotoUploadErrorTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PoiSubmissionPhotoUploadErrorTelemetry {

            enum PoiSubmissionPhotoUploadErrorIds {
                UNSET = 0,
                POI_PHOTO_UPLOAD_ERROR = 1,
                POI_PHOTO_UPLOAD_TIMEOUT = 2
            }
        }

        interface IPoiSubmissionTelemetry {
            gui_event_id?: (POGOProtos.Rpc.PoiSubmissionTelemetry.PoiSubmissionGuiEventId|null);
            image_type?: (POGOProtos.Rpc.PoiImageType|null);
            camera_step_id?: (POGOProtos.Rpc.PoiSubmissionTelemetry.PoiCameraStepIds|null);
            poi_id?: (string|null);
        }

        class PoiSubmissionTelemetry implements IPoiSubmissionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPoiSubmissionTelemetry);
            public gui_event_id: POGOProtos.Rpc.PoiSubmissionTelemetry.PoiSubmissionGuiEventId;
            public image_type: POGOProtos.Rpc.PoiImageType;
            public camera_step_id: POGOProtos.Rpc.PoiSubmissionTelemetry.PoiCameraStepIds;
            public poi_id: string;
            public static encode(message: POGOProtos.Rpc.IPoiSubmissionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PoiSubmissionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PoiSubmissionTelemetry;
            public static toObject(message: POGOProtos.Rpc.PoiSubmissionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PoiSubmissionTelemetry {

            enum PoiCameraStepIds {
                UNSET = 0,
                ENTER = 1,
                RETAKE = 2,
                CONFIRM = 3,
                EXIT = 4
            }

            enum PoiSubmissionGuiEventId {
                UNKNOWN = 0,
                POI_NOMINATION_ENTER = 1,
                POI_TUTORIAL_COMPLETE = 2,
                POI_MAP_CHANGEDVIEW_MAP = 3,
                POI_MAP_CHANGEDVIEW_SATELLITE = 4,
                POI_MAP_CENTER_LOCATION = 5,
                POI_LOCATION_SET = 6,
                POI_PHOTO_CAMERA_ENTER = 7,
                POI_PHOTO_CAMERA_EXIT = 8,
                POI_TITLE_ENTERED = 9,
                POI_DESCRIPTION_ENTER = 10,
                POI_DETAILS_CONFIRM = 11,
                POI_SUPPORTINGINFO_ENTER = 12,
                POI_SUBMIT_BUTTON_HIT = 13,
                POI_EXIT_BUTTON_HIT = 14,
                POI_NOMINATION_GUIDELINES_HIT = 15,
                POI_MAP_TOGGLE_POIS_OFF = 16,
                POI_MAP_TOGGLE_POIS_ON = 17,
                POI_MAP_WAYSPOTS_LOADED = 18,
                POI_MAP_SELECT_POI = 19,
                POI_MAP_SELECT_POI_ABANDON = 20,
                POI_MAP_SELECT_POI_COMPLETED = 21,
                POI_MAP_TUTORIAL_SELECTED = 22
            }
        }

        interface IPointList {
            coords?: (number[]|null);
        }

        class PointList implements IPointList {
            constructor(properties?: POGOProtos.Rpc.IPointList);
            public coords: number[];
            public static encode(message: POGOProtos.Rpc.IPointList, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PointList;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PointList;
            public static toObject(message: POGOProtos.Rpc.PointList, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPointProto {
            lat_degrees?: (number|null);
            lng_degrees?: (number|null);
        }

        class PointProto implements IPointProto {
            constructor(properties?: POGOProtos.Rpc.IPointProto);
            public lat_degrees: number;
            public lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IPointProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PointProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PointProto;
            public static toObject(message: POGOProtos.Rpc.PointProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokeBallAttributesProto {
            item_effect?: (POGOProtos.Rpc.HoloItemEffect|null);
            capture_multi?: (number|null);
            capture_multi_effect?: (number|null);
            item_effect_mod?: (number|null);
        }

        class PokeBallAttributesProto implements IPokeBallAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPokeBallAttributesProto);
            public item_effect: POGOProtos.Rpc.HoloItemEffect;
            public capture_multi: number;
            public capture_multi_effect: number;
            public item_effect_mod: number;
            public static encode(message: POGOProtos.Rpc.IPokeBallAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokeBallAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokeBallAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PokeBallAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokeCandyProto {
            pokemon_id?: (number|Long|null);
            candy_count?: (number|null);
        }

        class PokeCandyProto implements IPokeCandyProto {
            constructor(properties?: POGOProtos.Rpc.IPokeCandyProto);
            public pokemon_id: (number|Long);
            public candy_count: number;
            public static encode(message: POGOProtos.Rpc.IPokeCandyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokeCandyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokeCandyProto;
            public static toObject(message: POGOProtos.Rpc.PokeCandyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokeballThrowPropertySettingsProto {
            throw_properties?: (POGOProtos.Rpc.PokeballThrowPropertySettingsProto.IPokeballThrowPropertiesProto[]|null);
        }

        class PokeballThrowPropertySettingsProto implements IPokeballThrowPropertySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokeballThrowPropertySettingsProto);
            public throw_properties: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.IPokeballThrowPropertiesProto[];
            public static encode(message: POGOProtos.Rpc.IPokeballThrowPropertySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokeballThrowPropertySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokeballThrowPropertySettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokeballThrowPropertySettingsProto {

            interface IPokeballThrowPropertiesProto {
                throw_properties_category?: (POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.Category|null);
                min_spin_particle_amount?: (number|null);
                max_angular_velocity?: (number|null);
                drag_snap_speed?: (number|null);
                overshoot_correction?: (number|null);
                undershoot_correction?: (number|null);
                min_launch_angle?: (number|null);
                max_launch_angle?: (number|null);
                max_launch_angle_height?: (number|null);
                max_launch_speed?: (number|null);
                launch_speed_threshold?: (number|null);
                fly_timeout_duration?: (number|null);
                below_ground_fly_timeout_seconds?: (number|null);
                curveball_modifier?: (POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ICurveballModifierProto|null);
                launch_velocity_multiplier?: (POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ILaunchVelocityMultiplierProto|null);
            }

            class PokeballThrowPropertiesProto implements IPokeballThrowPropertiesProto {
                constructor(properties?: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.IPokeballThrowPropertiesProto);
                public throw_properties_category: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.Category;
                public min_spin_particle_amount: number;
                public max_angular_velocity: number;
                public drag_snap_speed: number;
                public overshoot_correction: number;
                public undershoot_correction: number;
                public min_launch_angle: number;
                public max_launch_angle: number;
                public max_launch_angle_height: number;
                public max_launch_speed: number;
                public launch_speed_threshold: number;
                public fly_timeout_duration: number;
                public below_ground_fly_timeout_seconds: number;
                public curveball_modifier?: (POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ICurveballModifierProto|null);
                public launch_velocity_multiplier?: (POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ILaunchVelocityMultiplierProto|null);
                public static encode(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.IPokeballThrowPropertiesProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto;
                public static toObject(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PokeballThrowPropertiesProto {

                enum Category {
                    UNSET = 0,
                    BREAD = 1
                }

                interface ICurveballModifierProto {
                    x?: (number|null);
                    y?: (number|null);
                    z?: (number|null);
                }

                class CurveballModifierProto implements ICurveballModifierProto {
                    constructor(properties?: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ICurveballModifierProto);
                    public x: number;
                    public y: number;
                    public z: number;
                    public static encode(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ICurveballModifierProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.CurveballModifierProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.CurveballModifierProto;
                    public static toObject(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.CurveballModifierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ILaunchVelocityMultiplierProto {
                    x?: (number|null);
                    y?: (number|null);
                }

                class LaunchVelocityMultiplierProto implements ILaunchVelocityMultiplierProto {
                    constructor(properties?: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ILaunchVelocityMultiplierProto);
                    public x: number;
                    public y: number;
                    public static encode(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.ILaunchVelocityMultiplierProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.LaunchVelocityMultiplierProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.LaunchVelocityMultiplierProto;
                    public static toObject(message: POGOProtos.Rpc.PokeballThrowPropertySettingsProto.PokeballThrowPropertiesProto.LaunchVelocityMultiplierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IPokecoinPurchaseDisplayGmtProto {
            feature_enabled?: (boolean|null);
        }

        class PokecoinPurchaseDisplayGmtProto implements IPokecoinPurchaseDisplayGmtProto {
            constructor(properties?: POGOProtos.Rpc.IPokecoinPurchaseDisplayGmtProto);
            public feature_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPokecoinPurchaseDisplayGmtProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokecoinPurchaseDisplayGmtProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokecoinPurchaseDisplayGmtProto;
            public static toObject(message: POGOProtos.Rpc.PokecoinPurchaseDisplayGmtProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokecoinPurchaseDisplaySettingsProto {
            feature_enabled?: (boolean|null);
            enabled_countries?: (string[]|null);
            enabled_currencies?: (string[]|null);
            use_pokecoin_purchase_display_gmt?: (boolean|null);
        }

        class PokecoinPurchaseDisplaySettingsProto implements IPokecoinPurchaseDisplaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokecoinPurchaseDisplaySettingsProto);
            public feature_enabled: boolean;
            public enabled_countries: string[];
            public enabled_currencies: string[];
            public use_pokecoin_purchase_display_gmt: boolean;
            public static encode(message: POGOProtos.Rpc.IPokecoinPurchaseDisplaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokecoinPurchaseDisplaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokecoinPurchaseDisplaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokecoinPurchaseDisplaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokecoinSectionProto {
            coins_earned_today?: (number|null);
            max_coins_per_day?: (number|null);
            coins_quest_id?: (string|null);
        }

        class PokecoinSectionProto implements IPokecoinSectionProto {
            constructor(properties?: POGOProtos.Rpc.IPokecoinSectionProto);
            public coins_earned_today: number;
            public max_coins_per_day: number;
            public coins_quest_id: string;
            public static encode(message: POGOProtos.Rpc.IPokecoinSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokecoinSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokecoinSectionProto;
            public static toObject(message: POGOProtos.Rpc.PokecoinSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexCategoriesSettingsProto {
            feature_enabled?: (boolean|null);
            pokedex_category_settings_in_order?: (POGOProtos.Rpc.PokedexCategoriesSettingsProto.IPokedexCategorySettingsProto[]|null);
            client_shiny_form_check?: (boolean|null);
            search_enabled?: (boolean|null);
            show_dex_after_new_form_enabled?: (boolean|null);
            show_shiny_dex_celebration_enabled?: (boolean|null);
        }

        class PokedexCategoriesSettingsProto implements IPokedexCategoriesSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexCategoriesSettingsProto);
            public feature_enabled: boolean;
            public pokedex_category_settings_in_order: POGOProtos.Rpc.PokedexCategoriesSettingsProto.IPokedexCategorySettingsProto[];
            public client_shiny_form_check: boolean;
            public search_enabled: boolean;
            public show_dex_after_new_form_enabled: boolean;
            public show_shiny_dex_celebration_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPokedexCategoriesSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexCategoriesSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexCategoriesSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokedexCategoriesSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokedexCategoriesSettingsProto {

            interface IPokedexCategorySettingsProto {
                pokedex_category?: (POGOProtos.Rpc.PokedexCategory|null);
                milestone_goal?: (number|null);
                visually_hidden?: (boolean|null);
            }

            class PokedexCategorySettingsProto implements IPokedexCategorySettingsProto {
                constructor(properties?: POGOProtos.Rpc.PokedexCategoriesSettingsProto.IPokedexCategorySettingsProto);
                public pokedex_category: POGOProtos.Rpc.PokedexCategory;
                public milestone_goal: number;
                public visually_hidden: boolean;
                public static encode(message: POGOProtos.Rpc.PokedexCategoriesSettingsProto.IPokedexCategorySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexCategoriesSettingsProto.PokedexCategorySettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexCategoriesSettingsProto.PokedexCategorySettingsProto;
                public static toObject(message: POGOProtos.Rpc.PokedexCategoriesSettingsProto.PokedexCategorySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPokedexCategoryMilestoneProto {
            pokedex_category?: (POGOProtos.Rpc.PokedexCategory|null);
            status?: (POGOProtos.Rpc.PokedexCategoryMilestoneProto.Status|null);
            progress?: (number|null);
        }

        class PokedexCategoryMilestoneProto implements IPokedexCategoryMilestoneProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexCategoryMilestoneProto);
            public pokedex_category: POGOProtos.Rpc.PokedexCategory;
            public status: POGOProtos.Rpc.PokedexCategoryMilestoneProto.Status;
            public progress: number;
            public static encode(message: POGOProtos.Rpc.IPokedexCategoryMilestoneProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexCategoryMilestoneProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexCategoryMilestoneProto;
            public static toObject(message: POGOProtos.Rpc.PokedexCategoryMilestoneProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokedexCategoryMilestoneProto {

            enum Status {
                UNSET = 0,
                ACTIVE = 1,
                UNLOCKED = 2
            }
        }

        interface IPokedexCategorySelectedTelemetry {
            category?: (POGOProtos.Rpc.PokedexCategory|null);
        }

        class PokedexCategorySelectedTelemetry implements IPokedexCategorySelectedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokedexCategorySelectedTelemetry);
            public category: POGOProtos.Rpc.PokedexCategory;
            public static encode(message: POGOProtos.Rpc.IPokedexCategorySelectedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexCategorySelectedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexCategorySelectedTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokedexCategorySelectedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexEntryProto {
            pokedex_entry_number?: (number|null);
            times_encountered?: (number|null);
            times_captured?: (number|null);
            evolution_stone_pieces?: (number|null);
            evolution_stones?: (number|null);
            captured_costumes?: (POGOProtos.Rpc.PokemonDisplayProto.Costume[]|null);
            captured_forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            captured_genders?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
            captured_shiny?: (boolean|null);
            encountered_costumes?: (POGOProtos.Rpc.PokemonDisplayProto.Costume[]|null);
            encountered_forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            encountered_genders?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
            encountered_shiny?: (boolean|null);
            times_lucky_received?: (number|null);
            times_purified?: (number|null);
            temp_evo_data?: (POGOProtos.Rpc.PokedexEntryProto.ITempEvoData[]|null);
            captured_shiny_forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            category_status?: ({ [k: string]: POGOProtos.Rpc.PokedexEntryProto.IPokedexCategoryStatus }|null);
            captured_shiny_alignments?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment[]|null);
            stats?: (POGOProtos.Rpc.IPokedexStatsProto|null);
            stats_for_forms?: ({ [k: string]: POGOProtos.Rpc.IPokedexStatsProto }|null);
            location_cards?: (POGOProtos.Rpc.LocationCard[]|null);
            location_cards_for_forms?: ({ [k: string]: POGOProtos.Rpc.IPokedexLocationCardStatsProto }|null);
            bread_dex_data?: (POGOProtos.Rpc.PokedexEntryProto.IBreadDexData[]|null);
            last_capture_timestamp_ms?: (number|Long|null);
        }

        class PokedexEntryProto implements IPokedexEntryProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexEntryProto);
            public pokedex_entry_number: number;
            public times_encountered: number;
            public times_captured: number;
            public evolution_stone_pieces: number;
            public evolution_stones: number;
            public captured_costumes: POGOProtos.Rpc.PokemonDisplayProto.Costume[];
            public captured_forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public captured_genders: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
            public captured_shiny: boolean;
            public encountered_costumes: POGOProtos.Rpc.PokemonDisplayProto.Costume[];
            public encountered_forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public encountered_genders: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
            public encountered_shiny: boolean;
            public times_lucky_received: number;
            public times_purified: number;
            public temp_evo_data: POGOProtos.Rpc.PokedexEntryProto.ITempEvoData[];
            public captured_shiny_forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public category_status: { [k: string]: POGOProtos.Rpc.PokedexEntryProto.IPokedexCategoryStatus };
            public captured_shiny_alignments: POGOProtos.Rpc.PokemonDisplayProto.Alignment[];
            public stats?: (POGOProtos.Rpc.IPokedexStatsProto|null);
            public stats_for_forms: { [k: string]: POGOProtos.Rpc.IPokedexStatsProto };
            public location_cards: POGOProtos.Rpc.LocationCard[];
            public location_cards_for_forms: { [k: string]: POGOProtos.Rpc.IPokedexLocationCardStatsProto };
            public bread_dex_data: POGOProtos.Rpc.PokedexEntryProto.IBreadDexData[];
            public last_capture_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPokedexEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexEntryProto;
            public static toObject(message: POGOProtos.Rpc.PokedexEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokedexEntryProto {

            interface IPokedexCategoryStatus {
                pokedex_category?: (POGOProtos.Rpc.PokedexCategory|null);
                encountered?: (boolean|null);
                acquired?: (boolean|null);
                last_capture_timestamp_ms?: (number|Long|null);
            }

            class PokedexCategoryStatus implements IPokedexCategoryStatus {
                constructor(properties?: POGOProtos.Rpc.PokedexEntryProto.IPokedexCategoryStatus);
                public pokedex_category: POGOProtos.Rpc.PokedexCategory;
                public encountered: boolean;
                public acquired: boolean;
                public last_capture_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.PokedexEntryProto.IPokedexCategoryStatus, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexEntryProto.PokedexCategoryStatus;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexEntryProto.PokedexCategoryStatus;
                public static toObject(message: POGOProtos.Rpc.PokedexEntryProto.PokedexCategoryStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITempEvoData {
                temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
                times_encountered?: (number|null);
                times_obtained?: (number|null);
                genders_encountered?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
                genders_obtained?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
                times_encountered_shiny?: (number|null);
                times_obtained_shiny?: (number|null);
                last_obtained_timestamp_ms?: (number|Long|null);
            }

            class TempEvoData implements ITempEvoData {
                constructor(properties?: POGOProtos.Rpc.PokedexEntryProto.ITempEvoData);
                public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
                public times_encountered: number;
                public times_obtained: number;
                public genders_encountered: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
                public genders_obtained: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
                public times_encountered_shiny: number;
                public times_obtained_shiny: number;
                public last_obtained_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.PokedexEntryProto.ITempEvoData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexEntryProto.TempEvoData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexEntryProto.TempEvoData;
                public static toObject(message: POGOProtos.Rpc.PokedexEntryProto.TempEvoData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBreadDexData {
                modifier_id?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
                times_encountered?: (number|null);
                times_obtained?: (number|null);
                genders_encountered?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
                genders_obtained?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
                encountered_shiny_gender?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
                obtained_shiny_gender?: (POGOProtos.Rpc.PokemonDisplayProto.Gender[]|null);
            }

            class BreadDexData implements IBreadDexData {
                constructor(properties?: POGOProtos.Rpc.PokedexEntryProto.IBreadDexData);
                public modifier_id: POGOProtos.Rpc.BreadModeEnum.Modifier;
                public times_encountered: number;
                public times_obtained: number;
                public genders_encountered: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
                public genders_obtained: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
                public encountered_shiny_gender: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
                public obtained_shiny_gender: POGOProtos.Rpc.PokemonDisplayProto.Gender[];
                public static encode(message: POGOProtos.Rpc.PokedexEntryProto.IBreadDexData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexEntryProto.BreadDexData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexEntryProto.BreadDexData;
                public static toObject(message: POGOProtos.Rpc.PokedexEntryProto.BreadDexData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPokedexFilterSelectedTelemetry {
            filter_name?: (string|null);
        }

        class PokedexFilterSelectedTelemetry implements IPokedexFilterSelectedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokedexFilterSelectedTelemetry);
            public filter_name: string;
            public static encode(message: POGOProtos.Rpc.IPokedexFilterSelectedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexFilterSelectedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexFilterSelectedTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokedexFilterSelectedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexLocationCardStatsProto {
            location_cards?: (POGOProtos.Rpc.LocationCard[]|null);
        }

        class PokedexLocationCardStatsProto implements IPokedexLocationCardStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexLocationCardStatsProto);
            public location_cards: POGOProtos.Rpc.LocationCard[];
            public static encode(message: POGOProtos.Rpc.IPokedexLocationCardStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexLocationCardStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexLocationCardStatsProto;
            public static toObject(message: POGOProtos.Rpc.PokedexLocationCardStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexPokemonSelectedTelemetry {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_name?: (string|null);
            seen_count?: (number|null);
            caught_count?: (number|null);
            lucky_count?: (number|null);
        }

        class PokedexPokemonSelectedTelemetry implements IPokedexPokemonSelectedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokedexPokemonSelectedTelemetry);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_name: string;
            public seen_count: number;
            public caught_count: number;
            public lucky_count: number;
            public static encode(message: POGOProtos.Rpc.IPokedexPokemonSelectedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexPokemonSelectedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexPokemonSelectedTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokedexPokemonSelectedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexPreferencesProto {
            tracked_pokemon?: (POGOProtos.Rpc.ITrackedPokemonProto[]|null);
        }

        class PokedexPreferencesProto implements IPokedexPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexPreferencesProto);
            public tracked_pokemon: POGOProtos.Rpc.ITrackedPokemonProto[];
            public static encode(message: POGOProtos.Rpc.IPokedexPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.PokedexPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexRegionSelectedTelemetry {
            region_generation?: (string|null);
        }

        class PokedexRegionSelectedTelemetry implements IPokedexRegionSelectedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokedexRegionSelectedTelemetry);
            public region_generation: string;
            public static encode(message: POGOProtos.Rpc.IPokedexRegionSelectedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexRegionSelectedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexRegionSelectedTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokedexRegionSelectedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexSessionTelemetry {
            open_timestamp_ms?: (number|Long|null);
            close_timestamp_ms?: (number|Long|null);
        }

        class PokedexSessionTelemetry implements IPokedexSessionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokedexSessionTelemetry);
            public open_timestamp_ms: (number|Long);
            public close_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPokedexSessionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexSessionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexSessionTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokedexSessionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexSizeStatsSystemSettingsProto {
            update_enabled?: (boolean|null);
            display_enabled?: (boolean|null);
            pokedex_display_pokemon_tracked_threshold?: (number|null);
            record_display_pokemon_tracked_threshold?: (number|null);
            update_from_inventory_timestamp_ms?: (number|Long|null);
            num_days_new_bubble_track?: (number|null);
            enable_randomized_height_and_weight_for_wild_pokemon?: (boolean|null);
        }

        class PokedexSizeStatsSystemSettingsProto implements IPokedexSizeStatsSystemSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexSizeStatsSystemSettingsProto);
            public update_enabled: boolean;
            public display_enabled: boolean;
            public pokedex_display_pokemon_tracked_threshold: number;
            public record_display_pokemon_tracked_threshold: number;
            public update_from_inventory_timestamp_ms: (number|Long);
            public num_days_new_bubble_track: number;
            public enable_randomized_height_and_weight_for_wild_pokemon: boolean;
            public static encode(message: POGOProtos.Rpc.IPokedexSizeStatsSystemSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexSizeStatsSystemSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexSizeStatsSystemSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokedexSizeStatsSystemSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexStatProto {
            min_value?: (POGOProtos.Rpc.IPokemonStatValueProto|null);
            max_value?: (POGOProtos.Rpc.IPokemonStatValueProto|null);
        }

        class PokedexStatProto implements IPokedexStatProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexStatProto);
            public min_value?: (POGOProtos.Rpc.IPokemonStatValueProto|null);
            public max_value?: (POGOProtos.Rpc.IPokemonStatValueProto|null);
            public static encode(message: POGOProtos.Rpc.IPokedexStatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexStatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexStatProto;
            public static toObject(message: POGOProtos.Rpc.PokedexStatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexStatsProto {
            num_pokemon_tracked?: (number|null);
            height?: (POGOProtos.Rpc.IPokedexStatProto|null);
            weight?: (POGOProtos.Rpc.IPokedexStatProto|null);
        }

        class PokedexStatsProto implements IPokedexStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexStatsProto);
            public num_pokemon_tracked: number;
            public height?: (POGOProtos.Rpc.IPokedexStatProto|null);
            public weight?: (POGOProtos.Rpc.IPokedexStatProto|null);
            public static encode(message: POGOProtos.Rpc.IPokedexStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexStatsProto;
            public static toObject(message: POGOProtos.Rpc.PokedexStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexV2FeatureFlagProto {
            is_feature_enabled?: (boolean|null);
            navigation_flag?: (number|null);
            detail_v1_flag?: (number|null);
            detail_evo_flag?: (number|null);
            detail_battle_flag?: (number|null);
            celeb_v1_flag?: (number|null);
            celeb_v2_flag?: (number|null);
            notification_flag?: (number|null);
        }

        class PokedexV2FeatureFlagProto implements IPokedexV2FeatureFlagProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexV2FeatureFlagProto);
            public is_feature_enabled: boolean;
            public navigation_flag: number;
            public detail_v1_flag: number;
            public detail_evo_flag: number;
            public detail_battle_flag: number;
            public celeb_v1_flag: number;
            public celeb_v2_flag: number;
            public notification_flag: number;
            public static encode(message: POGOProtos.Rpc.IPokedexV2FeatureFlagProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexV2FeatureFlagProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexV2FeatureFlagProto;
            public static toObject(message: POGOProtos.Rpc.PokedexV2FeatureFlagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexV2GlobalSettingsProto {
            navigation_flag?: (number|null);
            details_flag?: (number|null);
            celebration_flag?: (number|null);
            notifications_flag?: (number|null);
        }

        class PokedexV2GlobalSettingsProto implements IPokedexV2GlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexV2GlobalSettingsProto);
            public navigation_flag: number;
            public details_flag: number;
            public celebration_flag: number;
            public notifications_flag: number;
            public static encode(message: POGOProtos.Rpc.IPokedexV2GlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexV2GlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexV2GlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokedexV2GlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexV2SettingsProto {
            max_tracked_pokemon?: (number|null);
            pokemon_alert_excluded?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            pokemon_alert_auto_tracked?: (POGOProtos.Rpc.HoloPokemonId[]|null);
        }

        class PokedexV2SettingsProto implements IPokedexV2SettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokedexV2SettingsProto);
            public max_tracked_pokemon: number;
            public pokemon_alert_excluded: POGOProtos.Rpc.HoloPokemonId[];
            public pokemon_alert_auto_tracked: POGOProtos.Rpc.HoloPokemonId[];
            public static encode(message: POGOProtos.Rpc.IPokedexV2SettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokedexV2SettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokedexV2SettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokedexV2SettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonBonusStatLevelProto {
            bonus_individual_attack?: (number|null);
            bonus_individual_defense?: (number|null);
            bonus_individual_stamina?: (number|null);
        }

        class PokemonBonusStatLevelProto implements IPokemonBonusStatLevelProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonBonusStatLevelProto);
            public bonus_individual_attack: number;
            public bonus_individual_defense: number;
            public bonus_individual_stamina: number;
            public static encode(message: POGOProtos.Rpc.IPokemonBonusStatLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonBonusStatLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonBonusStatLevelProto;
            public static toObject(message: POGOProtos.Rpc.PokemonBonusStatLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonCameraAttributesProto {
            disk_radius_m?: (number|null);
            cyl_radius_m?: (number|null);
            cyl_height_m?: (number|null);
            cyl_ground_m?: (number|null);
            shoulder_mode_scale?: (number|null);
        }

        class PokemonCameraAttributesProto implements IPokemonCameraAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonCameraAttributesProto);
            public disk_radius_m: number;
            public cyl_radius_m: number;
            public cyl_height_m: number;
            public cyl_ground_m: number;
            public shoulder_mode_scale: number;
            public static encode(message: POGOProtos.Rpc.IPokemonCameraAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonCameraAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonCameraAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PokemonCameraAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonCandyRewardProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            amount?: (number|null);
        }

        class PokemonCandyRewardProto implements IPokemonCandyRewardProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonCandyRewardProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public amount: number;
            public static encode(message: POGOProtos.Rpc.IPokemonCandyRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonCandyRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonCandyRewardProto;
            public static toObject(message: POGOProtos.Rpc.PokemonCandyRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonClassOverrideProto {
            override?: (boolean|null);
            pokemon_class_override?: (POGOProtos.Rpc.HoloPokemonClass|null);
        }

        class PokemonClassOverrideProto implements IPokemonClassOverrideProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonClassOverrideProto);
            public override: boolean;
            public pokemon_class_override: POGOProtos.Rpc.HoloPokemonClass;
            public static encode(message: POGOProtos.Rpc.IPokemonClassOverrideProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonClassOverrideProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonClassOverrideProto;
            public static toObject(message: POGOProtos.Rpc.PokemonClassOverrideProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonClassOverridesProto {
            player_activity_catch?: (POGOProtos.Rpc.IPokemonClassOverrideProto|null);
        }

        class PokemonClassOverridesProto implements IPokemonClassOverridesProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonClassOverridesProto);
            public player_activity_catch?: (POGOProtos.Rpc.IPokemonClassOverrideProto|null);
            public static encode(message: POGOProtos.Rpc.IPokemonClassOverridesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonClassOverridesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonClassOverridesProto;
            public static toObject(message: POGOProtos.Rpc.PokemonClassOverridesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonCombatStatsProto {
            num_won?: (number|null);
            num_total?: (number|null);
        }

        class PokemonCombatStatsProto implements IPokemonCombatStatsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonCombatStatsProto);
            public num_won: number;
            public num_total: number;
            public static encode(message: POGOProtos.Rpc.IPokemonCombatStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonCombatStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonCombatStatsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonCombatStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonCompareChallenge {
            compare_stat?: (POGOProtos.Rpc.PokemonCompareChallenge.CompareStat|null);
            compare_operation?: (POGOProtos.Rpc.PokemonCompareChallenge.CompareOperation|null);
        }

        class PokemonCompareChallenge implements IPokemonCompareChallenge {
            constructor(properties?: POGOProtos.Rpc.IPokemonCompareChallenge);
            public compare_stat: POGOProtos.Rpc.PokemonCompareChallenge.CompareStat;
            public compare_operation: POGOProtos.Rpc.PokemonCompareChallenge.CompareOperation;
            public static encode(message: POGOProtos.Rpc.IPokemonCompareChallenge, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonCompareChallenge;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonCompareChallenge;
            public static toObject(message: POGOProtos.Rpc.PokemonCompareChallenge, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonCompareChallenge {

            enum CompareOperation {
                UNSET_OPERATION = 0,
                GREATER_WIN = 1,
                LESSER_WIN = 2
            }

            enum CompareStat {
                UNSET_STAT = 0,
                WEIGHT = 1,
                HEIGHT = 2,
                AGE = 3,
                WALKED_DISTANCE_KM = 4,
                CP = 5,
                MAX_HP = 6
            }
        }

        interface IPokemonContestInfoProto {
            contest_id?: (string|null);
            contest_end_time_ms?: (number|Long|null);
            free_up_time_ms?: (number|Long|null);
        }

        class PokemonContestInfoProto implements IPokemonContestInfoProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonContestInfoProto);
            public contest_id: string;
            public contest_end_time_ms: (number|Long);
            public free_up_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPokemonContestInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonContestInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonContestInfoProto;
            public static toObject(message: POGOProtos.Rpc.PokemonContestInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonCreateDetail {
            wild_detail?: (POGOProtos.Rpc.IWildCreateDetail|null);
            egg_detail?: (POGOProtos.Rpc.IEggCreateDetail|null);
            raid_detail?: (POGOProtos.Rpc.IRaidCreateDetail|null);
            quest_detail?: (POGOProtos.Rpc.IQuestCreateDetail|null);
            vs_seeker_detail?: (POGOProtos.Rpc.IVsSeekerCreateDetail|null);
            invasion_detail?: (POGOProtos.Rpc.IInvasionCreateDetail|null);
            photobomb_detail?: (POGOProtos.Rpc.IPhotobombCreateDetail|null);
            tutorial_detail?: (POGOProtos.Rpc.ITutorialCreateDetail|null);
            postcard_detail?: (POGOProtos.Rpc.IPostcardCreateDetail|null);
            station_detail?: (POGOProtos.Rpc.IStationCreateDetail|null);
            incense_detail?: (POGOProtos.Rpc.IIncenseCreateDetail|null);
            disk_detail?: (POGOProtos.Rpc.IDiskCreateDetail|null);
            bread_battle_detail?: (POGOProtos.Rpc.IBreadBattleCreateDetail|null);
        }

        class PokemonCreateDetail implements IPokemonCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IPokemonCreateDetail);
            public wild_detail?: (POGOProtos.Rpc.IWildCreateDetail|null);
            public egg_detail?: (POGOProtos.Rpc.IEggCreateDetail|null);
            public raid_detail?: (POGOProtos.Rpc.IRaidCreateDetail|null);
            public quest_detail?: (POGOProtos.Rpc.IQuestCreateDetail|null);
            public vs_seeker_detail?: (POGOProtos.Rpc.IVsSeekerCreateDetail|null);
            public invasion_detail?: (POGOProtos.Rpc.IInvasionCreateDetail|null);
            public photobomb_detail?: (POGOProtos.Rpc.IPhotobombCreateDetail|null);
            public tutorial_detail?: (POGOProtos.Rpc.ITutorialCreateDetail|null);
            public postcard_detail?: (POGOProtos.Rpc.IPostcardCreateDetail|null);
            public station_detail?: (POGOProtos.Rpc.IStationCreateDetail|null);
            public incense_detail?: (POGOProtos.Rpc.IIncenseCreateDetail|null);
            public disk_detail?: (POGOProtos.Rpc.IDiskCreateDetail|null);
            public bread_battle_detail?: (POGOProtos.Rpc.IBreadBattleCreateDetail|null);
            public OriginDetail?: ("wild_detail"|"egg_detail"|"raid_detail"|"quest_detail"|"vs_seeker_detail"|"invasion_detail"|"photobomb_detail"|"tutorial_detail"|"postcard_detail"|"station_detail"|"incense_detail"|"disk_detail"|"bread_battle_detail");
            public static encode(message: POGOProtos.Rpc.IPokemonCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonCreateDetail;
            public static toObject(message: POGOProtos.Rpc.PokemonCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonDisplayProto {
            costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            gender?: (POGOProtos.Rpc.PokemonDisplayProto.Gender|null);
            shiny?: (boolean|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            weather_boosted_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment|null);
            pokemon_badge?: (POGOProtos.Rpc.PokemonBadge|null);
            current_temp_evolution?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            temporary_evolution_finish_ms?: (number|Long|null);
            temp_evolution_is_locked?: (boolean|null);
            locked_temp_evolution?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            original_costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            display_id?: (number|Long|null);
            mega_evolution_level?: (POGOProtos.Rpc.IPokemonMegaEvolutionLevelProto|null);
            location_card?: (POGOProtos.Rpc.ILocationCardDisplayProto|null);
            bread_mode_enum?: (POGOProtos.Rpc.BreadModeEnum.Modifier|null);
            is_strong_pokemon?: (boolean|null);
        }

        class PokemonDisplayProto implements IPokemonDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonDisplayProto);
            public costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public gender: POGOProtos.Rpc.PokemonDisplayProto.Gender;
            public shiny: boolean;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public weather_boosted_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment;
            public pokemon_badge: POGOProtos.Rpc.PokemonBadge;
            public current_temp_evolution: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public temporary_evolution_finish_ms: (number|Long);
            public temp_evolution_is_locked: boolean;
            public locked_temp_evolution: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public original_costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public display_id: (number|Long);
            public mega_evolution_level?: (POGOProtos.Rpc.IPokemonMegaEvolutionLevelProto|null);
            public location_card?: (POGOProtos.Rpc.ILocationCardDisplayProto|null);
            public bread_mode_enum: POGOProtos.Rpc.BreadModeEnum.Modifier;
            public is_strong_pokemon: boolean;
            public static encode(message: POGOProtos.Rpc.IPokemonDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonDisplayProto;
            public static toObject(message: POGOProtos.Rpc.PokemonDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonDisplayProto {

            enum Costume {
                UNSET = 0,
                HOLIDAY_2016 = 1,
                ANNIVERSARY = 2,
                ONE_YEAR_ANNIVERSARY = 3,
                HALLOWEEN_2017 = 4,
                SUMMER_2018 = 5,
                FALL_2018 = 6,
                NOVEMBER_2018 = 7,
                WINTER_2018 = 8,
                FEB_2019 = 9,
                MAY_2019_NOEVOLVE = 10,
                JAN_2020_NOEVOLVE = 11,
                APRIL_2020_NOEVOLVE = 12,
                SAFARI_2020_NOEVOLVE = 13,
                SPRING_2020_NOEVOLVE = 14,
                SUMMER_2020_NOEVOLVE = 15,
                FALL_2020_NOEVOLVE = 16,
                WINTER_2020_NOEVOLVE = 17,
                NOT_FOR_RELEASE_ALPHA = 18,
                NOT_FOR_RELEASE_BETA = 19,
                NOT_FOR_RELEASE_GAMMA = 20,
                NOT_FOR_RELEASE_NOEVOLVE = 21,
                KANTO_2020_NOEVOLVE = 22,
                JOHTO_2020_NOEVOLVE = 23,
                HOENN_2020_NOEVOLVE = 24,
                SINNOH_2020_NOEVOLVE = 25,
                HALLOWEEN_2020_NOEVOLVE = 26,
                COSTUME_1 = 27,
                COSTUME_2 = 28,
                COSTUME_3 = 29,
                COSTUME_4 = 30,
                COSTUME_5 = 31,
                COSTUME_6 = 32,
                COSTUME_7 = 33,
                COSTUME_8 = 34,
                COSTUME_9 = 35,
                COSTUME_10 = 36,
                COSTUME_1_NOEVOLVE = 37,
                COSTUME_2_NOEVOLVE = 38,
                COSTUME_3_NOEVOLVE = 39,
                COSTUME_4_NOEVOLVE = 40,
                COSTUME_5_NOEVOLVE = 41,
                COSTUME_6_NOEVOLVE = 42,
                COSTUME_7_NOEVOLVE = 43,
                COSTUME_8_NOEVOLVE = 44,
                COSTUME_9_NOEVOLVE = 45,
                COSTUME_10_NOEVOLVE = 46,
                GOFEST_2021_NOEVOLVE = 47,
                FASHION_2021_NOEVOLVE = 48,
                HALLOWEEN_2021_NOEVOLVE = 49,
                GEMS_1_2021_NOEVOLVE = 50,
                GEMS_2_2021_NOEVOLVE = 51,
                HOLIDAY_2021_NOEVOLVE = 52,
                TCG_2022_NOEVOLVE = 53,
                JAN_2022_NOEVOLVE = 54,
                GOFEST_2022_NOEVOLVE = 55,
                ANNIVERSARY_2022_NOEVOLVE = 56,
                FALL_2022 = 57,
                FALL_2022_NOEVOLVE = 58,
                HOLIDAY_2022 = 59,
                JAN_2023_NOEVOLVE = 60,
                GOTOUR_2023_BANDANA_NOEVOLVE = 61,
                GOTOUR_2023_HAT_NOEVOLVE = 62,
                SPRING_2023 = 63,
                SPRING_2023_MYSTIC = 64,
                SPRING_2023_VALOR = 65,
                SPRING_2023_INSTINCT = 66,
                NIGHTCAP = 67,
                MAY_2023 = 68,
                PI = 69,
                FALL_2023 = 70,
                FALL_2023_NOEVOLVE = 71,
                PI_NOEVOLVE = 72,
                HOLIDAY_2023 = 73,
                JAN_2024 = 74,
                SPRING_2024 = 75,
                SUMMER_2024 = 77,
                ANNIVERSARY_2024 = 78,
                FALL_2024 = 79,
                WINTER_2024 = 80,
                FASHION_2025 = 81,
                HORIZONS_2025_NOEVOLVE = 82,
                ROYAL_NOEVOLVE = 83
            }

            enum Gender {
                GENDER_UNSET = 0,
                MALE = 1,
                FEMALE = 2,
                GENDERLESS = 3
            }

            enum Alignment {
                ALIGNMENT_UNSET = 0,
                SHADOW = 1,
                PURIFIED = 2
            }

            enum Form {
                FORM_UNSET = 0,
                UNOWN_A = 1,
                UNOWN_B = 2,
                UNOWN_C = 3,
                UNOWN_D = 4,
                UNOWN_E = 5,
                UNOWN_F = 6,
                UNOWN_G = 7,
                UNOWN_H = 8,
                UNOWN_I = 9,
                UNOWN_J = 10,
                UNOWN_K = 11,
                UNOWN_L = 12,
                UNOWN_M = 13,
                UNOWN_N = 14,
                UNOWN_O = 15,
                UNOWN_P = 16,
                UNOWN_Q = 17,
                UNOWN_R = 18,
                UNOWN_S = 19,
                UNOWN_T = 20,
                UNOWN_U = 21,
                UNOWN_V = 22,
                UNOWN_W = 23,
                UNOWN_X = 24,
                UNOWN_Y = 25,
                UNOWN_Z = 26,
                UNOWN_EXCLAMATION_POINT = 27,
                UNOWN_QUESTION_MARK = 28,
                CASTFORM_NORMAL = 29,
                CASTFORM_SUNNY = 30,
                CASTFORM_RAINY = 31,
                CASTFORM_SNOWY = 32,
                DEOXYS_NORMAL = 33,
                DEOXYS_ATTACK = 34,
                DEOXYS_DEFENSE = 35,
                DEOXYS_SPEED = 36,
                SPINDA_00 = 37,
                SPINDA_01 = 38,
                SPINDA_02 = 39,
                SPINDA_03 = 40,
                SPINDA_04 = 41,
                SPINDA_05 = 42,
                SPINDA_06 = 43,
                SPINDA_07 = 44,
                RATTATA_NORMAL = 45,
                RATTATA_ALOLA = 46,
                RATICATE_NORMAL = 47,
                RATICATE_ALOLA = 48,
                RAICHU_NORMAL = 49,
                RAICHU_ALOLA = 50,
                SANDSHREW_NORMAL = 51,
                SANDSHREW_ALOLA = 52,
                SANDSLASH_NORMAL = 53,
                SANDSLASH_ALOLA = 54,
                VULPIX_NORMAL = 55,
                VULPIX_ALOLA = 56,
                NINETALES_NORMAL = 57,
                NINETALES_ALOLA = 58,
                DIGLETT_NORMAL = 59,
                DIGLETT_ALOLA = 60,
                DUGTRIO_NORMAL = 61,
                DUGTRIO_ALOLA = 62,
                MEOWTH_NORMAL = 63,
                MEOWTH_ALOLA = 64,
                PERSIAN_NORMAL = 65,
                PERSIAN_ALOLA = 66,
                GEODUDE_NORMAL = 67,
                GEODUDE_ALOLA = 68,
                GRAVELER_NORMAL = 69,
                GRAVELER_ALOLA = 70,
                GOLEM_NORMAL = 71,
                GOLEM_ALOLA = 72,
                GRIMER_NORMAL = 73,
                GRIMER_ALOLA = 74,
                MUK_NORMAL = 75,
                MUK_ALOLA = 76,
                EXEGGUTOR_NORMAL = 77,
                EXEGGUTOR_ALOLA = 78,
                MAROWAK_NORMAL = 79,
                MAROWAK_ALOLA = 80,
                ROTOM_NORMAL = 81,
                ROTOM_FROST = 82,
                ROTOM_FAN = 83,
                ROTOM_MOW = 84,
                ROTOM_WASH = 85,
                ROTOM_HEAT = 86,
                WORMADAM_PLANT = 87,
                WORMADAM_SANDY = 88,
                WORMADAM_TRASH = 89,
                GIRATINA_ALTERED = 90,
                GIRATINA_ORIGIN = 91,
                SHAYMIN_SKY = 92,
                SHAYMIN_LAND = 93,
                CHERRIM_OVERCAST = 94,
                CHERRIM_SUNNY = 95,
                SHELLOS_WEST_SEA = 96,
                SHELLOS_EAST_SEA = 97,
                GASTRODON_WEST_SEA = 98,
                GASTRODON_EAST_SEA = 99,
                ARCEUS_NORMAL = 100,
                ARCEUS_FIGHTING = 101,
                ARCEUS_FLYING = 102,
                ARCEUS_POISON = 103,
                ARCEUS_GROUND = 104,
                ARCEUS_ROCK = 105,
                ARCEUS_BUG = 106,
                ARCEUS_GHOST = 107,
                ARCEUS_STEEL = 108,
                ARCEUS_FIRE = 109,
                ARCEUS_WATER = 110,
                ARCEUS_GRASS = 111,
                ARCEUS_ELECTRIC = 112,
                ARCEUS_PSYCHIC = 113,
                ARCEUS_ICE = 114,
                ARCEUS_DRAGON = 115,
                ARCEUS_DARK = 116,
                ARCEUS_FAIRY = 117,
                BURMY_PLANT = 118,
                BURMY_SANDY = 119,
                BURMY_TRASH = 120,
                SPINDA_08 = 121,
                SPINDA_09 = 122,
                SPINDA_10 = 123,
                SPINDA_11 = 124,
                SPINDA_12 = 125,
                SPINDA_13 = 126,
                SPINDA_14 = 127,
                SPINDA_15 = 128,
                SPINDA_16 = 129,
                SPINDA_17 = 130,
                SPINDA_18 = 131,
                SPINDA_19 = 132,
                MEWTWO_A = 133,
                MEWTWO_NORMAL = 135,
                BASCULIN_RED_STRIPED = 136,
                BASCULIN_BLUE_STRIPED = 137,
                DARMANITAN_STANDARD = 138,
                DARMANITAN_ZEN = 139,
                TORNADUS_INCARNATE = 140,
                TORNADUS_THERIAN = 141,
                THUNDURUS_INCARNATE = 142,
                THUNDURUS_THERIAN = 143,
                LANDORUS_INCARNATE = 144,
                LANDORUS_THERIAN = 145,
                KYUREM_NORMAL = 146,
                KYUREM_BLACK = 147,
                KYUREM_WHITE = 148,
                KELDEO_ORDINARY = 149,
                KELDEO_RESOLUTE = 150,
                MELOETTA_ARIA = 151,
                MELOETTA_PIROUETTE = 152,
                ZUBAT_NORMAL = 157,
                GOLBAT_NORMAL = 160,
                BULBASAUR_NORMAL = 163,
                IVYSAUR_NORMAL = 166,
                VENUSAUR_NORMAL = 169,
                CHARMANDER_NORMAL = 172,
                CHARMELEON_NORMAL = 175,
                CHARIZARD_NORMAL = 178,
                SQUIRTLE_NORMAL = 181,
                WARTORTLE_NORMAL = 184,
                BLASTOISE_NORMAL = 187,
                DRATINI_NORMAL = 190,
                DRAGONAIR_NORMAL = 193,
                DRAGONITE_NORMAL = 196,
                SNORLAX_NORMAL = 199,
                CROBAT_NORMAL = 202,
                MUDKIP_NORMAL = 205,
                MARSHTOMP_NORMAL = 208,
                SWAMPERT_NORMAL = 211,
                DROWZEE_NORMAL = 214,
                HYPNO_NORMAL = 217,
                CUBONE_NORMAL = 224,
                HOUNDOUR_NORMAL = 229,
                HOUNDOOM_NORMAL = 232,
                POLIWAG_NORMAL = 235,
                POLIWHIRL_NORMAL = 238,
                POLIWRATH_NORMAL = 241,
                POLITOED_NORMAL = 244,
                SCYTHER_NORMAL = 247,
                SCIZOR_NORMAL = 250,
                MAGIKARP_NORMAL = 253,
                GYARADOS_NORMAL = 256,
                VENONAT_NORMAL = 259,
                VENOMOTH_NORMAL = 262,
                ODDISH_NORMAL = 265,
                GLOOM_NORMAL = 268,
                VILEPLUME_NORMAL = 271,
                BELLOSSOM_NORMAL = 274,
                HITMONCHAN_NORMAL = 277,
                GROWLITHE_NORMAL = 280,
                ARCANINE_NORMAL = 283,
                PSYDUCK_NORMAL = 286,
                GOLDUCK_NORMAL = 289,
                RALTS_NORMAL = 292,
                KIRLIA_NORMAL = 295,
                GARDEVOIR_NORMAL = 298,
                GALLADE_NORMAL = 301,
                ABRA_NORMAL = 304,
                KADABRA_NORMAL = 307,
                ALAKAZAM_NORMAL = 310,
                LARVITAR_NORMAL = 313,
                PUPITAR_NORMAL = 316,
                TYRANITAR_NORMAL = 319,
                LAPRAS_NORMAL = 322,
                DEERLING_SPRING = 585,
                DEERLING_SUMMER = 586,
                DEERLING_AUTUMN = 587,
                DEERLING_WINTER = 588,
                SAWSBUCK_SPRING = 589,
                SAWSBUCK_SUMMER = 590,
                SAWSBUCK_AUTUMN = 591,
                SAWSBUCK_WINTER = 592,
                GENESECT_NORMAL = 593,
                GENESECT_SHOCK = 594,
                GENESECT_BURN = 595,
                GENESECT_CHILL = 596,
                GENESECT_DOUSE = 597,
                PIKACHU_NORMAL = 598,
                WURMPLE_NORMAL = 600,
                WOBBUFFET_NORMAL = 602,
                CACNEA_NORMAL = 610,
                CACTURNE_NORMAL = 613,
                WEEDLE_NORMAL = 616,
                KAKUNA_NORMAL = 619,
                BEEDRILL_NORMAL = 622,
                SEEDOT_NORMAL = 625,
                NUZLEAF_NORMAL = 628,
                SHIFTRY_NORMAL = 631,
                MAGMAR_NORMAL = 634,
                MAGMORTAR_NORMAL = 637,
                ELECTABUZZ_NORMAL = 640,
                ELECTIVIRE_NORMAL = 643,
                MAREEP_NORMAL = 646,
                FLAAFFY_NORMAL = 649,
                AMPHAROS_NORMAL = 652,
                MAGNEMITE_NORMAL = 655,
                MAGNETON_NORMAL = 658,
                MAGNEZONE_NORMAL = 661,
                BELLSPROUT_NORMAL = 664,
                WEEPINBELL_NORMAL = 667,
                VICTREEBEL_NORMAL = 670,
                PORYGON_NORMAL = 677,
                PORYGON2_NORMAL = 680,
                PORYGON_Z_NORMAL = 683,
                TURTWIG_NORMAL = 688,
                GROTLE_NORMAL = 691,
                TORTERRA_NORMAL = 694,
                EKANS_NORMAL = 697,
                ARBOK_NORMAL = 700,
                KOFFING_NORMAL = 703,
                WEEZING_NORMAL = 706,
                HITMONLEE_NORMAL = 713,
                ARTICUNO_NORMAL = 716,
                MISDREAVUS_NORMAL = 719,
                MISMAGIUS_NORMAL = 722,
                EXEGGCUTE_NORMAL = 729,
                CARVANHA_NORMAL = 734,
                SHARPEDO_NORMAL = 737,
                OMANYTE_NORMAL = 740,
                OMASTAR_NORMAL = 743,
                TRAPINCH_NORMAL = 746,
                VIBRAVA_NORMAL = 749,
                FLYGON_NORMAL = 752,
                BAGON_NORMAL = 755,
                SHELGON_NORMAL = 758,
                SALAMENCE_NORMAL = 761,
                BELDUM_NORMAL = 764,
                METANG_NORMAL = 767,
                METAGROSS_NORMAL = 770,
                ZAPDOS_NORMAL = 773,
                NIDORAN_NORMAL = 776,
                NIDORINA_NORMAL = 779,
                NIDOQUEEN_NORMAL = 782,
                NIDORINO_NORMAL = 785,
                NIDOKING_NORMAL = 788,
                STUNKY_NORMAL = 791,
                SKUNTANK_NORMAL = 794,
                SNEASEL_NORMAL = 797,
                WEAVILE_NORMAL = 800,
                GLIGAR_NORMAL = 803,
                GLISCOR_NORMAL = 806,
                MACHOP_NORMAL = 809,
                MACHOKE_NORMAL = 812,
                MACHAMP_NORMAL = 815,
                CHIMCHAR_NORMAL = 818,
                MONFERNO_NORMAL = 821,
                INFERNAPE_NORMAL = 824,
                SHUCKLE_NORMAL = 827,
                ABSOL_NORMAL = 830,
                MAWILE_NORMAL = 833,
                MOLTRES_NORMAL = 836,
                KANGASKHAN_NORMAL = 839,
                RHYHORN_NORMAL = 846,
                RHYDON_NORMAL = 849,
                RHYPERIOR_NORMAL = 852,
                MURKROW_NORMAL = 855,
                HONCHKROW_NORMAL = 858,
                GIBLE_NORMAL = 861,
                GABITE_NORMAL = 864,
                GARCHOMP_NORMAL = 867,
                KRABBY_NORMAL = 870,
                KINGLER_NORMAL = 873,
                SHELLDER_NORMAL = 876,
                CLOYSTER_NORMAL = 879,
                HIPPOPOTAS_NORMAL = 888,
                HIPPOWDON_NORMAL = 891,
                PIKACHU_FALL_2019 = 894,
                SQUIRTLE_FALL_2019 = 895,
                CHARMANDER_FALL_2019 = 896,
                BULBASAUR_FALL_2019 = 897,
                PINSIR_NORMAL = 898,
                PIKACHU_VS_2019 = 901,
                ONIX_NORMAL = 902,
                STEELIX_NORMAL = 905,
                SHUPPET_NORMAL = 908,
                BANETTE_NORMAL = 911,
                DUSKULL_NORMAL = 914,
                DUSCLOPS_NORMAL = 917,
                DUSKNOIR_NORMAL = 920,
                SABLEYE_NORMAL = 923,
                SNORUNT_NORMAL = 926,
                GLALIE_NORMAL = 929,
                SNOVER_NORMAL = 932,
                ABOMASNOW_NORMAL = 935,
                DELIBIRD_NORMAL = 938,
                STANTLER_NORMAL = 941,
                WEEZING_GALARIAN = 944,
                ZIGZAGOON_NORMAL = 945,
                ZIGZAGOON_GALARIAN = 946,
                LINOONE_NORMAL = 947,
                LINOONE_GALARIAN = 948,
                PIKACHU_COPY_2019 = 949,
                VENUSAUR_COPY_2019 = 950,
                CHARIZARD_COPY_2019 = 951,
                BLASTOISE_COPY_2019 = 952,
                CATERPIE_NORMAL = 953,
                METAPOD_NORMAL = 956,
                BUTTERFREE_NORMAL = 959,
                PIDGEY_NORMAL = 962,
                PIDGEOTTO_NORMAL = 965,
                PIDGEOT_NORMAL = 968,
                SPEAROW_NORMAL = 971,
                FEAROW_NORMAL = 974,
                CLEFAIRY_NORMAL = 981,
                CLEFABLE_NORMAL = 984,
                JIGGLYPUFF_NORMAL = 987,
                WIGGLYTUFF_NORMAL = 990,
                PARAS_NORMAL = 993,
                PARASECT_NORMAL = 996,
                MANKEY_NORMAL = 999,
                PRIMEAPE_NORMAL = 1002,
                TENTACOOL_NORMAL = 1005,
                TENTACRUEL_NORMAL = 1008,
                PONYTA_NORMAL = 1011,
                RAPIDASH_NORMAL = 1014,
                SLOWPOKE_NORMAL = 1017,
                SLOWBRO_NORMAL = 1020,
                FARFETCHD_NORMAL = 1023,
                DODUO_NORMAL = 1026,
                DODRIO_NORMAL = 1029,
                SEEL_NORMAL = 1032,
                DEWGONG_NORMAL = 1035,
                GASTLY_NORMAL = 1038,
                HAUNTER_NORMAL = 1041,
                GENGAR_NORMAL = 1044,
                VOLTORB_NORMAL = 1047,
                ELECTRODE_NORMAL = 1050,
                LICKITUNG_NORMAL = 1053,
                CHANSEY_NORMAL = 1056,
                TANGELA_NORMAL = 1059,
                HORSEA_NORMAL = 1062,
                SEADRA_NORMAL = 1065,
                GOLDEEN_NORMAL = 1068,
                SEAKING_NORMAL = 1071,
                STARYU_NORMAL = 1074,
                STARMIE_NORMAL = 1077,
                MR_MIME_NORMAL = 1080,
                JYNX_NORMAL = 1083,
                TAUROS_NORMAL = 1086,
                DITTO_NORMAL = 1089,
                EEVEE_NORMAL = 1092,
                VAPOREON_NORMAL = 1095,
                JOLTEON_NORMAL = 1098,
                FLAREON_NORMAL = 1101,
                KABUTO_NORMAL = 1104,
                KABUTOPS_NORMAL = 1107,
                AERODACTYL_NORMAL = 1110,
                MEW_NORMAL = 1115,
                CHIKORITA_NORMAL = 1118,
                BAYLEEF_NORMAL = 1121,
                MEGANIUM_NORMAL = 1124,
                CYNDAQUIL_NORMAL = 1127,
                QUILAVA_NORMAL = 1130,
                TYPHLOSION_NORMAL = 1133,
                TOTODILE_NORMAL = 1136,
                CROCONAW_NORMAL = 1139,
                FERALIGATR_NORMAL = 1142,
                SENTRET_NORMAL = 1145,
                FURRET_NORMAL = 1148,
                HOOTHOOT_NORMAL = 1151,
                NOCTOWL_NORMAL = 1154,
                LEDYBA_NORMAL = 1157,
                LEDIAN_NORMAL = 1160,
                SPINARAK_NORMAL = 1163,
                ARIADOS_NORMAL = 1166,
                CHINCHOU_NORMAL = 1169,
                LANTURN_NORMAL = 1172,
                PICHU_NORMAL = 1175,
                CLEFFA_NORMAL = 1178,
                IGGLYBUFF_NORMAL = 1181,
                TOGEPI_NORMAL = 1184,
                TOGETIC_NORMAL = 1187,
                NATU_NORMAL = 1190,
                XATU_NORMAL = 1193,
                MARILL_NORMAL = 1196,
                AZUMARILL_NORMAL = 1199,
                SUDOWOODO_NORMAL = 1202,
                HOPPIP_NORMAL = 1205,
                SKIPLOOM_NORMAL = 1208,
                JUMPLUFF_NORMAL = 1211,
                AIPOM_NORMAL = 1214,
                SUNKERN_NORMAL = 1217,
                SUNFLORA_NORMAL = 1220,
                YANMA_NORMAL = 1223,
                WOOPER_NORMAL = 1226,
                QUAGSIRE_NORMAL = 1229,
                ESPEON_NORMAL = 1232,
                UMBREON_NORMAL = 1235,
                SLOWKING_NORMAL = 1238,
                GIRAFARIG_NORMAL = 1241,
                PINECO_NORMAL = 1244,
                FORRETRESS_NORMAL = 1247,
                DUNSPARCE_NORMAL = 1250,
                SNUBBULL_NORMAL = 1253,
                GRANBULL_NORMAL = 1256,
                QWILFISH_NORMAL = 1259,
                HERACROSS_NORMAL = 1262,
                TEDDIURSA_NORMAL = 1265,
                URSARING_NORMAL = 1268,
                SLUGMA_NORMAL = 1271,
                MAGCARGO_NORMAL = 1274,
                SWINUB_NORMAL = 1277,
                PILOSWINE_NORMAL = 1280,
                CORSOLA_NORMAL = 1283,
                REMORAID_NORMAL = 1286,
                OCTILLERY_NORMAL = 1289,
                MANTINE_NORMAL = 1292,
                SKARMORY_NORMAL = 1295,
                KINGDRA_NORMAL = 1298,
                PHANPY_NORMAL = 1301,
                DONPHAN_NORMAL = 1304,
                SMEARGLE_NORMAL = 1307,
                TYROGUE_NORMAL = 1310,
                HITMONTOP_NORMAL = 1313,
                SMOOCHUM_NORMAL = 1316,
                ELEKID_NORMAL = 1319,
                MAGBY_NORMAL = 1322,
                MILTANK_NORMAL = 1325,
                BLISSEY_NORMAL = 1328,
                RAIKOU_NORMAL = 1331,
                ENTEI_NORMAL = 1334,
                SUICUNE_NORMAL = 1337,
                LUGIA_NORMAL = 1340,
                HO_OH_NORMAL = 1343,
                CELEBI_NORMAL = 1346,
                TREECKO_NORMAL = 1349,
                GROVYLE_NORMAL = 1352,
                SCEPTILE_NORMAL = 1355,
                TORCHIC_NORMAL = 1358,
                COMBUSKEN_NORMAL = 1361,
                BLAZIKEN_NORMAL = 1364,
                POOCHYENA_NORMAL = 1367,
                MIGHTYENA_NORMAL = 1370,
                SILCOON_NORMAL = 1379,
                BEAUTIFLY_NORMAL = 1382,
                CASCOON_NORMAL = 1385,
                DUSTOX_NORMAL = 1388,
                LOTAD_NORMAL = 1391,
                LOMBRE_NORMAL = 1394,
                LUDICOLO_NORMAL = 1397,
                TAILLOW_NORMAL = 1400,
                SWELLOW_NORMAL = 1403,
                WINGULL_NORMAL = 1406,
                PELIPPER_NORMAL = 1409,
                SURSKIT_NORMAL = 1412,
                MASQUERAIN_NORMAL = 1415,
                SHROOMISH_NORMAL = 1418,
                BRELOOM_NORMAL = 1421,
                SLAKOTH_NORMAL = 1424,
                VIGOROTH_NORMAL = 1427,
                SLAKING_NORMAL = 1430,
                NINCADA_NORMAL = 1433,
                NINJASK_NORMAL = 1436,
                SHEDINJA_NORMAL = 1439,
                WHISMUR_NORMAL = 1442,
                LOUDRED_NORMAL = 1445,
                EXPLOUD_NORMAL = 1448,
                MAKUHITA_NORMAL = 1451,
                HARIYAMA_NORMAL = 1454,
                AZURILL_NORMAL = 1457,
                NOSEPASS_NORMAL = 1460,
                SKITTY_NORMAL = 1463,
                DELCATTY_NORMAL = 1466,
                ARON_NORMAL = 1469,
                LAIRON_NORMAL = 1472,
                AGGRON_NORMAL = 1475,
                MEDITITE_NORMAL = 1478,
                MEDICHAM_NORMAL = 1481,
                ELECTRIKE_NORMAL = 1484,
                MANECTRIC_NORMAL = 1487,
                PLUSLE_NORMAL = 1490,
                MINUN_NORMAL = 1493,
                VOLBEAT_NORMAL = 1496,
                ILLUMISE_NORMAL = 1499,
                ROSELIA_NORMAL = 1502,
                GULPIN_NORMAL = 1505,
                SWALOT_NORMAL = 1508,
                WAILMER_NORMAL = 1511,
                WAILORD_NORMAL = 1514,
                NUMEL_NORMAL = 1517,
                CAMERUPT_NORMAL = 1520,
                TORKOAL_NORMAL = 1523,
                SPOINK_NORMAL = 1526,
                GRUMPIG_NORMAL = 1529,
                SWABLU_NORMAL = 1532,
                ALTARIA_NORMAL = 1535,
                ZANGOOSE_NORMAL = 1538,
                SEVIPER_NORMAL = 1541,
                LUNATONE_NORMAL = 1544,
                SOLROCK_NORMAL = 1547,
                BARBOACH_NORMAL = 1550,
                WHISCASH_NORMAL = 1553,
                CORPHISH_NORMAL = 1556,
                CRAWDAUNT_NORMAL = 1559,
                BALTOY_NORMAL = 1562,
                CLAYDOL_NORMAL = 1565,
                LILEEP_NORMAL = 1568,
                CRADILY_NORMAL = 1571,
                ANORITH_NORMAL = 1574,
                ARMALDO_NORMAL = 1577,
                FEEBAS_NORMAL = 1580,
                MILOTIC_NORMAL = 1583,
                KECLEON_NORMAL = 1586,
                TROPIUS_NORMAL = 1589,
                CHIMECHO_NORMAL = 1592,
                WYNAUT_NORMAL = 1595,
                SPHEAL_NORMAL = 1598,
                SEALEO_NORMAL = 1601,
                WALREIN_NORMAL = 1604,
                CLAMPERL_NORMAL = 1607,
                HUNTAIL_NORMAL = 1610,
                GOREBYSS_NORMAL = 1613,
                RELICANTH_NORMAL = 1616,
                LUVDISC_NORMAL = 1619,
                REGIROCK_NORMAL = 1622,
                REGICE_NORMAL = 1625,
                REGISTEEL_NORMAL = 1628,
                LATIAS_NORMAL = 1631,
                LATIOS_NORMAL = 1634,
                KYOGRE_NORMAL = 1637,
                GROUDON_NORMAL = 1640,
                RAYQUAZA_NORMAL = 1643,
                JIRACHI_NORMAL = 1646,
                PIPLUP_NORMAL = 1649,
                PRINPLUP_NORMAL = 1652,
                EMPOLEON_NORMAL = 1655,
                STARLY_NORMAL = 1658,
                STARAVIA_NORMAL = 1661,
                STARAPTOR_NORMAL = 1664,
                BIDOOF_NORMAL = 1667,
                BIBAREL_NORMAL = 1670,
                KRICKETOT_NORMAL = 1673,
                KRICKETUNE_NORMAL = 1676,
                SHINX_NORMAL = 1679,
                LUXIO_NORMAL = 1682,
                LUXRAY_NORMAL = 1685,
                BUDEW_NORMAL = 1688,
                ROSERADE_NORMAL = 1691,
                CRANIDOS_NORMAL = 1694,
                RAMPARDOS_NORMAL = 1697,
                SHIELDON_NORMAL = 1700,
                BASTIODON_NORMAL = 1703,
                BURMY_NORMAL = 1706,
                WORMADAM_NORMAL = 1709,
                MOTHIM_NORMAL = 1712,
                COMBEE_NORMAL = 1715,
                VESPIQUEN_NORMAL = 1718,
                PACHIRISU_NORMAL = 1721,
                BUIZEL_NORMAL = 1724,
                FLOATZEL_NORMAL = 1727,
                CHERUBI_NORMAL = 1730,
                CHERRIM_NORMAL = 1733,
                SHELLOS_NORMAL = 1736,
                GASTRODON_NORMAL = 1739,
                AMBIPOM_NORMAL = 1742,
                DRIFLOON_NORMAL = 1745,
                DRIFBLIM_NORMAL = 1748,
                BUNEARY_NORMAL = 1751,
                LOPUNNY_NORMAL = 1754,
                GLAMEOW_NORMAL = 1757,
                PURUGLY_NORMAL = 1760,
                CHINGLING_NORMAL = 1763,
                BRONZOR_NORMAL = 1766,
                BRONZONG_NORMAL = 1769,
                BONSLY_NORMAL = 1772,
                MIME_JR_NORMAL = 1775,
                HAPPINY_NORMAL = 1778,
                CHATOT_NORMAL = 1781,
                SPIRITOMB_NORMAL = 1784,
                MUNCHLAX_NORMAL = 1787,
                RIOLU_NORMAL = 1790,
                LUCARIO_NORMAL = 1793,
                SKORUPI_NORMAL = 1796,
                DRAPION_NORMAL = 1799,
                CROAGUNK_NORMAL = 1802,
                TOXICROAK_NORMAL = 1805,
                CARNIVINE_NORMAL = 1808,
                FINNEON_NORMAL = 1811,
                LUMINEON_NORMAL = 1814,
                MANTYKE_NORMAL = 1817,
                LICKILICKY_NORMAL = 1820,
                TANGROWTH_NORMAL = 1823,
                TOGEKISS_NORMAL = 1826,
                YANMEGA_NORMAL = 1829,
                LEAFEON_NORMAL = 1832,
                GLACEON_NORMAL = 1835,
                MAMOSWINE_NORMAL = 1838,
                PROBOPASS_NORMAL = 1841,
                FROSLASS_NORMAL = 1844,
                UXIE_NORMAL = 1847,
                MESPRIT_NORMAL = 1850,
                AZELF_NORMAL = 1853,
                DIALGA_NORMAL = 1856,
                PALKIA_NORMAL = 1859,
                HEATRAN_NORMAL = 1862,
                REGIGIGAS_NORMAL = 1865,
                GIRATINA_NORMAL = 1868,
                CRESSELIA_NORMAL = 1871,
                PHIONE_NORMAL = 1874,
                MANAPHY_NORMAL = 1877,
                DARKRAI_NORMAL = 1880,
                SHAYMIN_NORMAL = 1883,
                VICTINI_NORMAL = 1886,
                SNIVY_NORMAL = 1889,
                SERVINE_NORMAL = 1892,
                SERPERIOR_NORMAL = 1895,
                TEPIG_NORMAL = 1898,
                PIGNITE_NORMAL = 1901,
                EMBOAR_NORMAL = 1904,
                OSHAWOTT_NORMAL = 1907,
                DEWOTT_NORMAL = 1910,
                SAMUROTT_NORMAL = 1913,
                PATRAT_NORMAL = 1916,
                WATCHOG_NORMAL = 1919,
                LILLIPUP_NORMAL = 1922,
                HERDIER_NORMAL = 1925,
                STOUTLAND_NORMAL = 1928,
                PURRLOIN_NORMAL = 1931,
                LIEPARD_NORMAL = 1934,
                PANSAGE_NORMAL = 1937,
                SIMISAGE_NORMAL = 1940,
                PANSEAR_NORMAL = 1943,
                SIMISEAR_NORMAL = 1946,
                PANPOUR_NORMAL = 1949,
                SIMIPOUR_NORMAL = 1952,
                MUNNA_NORMAL = 1955,
                MUSHARNA_NORMAL = 1958,
                PIDOVE_NORMAL = 1961,
                TRANQUILL_NORMAL = 1964,
                UNFEZANT_NORMAL = 1967,
                BLITZLE_NORMAL = 1970,
                ZEBSTRIKA_NORMAL = 1973,
                ROGGENROLA_NORMAL = 1976,
                BOLDORE_NORMAL = 1979,
                GIGALITH_NORMAL = 1982,
                WOOBAT_NORMAL = 1985,
                SWOOBAT_NORMAL = 1988,
                DRILBUR_NORMAL = 1991,
                EXCADRILL_NORMAL = 1994,
                AUDINO_NORMAL = 1997,
                TIMBURR_NORMAL = 2000,
                GURDURR_NORMAL = 2003,
                CONKELDURR_NORMAL = 2006,
                TYMPOLE_NORMAL = 2009,
                PALPITOAD_NORMAL = 2012,
                SEISMITOAD_NORMAL = 2015,
                THROH_NORMAL = 2018,
                SAWK_NORMAL = 2021,
                SEWADDLE_NORMAL = 2024,
                SWADLOON_NORMAL = 2027,
                LEAVANNY_NORMAL = 2030,
                VENIPEDE_NORMAL = 2033,
                WHIRLIPEDE_NORMAL = 2036,
                SCOLIPEDE_NORMAL = 2039,
                COTTONEE_NORMAL = 2042,
                WHIMSICOTT_NORMAL = 2045,
                PETILIL_NORMAL = 2048,
                LILLIGANT_NORMAL = 2051,
                SANDILE_NORMAL = 2054,
                KROKOROK_NORMAL = 2057,
                KROOKODILE_NORMAL = 2060,
                DARUMAKA_NORMAL = 2063,
                MARACTUS_NORMAL = 2066,
                DWEBBLE_NORMAL = 2069,
                CRUSTLE_NORMAL = 2072,
                SCRAGGY_NORMAL = 2075,
                SCRAFTY_NORMAL = 2078,
                SIGILYPH_NORMAL = 2081,
                YAMASK_NORMAL = 2084,
                COFAGRIGUS_NORMAL = 2087,
                TIRTOUGA_NORMAL = 2090,
                CARRACOSTA_NORMAL = 2093,
                ARCHEN_NORMAL = 2096,
                ARCHEOPS_NORMAL = 2099,
                TRUBBISH_NORMAL = 2102,
                GARBODOR_NORMAL = 2105,
                ZORUA_NORMAL = 2108,
                ZOROARK_NORMAL = 2111,
                MINCCINO_NORMAL = 2114,
                CINCCINO_NORMAL = 2117,
                GOTHITA_NORMAL = 2120,
                GOTHORITA_NORMAL = 2123,
                GOTHITELLE_NORMAL = 2126,
                SOLOSIS_NORMAL = 2129,
                DUOSION_NORMAL = 2132,
                REUNICLUS_NORMAL = 2135,
                DUCKLETT_NORMAL = 2138,
                SWANNA_NORMAL = 2141,
                VANILLITE_NORMAL = 2144,
                VANILLISH_NORMAL = 2147,
                VANILLUXE_NORMAL = 2150,
                EMOLGA_NORMAL = 2153,
                KARRABLAST_NORMAL = 2156,
                ESCAVALIER_NORMAL = 2159,
                FOONGUS_NORMAL = 2162,
                AMOONGUSS_NORMAL = 2165,
                FRILLISH_NORMAL = 2168,
                JELLICENT_NORMAL = 2171,
                ALOMOMOLA_NORMAL = 2174,
                JOLTIK_NORMAL = 2177,
                GALVANTULA_NORMAL = 2180,
                FERROSEED_NORMAL = 2183,
                FERROTHORN_NORMAL = 2186,
                KLINK_NORMAL = 2189,
                KLANG_NORMAL = 2192,
                KLINKLANG_NORMAL = 2195,
                TYNAMO_NORMAL = 2198,
                EELEKTRIK_NORMAL = 2201,
                EELEKTROSS_NORMAL = 2204,
                ELGYEM_NORMAL = 2207,
                BEHEEYEM_NORMAL = 2210,
                LITWICK_NORMAL = 2213,
                LAMPENT_NORMAL = 2216,
                CHANDELURE_NORMAL = 2219,
                AXEW_NORMAL = 2222,
                FRAXURE_NORMAL = 2225,
                HAXORUS_NORMAL = 2228,
                CUBCHOO_NORMAL = 2231,
                BEARTIC_NORMAL = 2234,
                CRYOGONAL_NORMAL = 2237,
                SHELMET_NORMAL = 2240,
                ACCELGOR_NORMAL = 2243,
                STUNFISK_NORMAL = 2246,
                MIENFOO_NORMAL = 2249,
                MIENSHAO_NORMAL = 2252,
                DRUDDIGON_NORMAL = 2255,
                GOLETT_NORMAL = 2258,
                GOLURK_NORMAL = 2261,
                PAWNIARD_NORMAL = 2264,
                BISHARP_NORMAL = 2267,
                BOUFFALANT_NORMAL = 2270,
                RUFFLET_NORMAL = 2273,
                BRAVIARY_NORMAL = 2276,
                VULLABY_NORMAL = 2279,
                MANDIBUZZ_NORMAL = 2282,
                HEATMOR_NORMAL = 2285,
                DURANT_NORMAL = 2288,
                DEINO_NORMAL = 2291,
                ZWEILOUS_NORMAL = 2294,
                HYDREIGON_NORMAL = 2297,
                LARVESTA_NORMAL = 2300,
                VOLCARONA_NORMAL = 2303,
                COBALION_NORMAL = 2306,
                TERRAKION_NORMAL = 2309,
                VIRIZION_NORMAL = 2312,
                RESHIRAM_NORMAL = 2315,
                ZEKROM_NORMAL = 2318,
                MELTAN_NORMAL = 2321,
                MELMETAL_NORMAL = 2324,
                WURMPLE_SPRING_2020 = 2327,
                WOBBUFFET_SPRING_2020 = 2328,
                RATICATE_SPRING_2020 = 2329,
                FRILLISH_FEMALE = 2330,
                JELLICENT_FEMALE = 2331,
                PIKACHU_COSTUME_2020 = 2332,
                DRAGONITE_COSTUME_2020 = 2333,
                ONIX_COSTUME_2020 = 2334,
                MEOWTH_GALARIAN = 2335,
                PONYTA_GALARIAN = 2336,
                RAPIDASH_GALARIAN = 2337,
                FARFETCHD_GALARIAN = 2338,
                MR_MIME_GALARIAN = 2339,
                CORSOLA_GALARIAN = 2340,
                DARUMAKA_GALARIAN = 2341,
                DARMANITAN_GALARIAN_STANDARD = 2342,
                DARMANITAN_GALARIAN_ZEN = 2343,
                YAMASK_GALARIAN = 2344,
                STUNFISK_GALARIAN = 2345,
                TOXTRICITY_LOW_KEY = 2463,
                TOXTRICITY_AMPED = 2464,
                SINISTEA_PHONY = 2477,
                SINISTEA_ANTIQUE = 2478,
                POLTEAGEIST_PHONY = 2480,
                POLTEAGEIST_ANTIQUE = 2481,
                OBSTAGOON_NORMAL = 2501,
                PERRSERKER_NORMAL = 2504,
                CURSOLA_NORMAL = 2507,
                SIRFETCHD_NORMAL = 2510,
                MR_RIME_NORMAL = 2513,
                RUNERIGUS_NORMAL = 2516,
                EISCUE_ICE = 2540,
                EISCUE_NOICE = 2541,
                INDEEDEE_MALE = 2542,
                INDEEDEE_FEMALE = 2543,
                MORPEKO_FULL_BELLY = 2544,
                MORPEKO_HANGRY = 2545,
                ZACIAN_CROWNED_SWORD = 2576,
                ZACIAN_HERO = 2577,
                ZAMAZENTA_CROWNED_SHIELD = 2578,
                ZAMAZENTA_HERO = 2579,
                ETERNATUS_ETERNAMAX = 2580,
                ETERNATUS_NORMAL = 2581,
                SLOWPOKE_GALARIAN = 2582,
                SLOWBRO_GALARIAN = 2583,
                SLOWKING_GALARIAN = 2584,
                LAPRAS_COSTUME_2020 = 2585,
                GENGAR_COSTUME_2020 = 2586,
                PYROAR_NORMAL = 2587,
                PYROAR_FEMALE = 2588,
                MEOWSTIC_NORMAL = 2589,
                MEOWSTIC_FEMALE = 2590,
                ZYGARDE_TEN_PERCENT = 2591,
                ZYGARDE_FIFTY_PERCENT = 2592,
                ZYGARDE_COMPLETE = 2593,
                VIVILLON_ARCHIPELAGO = 2594,
                VIVILLON_CONTINENTAL = 2595,
                VIVILLON_ELEGANT = 2596,
                VIVILLON_FANCY = 2597,
                VIVILLON_GARDEN = 2598,
                VIVILLON_HIGH_PLAINS = 2599,
                VIVILLON_ICY_SNOW = 2600,
                VIVILLON_JUNGLE = 2601,
                VIVILLON_MARINE = 2602,
                VIVILLON_MEADOW = 2603,
                VIVILLON_MODERN = 2604,
                VIVILLON_MONSOON = 2605,
                VIVILLON_OCEAN = 2606,
                VIVILLON_POKEBALL = 2607,
                VIVILLON_POLAR = 2608,
                VIVILLON_RIVER = 2609,
                VIVILLON_SANDSTORM = 2610,
                VIVILLON_SAVANNA = 2611,
                VIVILLON_SUN = 2612,
                VIVILLON_TUNDRA = 2613,
                FLABEBE_RED = 2614,
                FLABEBE_YELLOW = 2615,
                FLABEBE_ORANGE = 2616,
                FLABEBE_BLUE = 2617,
                FLABEBE_WHITE = 2618,
                FLOETTE_RED = 2619,
                FLOETTE_YELLOW = 2620,
                FLOETTE_ORANGE = 2621,
                FLOETTE_BLUE = 2622,
                FLOETTE_WHITE = 2623,
                FLORGES_RED = 2624,
                FLORGES_YELLOW = 2625,
                FLORGES_ORANGE = 2626,
                FLORGES_BLUE = 2627,
                FLORGES_WHITE = 2628,
                FURFROU_NATURAL = 2629,
                FURFROU_HEART = 2630,
                FURFROU_STAR = 2631,
                FURFROU_DIAMOND = 2632,
                FURFROU_DEBUTANTE = 2633,
                FURFROU_MATRON = 2634,
                FURFROU_DANDY = 2635,
                FURFROU_LA_REINE = 2636,
                FURFROU_KABUKI = 2637,
                FURFROU_PHARAOH = 2638,
                AEGISLASH_SHIELD = 2639,
                AEGISLASH_BLADE = 2640,
                PUMPKABOO_SMALL = 2641,
                PUMPKABOO_AVERAGE = 2642,
                PUMPKABOO_LARGE = 2643,
                PUMPKABOO_SUPER = 2644,
                GOURGEIST_SMALL = 2645,
                GOURGEIST_AVERAGE = 2646,
                GOURGEIST_LARGE = 2647,
                GOURGEIST_SUPER = 2648,
                XERNEAS_NEUTRAL = 2649,
                XERNEAS_ACTIVE = 2650,
                HOOPA_CONFINED = 2651,
                HOOPA_UNBOUND = 2652,
                SABLEYE_COSTUME_2020_DEPRECATED = 2666,
                SABLEYE_COSTUME_2020 = 2668,
                PIKACHU_ADVENTURE_HAT_2020 = 2669,
                PIKACHU_WINTER_2020 = 2670,
                DELIBIRD_WINTER_2020 = 2671,
                CUBCHOO_WINTER_2020 = 2672,
                SLOWPOKE_2020 = 2673,
                SLOWBRO_2021 = 2674,
                PIKACHU_KARIYUSHI = 2675,
                PIKACHU_POP_STAR = 2676,
                PIKACHU_ROCK_STAR = 2677,
                PIKACHU_FLYING_5TH_ANNIV = 2678,
                ORICORIO_BAILE = 2679,
                ORICORIO_POMPOM = 2680,
                ORICORIO_PAU = 2681,
                ORICORIO_SENSU = 2683,
                LYCANROC_MIDDAY = 2684,
                LYCANROC_MIDNIGHT = 2685,
                LYCANROC_DUSK = 2686,
                WISHIWASHI_SOLO = 2687,
                WISHIWASHI_SCHOOL = 2688,
                SILVALLY_NORMAL = 2689,
                SILVALLY_BUG = 2690,
                SILVALLY_DARK = 2691,
                SILVALLY_DRAGON = 2692,
                SILVALLY_ELECTRIC = 2693,
                SILVALLY_FAIRY = 2694,
                SILVALLY_FIGHTING = 2695,
                SILVALLY_FIRE = 2696,
                SILVALLY_FLYING = 2697,
                SILVALLY_GHOST = 2698,
                SILVALLY_GRASS = 2699,
                SILVALLY_GROUND = 2700,
                SILVALLY_ICE = 2701,
                SILVALLY_POISON = 2702,
                SILVALLY_PSYCHIC = 2703,
                SILVALLY_ROCK = 2704,
                SILVALLY_STEEL = 2705,
                SILVALLY_WATER = 2706,
                MINIOR_METEOR_BLUE = 2707,
                MINIOR_BLUE = 2708,
                MINIOR_GREEN = 2709,
                MINIOR_INDIGO = 2710,
                MINIOR_ORANGE = 2711,
                MINIOR_RED = 2712,
                MINIOR_VIOLET = 2713,
                MINIOR_YELLOW = 2714,
                MIMIKYU_BUSTED = 2715,
                MIMIKYU_DISGUISED = 2716,
                NECROZMA_NORMAL = 2717,
                NECROZMA_DUSK_MANE = 2718,
                NECROZMA_DAWN_WINGS = 2719,
                NECROZMA_ULTRA = 2720,
                MAGEARNA_NORMAL = 2721,
                MAGEARNA_ORIGINAL_COLOR = 2722,
                URSHIFU_SINGLE_STRIKE = 2723,
                URSHIFU_RAPID_STRIKE = 2724,
                CALYREX_NORMAL = 2725,
                CALYREX_ICE_RIDER = 2726,
                CALYREX_SHADOW_RIDER = 2727,
                VOLTORB_HISUIAN = 2728,
                LUGIA_S = 2729,
                HO_OH_S = 2730,
                RAIKOU_S = 2731,
                ENTEI_S = 2732,
                SUICUNE_S = 2733,
                SLOWKING_2022 = 2734,
                ELECTRODE_HISUIAN = 2735,
                PIKACHU_FLYING_OKINAWA = 2736,
                ROCKRUFF_DUSK = 2737,
                MINIOR_METEOR_GREEN = 2739,
                MINIOR_METEOR_INDIGO = 2740,
                MINIOR_METEOR_ORANGE = 2741,
                MINIOR_METEOR_RED = 2742,
                MINIOR_METEOR_VIOLET = 2743,
                MINIOR_METEOR_YELLOW = 2744,
                SCATTERBUG_ARCHIPELAGO = 2745,
                SCATTERBUG_CONTINENTAL = 2746,
                SCATTERBUG_ELEGANT = 2747,
                SCATTERBUG_FANCY = 2748,
                SCATTERBUG_GARDEN = 2749,
                SCATTERBUG_HIGH_PLAINS = 2750,
                SCATTERBUG_ICY_SNOW = 2751,
                SCATTERBUG_JUNGLE = 2752,
                SCATTERBUG_MARINE = 2753,
                SCATTERBUG_MEADOW = 2754,
                SCATTERBUG_MODERN = 2755,
                SCATTERBUG_MONSOON = 2756,
                SCATTERBUG_OCEAN = 2757,
                SCATTERBUG_POKEBALL = 2758,
                SCATTERBUG_POLAR = 2759,
                SCATTERBUG_RIVER = 2760,
                SCATTERBUG_SANDSTORM = 2761,
                SCATTERBUG_SAVANNA = 2762,
                SCATTERBUG_SUN = 2763,
                SCATTERBUG_TUNDRA = 2764,
                SPEWPA_ARCHIPELAGO = 2765,
                SPEWPA_CONTINENTAL = 2766,
                SPEWPA_ELEGANT = 2767,
                SPEWPA_FANCY = 2768,
                SPEWPA_GARDEN = 2769,
                SPEWPA_HIGH_PLAINS = 2770,
                SPEWPA_ICY_SNOW = 2771,
                SPEWPA_JUNGLE = 2772,
                SPEWPA_MARINE = 2773,
                SPEWPA_MEADOW = 2774,
                SPEWPA_MODERN = 2775,
                SPEWPA_MONSOON = 2776,
                SPEWPA_OCEAN = 2777,
                SPEWPA_POKEBALL = 2778,
                SPEWPA_POLAR = 2779,
                SPEWPA_RIVER = 2780,
                SPEWPA_SANDSTORM = 2781,
                SPEWPA_SAVANNA = 2782,
                SPEWPA_SUN = 2783,
                SPEWPA_TUNDRA = 2784,
                DECIDUEYE_HISUIAN = 2785,
                TYPHLOSION_HISUIAN = 2786,
                SAMUROTT_HISUIAN = 2787,
                QWILFISH_HISUIAN = 2788,
                LILLIGANT_HISUIAN = 2789,
                SLIGGOO_HISUIAN = 2790,
                GOODRA_HISUIAN = 2791,
                GROWLITHE_HISUIAN = 2792,
                ARCANINE_HISUIAN = 2793,
                SNEASEL_HISUIAN = 2794,
                AVALUGG_HISUIAN = 2795,
                ZORUA_HISUIAN = 2796,
                ZOROARK_HISUIAN = 2797,
                BRAVIARY_HISUIAN = 2798,
                MOLTRES_GALARIAN = 2799,
                ZAPDOS_GALARIAN = 2800,
                ARTICUNO_GALARIAN = 2801,
                ENAMORUS_INCARNATE = 2802,
                ENAMORUS_THERIAN = 2803,
                BASCULIN_WHITE_STRIPED = 2804,
                PIKACHU_GOFEST_2022 = 2805,
                PIKACHU_WCS_2022 = 2806,
                BASCULEGION_NORMAL = 2807,
                BASCULEGION_FEMALE = 2808,
                DECIDUEYE_NORMAL = 2809,
                SLIGGOO_NORMAL = 2810,
                GOODRA_NORMAL = 2811,
                AVALUGG_NORMAL = 2812,
                PIKACHU_TSHIRT_01 = 2813,
                PIKACHU_TSHIRT_02 = 2814,
                PIKACHU_FLYING_01 = 2815,
                PIKACHU_FLYING_02 = 2816,
                URSALUNA_NORMAL = 2817,
                BEARTIC_WINTER_2020 = 2820,
                LATIAS_S = 2821,
                LATIOS_S = 2822,
                ZYGARDE_COMPLETE_TEN_PERCENT = 2823,
                ZYGARDE_COMPLETE_FIFTY_PERCENT = 2824,
                PIKACHU_GOTOUR_2024_A = 2825,
                PIKACHU_GOTOUR_2024_B = 2826,
                PIKACHU_GOTOUR_2024_A_02 = 2827,
                PIKACHU_GOTOUR_2024_B_02 = 2828,
                DIALGA_ORIGIN = 2829,
                PALKIA_ORIGIN = 2830,
                ROCKRUFF_NORMAL = 2831,
                PIKACHU_TSHIRT_03 = 2832,
                PIKACHU_FLYING_04 = 2833,
                PIKACHU_TSHIRT_04 = 2834,
                PIKACHU_TSHIRT_05 = 2835,
                PIKACHU_TSHIRT_06 = 2836,
                PIKACHU_TSHIRT_07 = 2837,
                PIKACHU_FLYING_05 = 2838,
                PIKACHU_FLYING_06 = 2839,
                PIKACHU_FLYING_07 = 2840,
                PIKACHU_FLYING_08 = 2841,
                PIKACHU_HORIZONS = 2842,
                PIKACHU_GOFEST_2024_STIARA = 2843,
                PIKACHU_GOFEST_2024_MTIARA = 2844,
                EEVEE_GOFEST_2024_STIARA = 2845,
                EEVEE_GOFEST_2024_MTIARA = 2846,
                ESPEON_GOFEST_2024_SSCARF = 2847,
                UMBREON_GOFEST_2024_MSCARF = 2848,
                SNORLAX_WILDAREA_2024 = 2849,
                PIKACHU_DIWALI_2024 = 2850,
                PIKACHU_GOTOUR_2025_A = 2856,
                PIKACHU_GOTOUR_2025_B = 2857,
                PIKACHU_GOTOUR_2025_A_02 = 2858,
                PIKACHU_GOTOUR_2025_B_02 = 2859,
                PIKACHU_KURTA = 2863,
                OINKOLOGNE_NORMAL = 2981,
                OINKOLOGNE_FEMALE = 2982,
                MAUSHOLD_FAMILY_OF_THREE = 2983,
                MAUSHOLD_FAMILY_OF_FOUR = 2984,
                SQUAWKABILLY_GREEN = 2985,
                SQUAWKABILLY_BLUE = 2986,
                SQUAWKABILLY_YELLOW = 2987,
                SQUAWKABILLY_WHITE = 2988,
                PALAFIN_ZERO = 2989,
                PALAFIN_HERO = 2990,
                TATSUGIRI_CURLY = 2991,
                TATSUGIRI_DROOPY = 2992,
                TATSUGIRI_STRETCHY = 2993,
                DUDUNSPARCE_TWO = 2994,
                DUDUNSPARCE_THREE = 2995,
                KORAIDON_APEX = 2996,
                MIRAIDON_ULTIMATE = 2997,
                GIMMIGHOUL_NORMAL = 2998,
                GHOLDENGO_NORMAL = 3000,
                AERODACTYL_SUMMER_2023 = 3001,
                PIKACHU_SUMMER_2023_A = 3002,
                PIKACHU_SUMMER_2023_B = 3003,
                PIKACHU_SUMMER_2023_C = 3004,
                PIKACHU_SUMMER_2023_D = 3005,
                TAUROS_PALDEA_COMBAT = 3006,
                TAUROS_PALDEA_BLAZE = 3007,
                TAUROS_PALDEA_AQUA = 3008,
                WOOPER_PALDEA = 3009,
                PIKACHU_SUMMER_2023_E = 3010,
                PIKACHU_FLYING_03 = 3011,
                PIKACHU_JEJU = 3012,
                PIKACHU_DOCTOR = 3013,
                PIKACHU_WCS_2023 = 3014,
                PIKACHU_WCS_2024 = 3015
            }
        }

        interface IPokemonEggRewardDistributionEntryProto {
            pokemon?: (POGOProtos.Rpc.IPokemonEggRewardEntryProto|null);
            weight?: (number|null);
        }

        class PokemonEggRewardDistributionEntryProto implements IPokemonEggRewardDistributionEntryProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEggRewardDistributionEntryProto);
            public pokemon?: (POGOProtos.Rpc.IPokemonEggRewardEntryProto|null);
            public weight: number;
            public static encode(message: POGOProtos.Rpc.IPokemonEggRewardDistributionEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEggRewardDistributionEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEggRewardDistributionEntryProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEggRewardDistributionEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonEggRewardDistributionProto {
            entries?: (POGOProtos.Rpc.IPokemonEggRewardDistributionEntryProto[]|null);
        }

        class PokemonEggRewardDistributionProto implements IPokemonEggRewardDistributionProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEggRewardDistributionProto);
            public entries: POGOProtos.Rpc.IPokemonEggRewardDistributionEntryProto[];
            public static encode(message: POGOProtos.Rpc.IPokemonEggRewardDistributionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEggRewardDistributionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEggRewardDistributionProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEggRewardDistributionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonEggRewardEntryProto {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            aligmnent?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment|null);
            hatch_dist_km?: (number|null);
        }

        class PokemonEggRewardEntryProto implements IPokemonEggRewardEntryProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEggRewardEntryProto);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public aligmnent: POGOProtos.Rpc.PokemonDisplayProto.Alignment;
            public hatch_dist_km: number;
            public static encode(message: POGOProtos.Rpc.IPokemonEggRewardEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEggRewardEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEggRewardEntryProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEggRewardEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonEggRewardProto {
            distribution?: (POGOProtos.Rpc.IPokemonEggRewardDistributionProto|null);
            egg_slot_type?: (POGOProtos.Rpc.EggSlotType|null);
            hatch_dist_km?: (number|null);
        }

        class PokemonEggRewardProto implements IPokemonEggRewardProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEggRewardProto);
            public distribution?: (POGOProtos.Rpc.IPokemonEggRewardDistributionProto|null);
            public egg_slot_type: POGOProtos.Rpc.EggSlotType;
            public hatch_dist_km: number;
            public pokemon?: "distribution";
            public static encode(message: POGOProtos.Rpc.IPokemonEggRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEggRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEggRewardProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEggRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonEncounterAttributesProto {
            base_capture_rate?: (number|null);
            base_flee_rate?: (number|null);
            collision_radius_m?: (number|null);
            collision_height_m?: (number|null);
            collision_head_radius_m?: (number|null);
            movement_type?: (POGOProtos.Rpc.HoloPokemonMovementType|null);
            movement_timer_s?: (number|null);
            jump_time_s?: (number|null);
            attack_timer_s?: (number|null);
            bonus_candy_capture_reward?: (number|null);
            bonus_stardust_capture_reward?: (number|null);
            attack_probability?: (number|null);
            dodge_probability?: (number|null);
            dodge_duration_s?: (number|null);
            dodge_distance?: (number|null);
            camera_distance?: (number|null);
            min_pokemon_action_frequency_s?: (number|null);
            max_pokemon_action_frequency_s?: (number|null);
            bonus_xl_candy_capture_reward?: (number|null);
            shadow_base_capture_rate?: (number|null);
            shadow_attack_probability?: (number|null);
            shadow_dodge_probability?: (number|null);
            catch_radius_multiplier?: (number|null);
        }

        class PokemonEncounterAttributesProto implements IPokemonEncounterAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEncounterAttributesProto);
            public base_capture_rate: number;
            public base_flee_rate: number;
            public collision_radius_m: number;
            public collision_height_m: number;
            public collision_head_radius_m: number;
            public movement_type: POGOProtos.Rpc.HoloPokemonMovementType;
            public movement_timer_s: number;
            public jump_time_s: number;
            public attack_timer_s: number;
            public bonus_candy_capture_reward: number;
            public bonus_stardust_capture_reward: number;
            public attack_probability: number;
            public dodge_probability: number;
            public dodge_duration_s: number;
            public dodge_distance: number;
            public camera_distance: number;
            public min_pokemon_action_frequency_s: number;
            public max_pokemon_action_frequency_s: number;
            public bonus_xl_candy_capture_reward: number;
            public shadow_base_capture_rate: number;
            public shadow_attack_probability: number;
            public shadow_dodge_probability: number;
            public catch_radius_multiplier: number;
            public static encode(message: POGOProtos.Rpc.IPokemonEncounterAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEncounterAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEncounterAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEncounterAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonEncounterRewardProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            use_quest_pokemon_encounter_distribuition?: (boolean|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            is_hidden_ditto?: (boolean|null);
            ditto_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            poke_ball_override?: (POGOProtos.Rpc.Item|null);
            shiny_probability?: (number|null);
            size_override?: (POGOProtos.Rpc.HoloPokemonSize|null);
            stats_limits_override?: (POGOProtos.Rpc.IPokemonStatsLimitsProto|null);
            quest_encounter_type?: (POGOProtos.Rpc.QuestEncounterType|null);
            is_featured_pokemon?: (boolean|null);
        }

        class PokemonEncounterRewardProto implements IPokemonEncounterRewardProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEncounterRewardProto);
            public pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            public use_quest_pokemon_encounter_distribuition?: (boolean|null);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public is_hidden_ditto: boolean;
            public ditto_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public poke_ball_override: POGOProtos.Rpc.Item;
            public shiny_probability: number;
            public size_override: POGOProtos.Rpc.HoloPokemonSize;
            public stats_limits_override?: (POGOProtos.Rpc.IPokemonStatsLimitsProto|null);
            public quest_encounter_type: POGOProtos.Rpc.QuestEncounterType;
            public is_featured_pokemon: boolean;
            public Type?: ("pokemon_id"|"use_quest_pokemon_encounter_distribuition");
            public static encode(message: POGOProtos.Rpc.IPokemonEncounterRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEncounterRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEncounterRewardProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEncounterRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonEvolutionQuestProto {
            quest_requirement?: (POGOProtos.Rpc.IQuestProto|null);
            quest_info?: (POGOProtos.Rpc.IEvolutionQuestInfoProto|null);
            evolution?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class PokemonEvolutionQuestProto implements IPokemonEvolutionQuestProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonEvolutionQuestProto);
            public quest_requirement?: (POGOProtos.Rpc.IQuestProto|null);
            public quest_info?: (POGOProtos.Rpc.IEvolutionQuestInfoProto|null);
            public evolution: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IPokemonEvolutionQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonEvolutionQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonEvolutionQuestProto;
            public static toObject(message: POGOProtos.Rpc.PokemonEvolutionQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonExchangeEntryProto {
        }

        class PokemonExchangeEntryProto implements IPokemonExchangeEntryProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonExchangeEntryProto);
            public static encode(message: POGOProtos.Rpc.IPokemonExchangeEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonExchangeEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonExchangeEntryProto;
            public static toObject(message: POGOProtos.Rpc.PokemonExchangeEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonExpressionUpdateProto {
            unique_pokemon_ids?: ((number|Long)[]|null);
            pokemon_expression?: (POGOProtos.Rpc.IrisSocialPokemonExpression|null);
            expression_start_time_ms?: (number|Long|null);
            fx_offset?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition|null);
        }

        class PokemonExpressionUpdateProto implements IPokemonExpressionUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonExpressionUpdateProto);
            public unique_pokemon_ids: (number|Long)[];
            public pokemon_expression: POGOProtos.Rpc.IrisSocialPokemonExpression;
            public expression_start_time_ms: (number|Long);
            public fx_offset?: (POGOProtos.Rpc.IrisSocialEventTelemetry.IPosition|null);
            public static encode(message: POGOProtos.Rpc.IPokemonExpressionUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonExpressionUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonExpressionUpdateProto;
            public static toObject(message: POGOProtos.Rpc.PokemonExpressionUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonExtendedSettingsProto {
            unique_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            temp_evo_overrides?: (POGOProtos.Rpc.ITempEvoOverrideExtendedProto[]|null);
            size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            bread_overrides?: (POGOProtos.Rpc.IBreadOverrideExtendedProto[]|null);
        }

        class PokemonExtendedSettingsProto implements IPokemonExtendedSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonExtendedSettingsProto);
            public unique_id: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public temp_evo_overrides: POGOProtos.Rpc.ITempEvoOverrideExtendedProto[];
            public size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            public bread_overrides: POGOProtos.Rpc.IBreadOverrideExtendedProto[];
            public static encode(message: POGOProtos.Rpc.IPokemonExtendedSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonExtendedSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonExtendedSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonExtendedSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonFamilyProto {
            family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            candy?: (number|null);
            mega_evolution_resources?: (POGOProtos.Rpc.ITemporaryEvolutionResourceProto[]|null);
            xl_candy?: (number|null);
        }

        class PokemonFamilyProto implements IPokemonFamilyProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonFamilyProto);
            public family_id: POGOProtos.Rpc.HoloPokemonFamilyId;
            public candy: number;
            public mega_evolution_resources: POGOProtos.Rpc.ITemporaryEvolutionResourceProto[];
            public xl_candy: number;
            public static encode(message: POGOProtos.Rpc.IPokemonFamilyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonFamilyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonFamilyProto;
            public static toObject(message: POGOProtos.Rpc.PokemonFamilyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonFamilySettingsProto {
            family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            candy_per_xl_candy?: (number|null);
            mega_evolvable_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            mega_evolvable_pokemon_ids?: (POGOProtos.Rpc.HoloPokemonId[]|null);
        }

        class PokemonFamilySettingsProto implements IPokemonFamilySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonFamilySettingsProto);
            public family_id: POGOProtos.Rpc.HoloPokemonFamilyId;
            public candy_per_xl_candy: number;
            public mega_evolvable_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public mega_evolvable_pokemon_ids: POGOProtos.Rpc.HoloPokemonId[];
            public static encode(message: POGOProtos.Rpc.IPokemonFamilySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonFamilySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonFamilySettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonFamilySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonFortProto {
            fort_id?: (string|null);
            last_modified_ms?: (number|Long|null);
            latitude?: (number|null);
            longitude?: (number|null);
            team?: (POGOProtos.Rpc.Team|null);
            guard_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            guard_pokemon_level?: (number|null);
            enabled?: (boolean|null);
            fort_type?: (POGOProtos.Rpc.FortType|null);
            gym_points?: (number|Long|null);
            is_in_battle?: (boolean|null);
            active_fort_modifier?: (POGOProtos.Rpc.Item[]|null);
            active_pokemon?: (POGOProtos.Rpc.IMapPokemonProto|null);
            cooldown_complete_ms?: (number|Long|null);
            sponsor?: (POGOProtos.Rpc.FortSponsor.Sponsor|null);
            rendering_type?: (POGOProtos.Rpc.FortRenderingType.RenderingType|null);
            deploy_lockout_end_ms?: (number|Long|null);
            guard_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            closed?: (boolean|null);
            raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            gym_display?: (POGOProtos.Rpc.IGymDisplayProto|null);
            visited?: (boolean|null);
            same_team_deploy_lockout_end_ms?: (number|Long|null);
            allow_checkin?: (boolean|null);
            image_url?: (string|null);
            in_event?: (boolean|null);
            banner_url?: (string|null);
            partner_id?: (string|null);
            challenge_quest_completed?: (boolean|null);
            is_ex_raid_eligible?: (boolean|null);
            pokestop_display?: (POGOProtos.Rpc.IPokestopIncidentDisplayProto|null);
            pokestop_displays?: (POGOProtos.Rpc.IPokestopIncidentDisplayProto[]|null);
            is_ar_scan_eligible?: (boolean|null);
            geostore_tombstone_message_key?: (string|null);
            geostore_suspension_message_key?: (string|null);
            power_up_progress_points?: (number|null);
            power_up_level_expiration_ms?: (number|Long|null);
            next_fort_open_ms?: (number|Long|null);
            next_fort_close_ms?: (number|Long|null);
            active_fort_pokemon?: (POGOProtos.Rpc.IFortPokemonProto[]|null);
            is_route_eligible?: (boolean|null);
            fort_vps_info?: (POGOProtos.Rpc.IFortVpsInfoProto|null);
            ar_experiences_allowed?: (boolean|null);
            stamp_collection_ids?: (string[]|null);
            tappable?: (POGOProtos.Rpc.ITappable|null);
        }

        class PokemonFortProto implements IPokemonFortProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonFortProto);
            public fort_id: string;
            public last_modified_ms: (number|Long);
            public latitude: number;
            public longitude: number;
            public team: POGOProtos.Rpc.Team;
            public guard_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public guard_pokemon_level: number;
            public enabled: boolean;
            public fort_type: POGOProtos.Rpc.FortType;
            public gym_points: (number|Long);
            public is_in_battle: boolean;
            public active_fort_modifier: POGOProtos.Rpc.Item[];
            public active_pokemon?: (POGOProtos.Rpc.IMapPokemonProto|null);
            public cooldown_complete_ms: (number|Long);
            public sponsor: POGOProtos.Rpc.FortSponsor.Sponsor;
            public rendering_type: POGOProtos.Rpc.FortRenderingType.RenderingType;
            public deploy_lockout_end_ms: (number|Long);
            public guard_pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public closed: boolean;
            public raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            public gym_display?: (POGOProtos.Rpc.IGymDisplayProto|null);
            public visited: boolean;
            public same_team_deploy_lockout_end_ms: (number|Long);
            public allow_checkin: boolean;
            public image_url: string;
            public in_event: boolean;
            public banner_url: string;
            public partner_id: string;
            public challenge_quest_completed: boolean;
            public is_ex_raid_eligible: boolean;
            public pokestop_display?: (POGOProtos.Rpc.IPokestopIncidentDisplayProto|null);
            public pokestop_displays: POGOProtos.Rpc.IPokestopIncidentDisplayProto[];
            public is_ar_scan_eligible: boolean;
            public geostore_tombstone_message_key: string;
            public geostore_suspension_message_key: string;
            public power_up_progress_points: number;
            public power_up_level_expiration_ms: (number|Long);
            public next_fort_open_ms: (number|Long);
            public next_fort_close_ms: (number|Long);
            public active_fort_pokemon: POGOProtos.Rpc.IFortPokemonProto[];
            public is_route_eligible: boolean;
            public fort_vps_info?: (POGOProtos.Rpc.IFortVpsInfoProto|null);
            public ar_experiences_allowed: boolean;
            public stamp_collection_ids: string[];
            public tappable?: (POGOProtos.Rpc.ITappable|null);
            public static encode(message: POGOProtos.Rpc.IPokemonFortProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonFortProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonFortProto;
            public static toObject(message: POGOProtos.Rpc.PokemonFortProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonFxSettingsProto {
            pokemon_glow_feature_active?: (boolean|null);
            glow_during_day?: (boolean|null);
            glow_during_night?: (boolean|null);
            glow_on_map?: (boolean|null);
            glow_in_encounter?: (boolean|null);
            glow_in_battle?: (boolean|null);
            glow_in_combat?: (boolean|null);
            glow_fx_pokemon?: (POGOProtos.Rpc.IGlowFxPokemonProto[]|null);
            hiding_in_map?: (boolean|null);
            hiding_in_photo?: (boolean|null);
            hiding_in_encounter?: (boolean|null);
        }

        class PokemonFxSettingsProto implements IPokemonFxSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonFxSettingsProto);
            public pokemon_glow_feature_active: boolean;
            public glow_during_day: boolean;
            public glow_during_night: boolean;
            public glow_on_map: boolean;
            public glow_in_encounter: boolean;
            public glow_in_battle: boolean;
            public glow_in_combat: boolean;
            public glow_fx_pokemon: POGOProtos.Rpc.IGlowFxPokemonProto[];
            public hiding_in_map: boolean;
            public hiding_in_photo: boolean;
            public hiding_in_encounter: boolean;
            public static encode(message: POGOProtos.Rpc.IPokemonFxSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonFxSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonFxSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonFxSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonGlobalSettingsProto {
            enable_camo_shader?: (boolean|null);
            display_pokemon_badge_on_model?: (boolean|null);
        }

        class PokemonGlobalSettingsProto implements IPokemonGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonGlobalSettingsProto);
            public enable_camo_shader: boolean;
            public display_pokemon_badge_on_model: boolean;
            public static encode(message: POGOProtos.Rpc.IPokemonGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonGoPlusTelemetry {
            pgp_event_ids?: (POGOProtos.Rpc.PokemonGoPlusIds|null);
            count?: (number|null);
            version?: (number|null);
            device_kind?: (string|null);
            connection_state?: (string|null);
        }

        class PokemonGoPlusTelemetry implements IPokemonGoPlusTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokemonGoPlusTelemetry);
            public pgp_event_ids: POGOProtos.Rpc.PokemonGoPlusIds;
            public count: number;
            public version: number;
            public device_kind: string;
            public connection_state: string;
            public static encode(message: POGOProtos.Rpc.IPokemonGoPlusTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonGoPlusTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonGoPlusTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokemonGoPlusTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonHomeEnergyCostsProto {
            pokemon_class?: (POGOProtos.Rpc.HoloPokemonClass|null);
            base?: (number|null);
            shiny?: (number|null);
            cp0_to1000?: (number|null);
            cp1001_to2000?: (number|null);
            cp2001_to_inf?: (number|null);
        }

        class PokemonHomeEnergyCostsProto implements IPokemonHomeEnergyCostsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonHomeEnergyCostsProto);
            public pokemon_class: POGOProtos.Rpc.HoloPokemonClass;
            public base: number;
            public shiny: number;
            public cp0_to1000: number;
            public cp1001_to2000: number;
            public cp2001_to_inf: number;
            public static encode(message: POGOProtos.Rpc.IPokemonHomeEnergyCostsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonHomeEnergyCostsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonHomeEnergyCostsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonHomeEnergyCostsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonHomeFormReversionProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form_mapping?: (POGOProtos.Rpc.PokemonHomeFormReversionProto.IFormMappingProto[]|null);
        }

        class PokemonHomeFormReversionProto implements IPokemonHomeFormReversionProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonHomeFormReversionProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public form_mapping: POGOProtos.Rpc.PokemonHomeFormReversionProto.IFormMappingProto[];
            public static encode(message: POGOProtos.Rpc.IPokemonHomeFormReversionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonHomeFormReversionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonHomeFormReversionProto;
            public static toObject(message: POGOProtos.Rpc.PokemonHomeFormReversionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonHomeFormReversionProto {

            interface IFormMappingProto {
                reverted_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
                unauthorized_forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
                reverted_form_string?: (string|null);
            }

            class FormMappingProto implements IFormMappingProto {
                constructor(properties?: POGOProtos.Rpc.PokemonHomeFormReversionProto.IFormMappingProto);
                public reverted_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
                public unauthorized_forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
                public reverted_form_string: string;
                public static encode(message: POGOProtos.Rpc.PokemonHomeFormReversionProto.IFormMappingProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonHomeFormReversionProto.FormMappingProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonHomeFormReversionProto.FormMappingProto;
                public static toObject(message: POGOProtos.Rpc.PokemonHomeFormReversionProto.FormMappingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPokemonHomeProto {
            transporter_energy?: (number|null);
            transporter_fully_charged_ms?: (number|Long|null);
            last_passive_transporter_energy_gain_hour?: (number|Long|null);
        }

        class PokemonHomeProto implements IPokemonHomeProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonHomeProto);
            public transporter_energy: number;
            public transporter_fully_charged_ms: (number|Long);
            public last_passive_transporter_energy_gain_hour: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPokemonHomeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonHomeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonHomeProto;
            public static toObject(message: POGOProtos.Rpc.PokemonHomeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonHomeSettingsProto {
            player_min_level?: (number|null);
            transporter_max_energy?: (number|null);
            energy_sku_id?: (string|null);
            transporter_energy_gain_per_hour?: (number|null);
        }

        class PokemonHomeSettingsProto implements IPokemonHomeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonHomeSettingsProto);
            public player_min_level: number;
            public transporter_max_energy: number;
            public energy_sku_id: string;
            public transporter_energy_gain_per_hour: number;
            public static encode(message: POGOProtos.Rpc.IPokemonHomeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonHomeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonHomeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonHomeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonHomeTelemetry {
            pokemon_home_click_ids?: (POGOProtos.Rpc.PokemonHomeTelemetryIds|null);
        }

        class PokemonHomeTelemetry implements IPokemonHomeTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokemonHomeTelemetry);
            public pokemon_home_click_ids: POGOProtos.Rpc.PokemonHomeTelemetryIds;
            public static encode(message: POGOProtos.Rpc.IPokemonHomeTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonHomeTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonHomeTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokemonHomeTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonIndividualStatRewardProto {
            pokemon_id?: (number|Long|null);
            stat_type?: (POGOProtos.Rpc.PokemonIndividualStatType|null);
            stat_increase_amount?: (number|null);
        }

        class PokemonIndividualStatRewardProto implements IPokemonIndividualStatRewardProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonIndividualStatRewardProto);
            public pokemon_id: (number|Long);
            public stat_type: POGOProtos.Rpc.PokemonIndividualStatType;
            public stat_increase_amount: number;
            public static encode(message: POGOProtos.Rpc.IPokemonIndividualStatRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonIndividualStatRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonIndividualStatRewardProto;
            public static toObject(message: POGOProtos.Rpc.PokemonIndividualStatRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonInfo {
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            current_health?: (number|null);
            current_energy?: (number|null);
            notable_action_history?: (POGOProtos.Rpc.IVsActionHistory[]|null);
            stat_modifiers?: ({ [k: string]: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer }|null);
            vs_effect_tag?: (POGOProtos.Rpc.VsEffectTag[]|null);
        }

        class PokemonInfo implements IPokemonInfo {
            constructor(properties?: POGOProtos.Rpc.IPokemonInfo);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public current_health: number;
            public current_energy: number;
            public notable_action_history: POGOProtos.Rpc.IVsActionHistory[];
            public stat_modifiers: { [k: string]: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer };
            public vs_effect_tag: POGOProtos.Rpc.VsEffectTag[];
            public static encode(message: POGOProtos.Rpc.IPokemonInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonInfo;
            public static toObject(message: POGOProtos.Rpc.PokemonInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonInfo {

            interface IStatModifierContainer {
                stat_modifier?: (POGOProtos.Rpc.PokemonInfo.StatModifierContainer.IStatModifier[]|null);
            }

            class StatModifierContainer implements IStatModifierContainer {
                constructor(properties?: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer);
                public stat_modifier: POGOProtos.Rpc.PokemonInfo.StatModifierContainer.IStatModifier[];
                public static encode(message: POGOProtos.Rpc.PokemonInfo.IStatModifierContainer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonInfo.StatModifierContainer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonInfo.StatModifierContainer;
                public static toObject(message: POGOProtos.Rpc.PokemonInfo.StatModifierContainer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace StatModifierContainer {

                interface IStatModifier {
                    value?: (number|Long|null);
                    expiry_time_ms?: (number|Long|null);
                    type?: (POGOProtos.Rpc.MoveModifierProto.MoveModifierType|null);
                    string_value?: (string|null);
                    expiry_type?: (POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier.ExpiryType|null);
                    condition?: (POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier.Condition[]|null);
                    expiry_value?: (number|Long|null);
                }

                class StatModifier implements IStatModifier {
                    constructor(properties?: POGOProtos.Rpc.PokemonInfo.StatModifierContainer.IStatModifier);
                    public value: (number|Long);
                    public expiry_time_ms: (number|Long);
                    public type: POGOProtos.Rpc.MoveModifierProto.MoveModifierType;
                    public string_value: string;
                    public expiry_type: POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier.ExpiryType;
                    public condition: POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier.Condition[];
                    public expiry_value: (number|Long);
                    public static encode(message: POGOProtos.Rpc.PokemonInfo.StatModifierContainer.IStatModifier, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier;
                    public static toObject(message: POGOProtos.Rpc.PokemonInfo.StatModifierContainer.StatModifier, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace StatModifier {

                    enum Condition {
                        UNSET_CONDITION = 0,
                        CHARGE_MOVE = 1,
                        FAST_MOVE = 2
                    }

                    enum ExpiryType {
                        UNSET_EXPIRY_TYPE = 0,
                        EXPIRY_TIME = 1,
                        CHARGES_REMAINING = 2
                    }
                }
            }
        }

        interface IPokemonInfoPanelSettingsProto {
            origin_section_v2_enabled?: (boolean|null);
            bottom_origin_section_v2_enabled?: (boolean|null);
        }

        class PokemonInfoPanelSettingsProto implements IPokemonInfoPanelSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonInfoPanelSettingsProto);
            public origin_section_v2_enabled: boolean;
            public bottom_origin_section_v2_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPokemonInfoPanelSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonInfoPanelSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonInfoPanelSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonInfoPanelSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonInventoryTelemetry {
            pokemon_inventory_click_ids?: (POGOProtos.Rpc.PokemonInventoryTelemetryIds|null);
            sort_id?: (string|null);
        }

        class PokemonInventoryTelemetry implements IPokemonInventoryTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokemonInventoryTelemetry);
            public pokemon_inventory_click_ids: POGOProtos.Rpc.PokemonInventoryTelemetryIds;
            public sort_id: string;
            public static encode(message: POGOProtos.Rpc.IPokemonInventoryTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonInventoryTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonInventoryTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokemonInventoryTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonKeyItemSettings {
            item?: (POGOProtos.Rpc.Item|null);
            count?: (number|null);
        }

        class PokemonKeyItemSettings implements IPokemonKeyItemSettings {
            constructor(properties?: POGOProtos.Rpc.IPokemonKeyItemSettings);
            public item: POGOProtos.Rpc.Item;
            public count: number;
            public static encode(message: POGOProtos.Rpc.IPokemonKeyItemSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonKeyItemSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonKeyItemSettings;
            public static toObject(message: POGOProtos.Rpc.PokemonKeyItemSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonLoadDelay {
            pokemon?: (POGOProtos.Rpc.IPokemonLoadTelemetry|null);
            load_delay?: (number|null);
        }

        class PokemonLoadDelay implements IPokemonLoadDelay {
            constructor(properties?: POGOProtos.Rpc.IPokemonLoadDelay);
            public pokemon?: (POGOProtos.Rpc.IPokemonLoadTelemetry|null);
            public load_delay: number;
            public static encode(message: POGOProtos.Rpc.IPokemonLoadDelay, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonLoadDelay;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonLoadDelay;
            public static toObject(message: POGOProtos.Rpc.PokemonLoadDelay, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonLoadTelemetry {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            gender?: (POGOProtos.Rpc.PokemonDisplayProto.Gender|null);
            shiny?: (boolean|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment|null);
            temporary_evolution_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
        }

        class PokemonLoadTelemetry implements IPokemonLoadTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokemonLoadTelemetry);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public gender: POGOProtos.Rpc.PokemonDisplayProto.Gender;
            public shiny: boolean;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment;
            public temporary_evolution_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public static encode(message: POGOProtos.Rpc.IPokemonLoadTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonLoadTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonLoadTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokemonLoadTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonMapSettingsProto {
            hide_nearby?: (boolean|null);
        }

        class PokemonMapSettingsProto implements IPokemonMapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonMapSettingsProto);
            public hide_nearby: boolean;
            public static encode(message: POGOProtos.Rpc.IPokemonMapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonMapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonMapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonMapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonMegaEvolutionLevelProto {
            points?: (number|Long|null);
            level?: (number|null);
            mega_point_daily_counters?: (POGOProtos.Rpc.IPokemonMegaEvolutionPointDailyCountersProto|null);
        }

        class PokemonMegaEvolutionLevelProto implements IPokemonMegaEvolutionLevelProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonMegaEvolutionLevelProto);
            public points: (number|Long);
            public level: number;
            public mega_point_daily_counters?: (POGOProtos.Rpc.IPokemonMegaEvolutionPointDailyCountersProto|null);
            public static encode(message: POGOProtos.Rpc.IPokemonMegaEvolutionLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonMegaEvolutionLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonMegaEvolutionLevelProto;
            public static toObject(message: POGOProtos.Rpc.PokemonMegaEvolutionLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonMegaEvolutionPointDailyCountersProto {
            mega_evo?: (POGOProtos.Rpc.IDailyCounterProto|null);
        }

        class PokemonMegaEvolutionPointDailyCountersProto implements IPokemonMegaEvolutionPointDailyCountersProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonMegaEvolutionPointDailyCountersProto);
            public mega_evo?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public static encode(message: POGOProtos.Rpc.IPokemonMegaEvolutionPointDailyCountersProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonMegaEvolutionPointDailyCountersProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonMegaEvolutionPointDailyCountersProto;
            public static toObject(message: POGOProtos.Rpc.PokemonMegaEvolutionPointDailyCountersProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonMusicOverrideConfig {
            pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
            battle_music_key?: (string|null);
        }

        class PokemonMusicOverrideConfig implements IPokemonMusicOverrideConfig {
            constructor(properties?: POGOProtos.Rpc.IPokemonMusicOverrideConfig);
            public pokemon: POGOProtos.Rpc.HoloPokemonId;
            public forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public battle_music_key: string;
            public static encode(message: POGOProtos.Rpc.IPokemonMusicOverrideConfig, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonMusicOverrideConfig;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonMusicOverrideConfig;
            public static toObject(message: POGOProtos.Rpc.PokemonMusicOverrideConfig, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonPhotoSetsProto {
            name_key?: (string|null);
            frame_color?: (string|null);
            minimum_pokemon?: (number|null);
            pokemon?: (POGOProtos.Rpc.IPhotoSetPokemonInfoProto[]|null);
            display_order?: (number|null);
        }

        class PokemonPhotoSetsProto implements IPokemonPhotoSetsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonPhotoSetsProto);
            public name_key: string;
            public frame_color: string;
            public minimum_pokemon: number;
            public pokemon: POGOProtos.Rpc.IPhotoSetPokemonInfoProto[];
            public display_order: number;
            public static encode(message: POGOProtos.Rpc.IPokemonPhotoSetsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonPhotoSetsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonPhotoSetsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonPhotoSetsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonProto {
            id?: (number|Long|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            stamina?: (number|null);
            max_stamina?: (number|null);
            move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
            move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
            deployed_fort_id?: (string|null);
            owner_name?: (string|null);
            is_egg?: (boolean|null);
            egg_km_walked_target?: (number|null);
            egg_km_walked_start?: (number|null);
            height_m?: (number|null);
            weight_kg?: (number|null);
            individual_attack?: (number|null);
            individual_defense?: (number|null);
            individual_stamina?: (number|null);
            cp_multiplier?: (number|null);
            pokeball?: (POGOProtos.Rpc.Item|null);
            captured_s2_cell_id?: (number|Long|null);
            battles_attacked?: (number|null);
            battles_defended?: (number|null);
            egg_incubator_id?: (string|null);
            creation_time_ms?: (number|Long|null);
            num_upgrades?: (number|null);
            additional_cp_multiplier?: (number|null);
            favorite?: (boolean|null);
            nickname?: (string|null);
            from_fort?: (boolean|null);
            buddy_candy_awarded?: (number|null);
            buddy_km_walked?: (number|null);
            display_pokemon_id?: (number|null);
            display_cp?: (number|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            is_bad?: (boolean|null);
            hatched_from_egg?: (boolean|null);
            coins_returned?: (number|null);
            deployed_duration_ms?: (number|Long|null);
            deployed_returned_timestamp_ms?: (number|Long|null);
            cp_multiplier_before_trading?: (number|null);
            trading_original_owner_hash?: (number|null);
            original_owner_nickname?: (string|null);
            traded_time_ms?: (number|Long|null);
            is_lucky?: (boolean|null);
            move3?: (POGOProtos.Rpc.HoloPokemonMove|null);
            pvp_combat_stats?: (POGOProtos.Rpc.IPokemonCombatStatsProto|null);
            npc_combat_stats?: (POGOProtos.Rpc.IPokemonCombatStatsProto|null);
            move2_is_purified_exclusive?: (boolean|null);
            limited_pokemon_identifier?: (string|null);
            pre_boosted_cp?: (number|null);
            pre_boosted_additional_cp_multiplier?: (number|null);
            deployed_gym_lat_degree?: (number|null);
            deployed_gym_lng_degree?: (number|null);
            has_mega_evolved?: (boolean|null);
            egg_type?: (POGOProtos.Rpc.HoloPokemonEggType|null);
            temp_evo_cp?: (number|null);
            temp_evo_stamina_modifier?: (number|null);
            temp_evo_cp_multiplier?: (number|null);
            mega_evolved_forms?: (POGOProtos.Rpc.HoloTemporaryEvolutionId[]|null);
            evolution_quest_info?: (POGOProtos.Rpc.IPokemonEvolutionQuestProto[]|null);
            origin_detail?: (POGOProtos.Rpc.IPokemonCreateDetail|null);
            pokemon_tag_ids?: ((number|Long)[]|null);
            origin_events?: (string[]|null);
            egg_slot_type?: (POGOProtos.Rpc.EggSlotType|null);
            egg_telemetry?: (POGOProtos.Rpc.IEggTelemetryProto|null);
            egg_distribution?: (POGOProtos.Rpc.IEggDistributionProto|null);
            size?: (POGOProtos.Rpc.HoloPokemonSize|null);
            pokemon_contest_info?: (POGOProtos.Rpc.IPokemonContestInfoProto|null);
            caught_in_party?: (boolean|null);
            is_component?: (boolean|null);
            is_fusion?: (boolean|null);
            iris_social_deployment?: (POGOProtos.Rpc.IIrisSocialDeploymentProto|null);
            bread_moves?: (POGOProtos.Rpc.IBreadMoveSlotProto[]|null);
            deployed_station_id?: (string|null);
            deployed_station_expiration_time_ms?: (number|Long|null);
            is_stamp_collection_reward?: (boolean|null);
            is_actively_training?: (boolean|null);
            bonus_stat_level?: (POGOProtos.Rpc.IPokemonBonusStatLevelProto|null);
        }

        class PokemonProto implements IPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonProto);
            public id: (number|Long);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public stamina: number;
            public max_stamina: number;
            public move1: POGOProtos.Rpc.HoloPokemonMove;
            public move2: POGOProtos.Rpc.HoloPokemonMove;
            public deployed_fort_id: string;
            public owner_name: string;
            public is_egg: boolean;
            public egg_km_walked_target: number;
            public egg_km_walked_start: number;
            public height_m: number;
            public weight_kg: number;
            public individual_attack: number;
            public individual_defense: number;
            public individual_stamina: number;
            public cp_multiplier: number;
            public pokeball: POGOProtos.Rpc.Item;
            public captured_s2_cell_id: (number|Long);
            public battles_attacked: number;
            public battles_defended: number;
            public egg_incubator_id: string;
            public creation_time_ms: (number|Long);
            public num_upgrades: number;
            public additional_cp_multiplier: number;
            public favorite: boolean;
            public nickname: string;
            public from_fort: boolean;
            public buddy_candy_awarded: number;
            public buddy_km_walked: number;
            public display_pokemon_id: number;
            public display_cp: number;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public is_bad: boolean;
            public hatched_from_egg: boolean;
            public coins_returned: number;
            public deployed_duration_ms: (number|Long);
            public deployed_returned_timestamp_ms: (number|Long);
            public cp_multiplier_before_trading: number;
            public trading_original_owner_hash: number;
            public original_owner_nickname: string;
            public traded_time_ms: (number|Long);
            public is_lucky: boolean;
            public move3: POGOProtos.Rpc.HoloPokemonMove;
            public pvp_combat_stats?: (POGOProtos.Rpc.IPokemonCombatStatsProto|null);
            public npc_combat_stats?: (POGOProtos.Rpc.IPokemonCombatStatsProto|null);
            public move2_is_purified_exclusive: boolean;
            public limited_pokemon_identifier: string;
            public pre_boosted_cp: number;
            public pre_boosted_additional_cp_multiplier: number;
            public deployed_gym_lat_degree: number;
            public deployed_gym_lng_degree: number;
            public has_mega_evolved: boolean;
            public egg_type: POGOProtos.Rpc.HoloPokemonEggType;
            public temp_evo_cp: number;
            public temp_evo_stamina_modifier: number;
            public temp_evo_cp_multiplier: number;
            public mega_evolved_forms: POGOProtos.Rpc.HoloTemporaryEvolutionId[];
            public evolution_quest_info: POGOProtos.Rpc.IPokemonEvolutionQuestProto[];
            public origin_detail?: (POGOProtos.Rpc.IPokemonCreateDetail|null);
            public pokemon_tag_ids: (number|Long)[];
            public origin_events: string[];
            public egg_slot_type: POGOProtos.Rpc.EggSlotType;
            public egg_telemetry?: (POGOProtos.Rpc.IEggTelemetryProto|null);
            public egg_distribution?: (POGOProtos.Rpc.IEggDistributionProto|null);
            public size: POGOProtos.Rpc.HoloPokemonSize;
            public pokemon_contest_info?: (POGOProtos.Rpc.IPokemonContestInfoProto|null);
            public caught_in_party: boolean;
            public is_component: boolean;
            public is_fusion: boolean;
            public iris_social_deployment?: (POGOProtos.Rpc.IIrisSocialDeploymentProto|null);
            public bread_moves: POGOProtos.Rpc.IBreadMoveSlotProto[];
            public deployed_station_id: string;
            public deployed_station_expiration_time_ms: (number|Long);
            public is_stamp_collection_reward: boolean;
            public is_actively_training: boolean;
            public bonus_stat_level?: (POGOProtos.Rpc.IPokemonBonusStatLevelProto|null);
            public static encode(message: POGOProtos.Rpc.IPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonProto;
            public static toObject(message: POGOProtos.Rpc.PokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonReachCpQuestProto {
        }

        class PokemonReachCpQuestProto implements IPokemonReachCpQuestProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonReachCpQuestProto);
            public static encode(message: POGOProtos.Rpc.IPokemonReachCpQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonReachCpQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonReachCpQuestProto;
            public static toObject(message: POGOProtos.Rpc.PokemonReachCpQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonScaleSettingProto {
            pokemon_scale_mode?: (POGOProtos.Rpc.PokemonScaleSettingProto.PokemonScaleMode|null);
            min_height?: (number|null);
            max_height?: (number|null);
        }

        class PokemonScaleSettingProto implements IPokemonScaleSettingProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonScaleSettingProto);
            public pokemon_scale_mode: POGOProtos.Rpc.PokemonScaleSettingProto.PokemonScaleMode;
            public min_height: number;
            public max_height: number;
            public static encode(message: POGOProtos.Rpc.IPokemonScaleSettingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonScaleSettingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonScaleSettingProto;
            public static toObject(message: POGOProtos.Rpc.PokemonScaleSettingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonScaleSettingProto {

            enum PokemonScaleMode {
                natural_scale = 0,
                gui_scale = 1,
                battle_pokemon_scale = 2,
                raid_boss_scale = 3,
                gym_topper_scale = 4,
                map_pokemon_scale = 5
            }
        }

        interface IPokemonSearchTelemetry {
            pokemon_search_source_id?: (POGOProtos.Rpc.PokemonSearchTelemetry.PokemonSearchSourceIds|null);
            prepended_search_string?: (string|null);
            search_term_string?: (string|null);
            appended_search_string?: (string|null);
            experiment_id?: (number[]|null);
        }

        class PokemonSearchTelemetry implements IPokemonSearchTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokemonSearchTelemetry);
            public pokemon_search_source_id: POGOProtos.Rpc.PokemonSearchTelemetry.PokemonSearchSourceIds;
            public prepended_search_string: string;
            public search_term_string: string;
            public appended_search_string: string;
            public experiment_id: number[];
            public static encode(message: POGOProtos.Rpc.IPokemonSearchTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonSearchTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonSearchTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokemonSearchTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonSearchTelemetry {

            enum PokemonSearchSourceIds {
                UNDEFINED = 0,
                FROM_SEARCH_PILL_CLICK = 1,
                LATEST_SEARCH_ENTRY_CLICK = 2
            }
        }

        interface IPokemonSettingsProto {
            unique_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            model_scale?: (number|null);
            type1?: (POGOProtos.Rpc.HoloPokemonType|null);
            type2?: (POGOProtos.Rpc.HoloPokemonType|null);
            camera?: (POGOProtos.Rpc.IPokemonCameraAttributesProto|null);
            encounter?: (POGOProtos.Rpc.IPokemonEncounterAttributesProto|null);
            stats?: (POGOProtos.Rpc.IPokemonStatsAttributesProto|null);
            quick_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            cinematic_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            anim_time?: (number[]|null);
            evolution?: (POGOProtos.Rpc.HoloPokemonId[]|null);
            evolution_pips?: (number|null);
            pokemon_class?: (POGOProtos.Rpc.HoloPokemonClass|null);
            pokedex_height_m?: (number|null);
            pokedex_weight_kg?: (number|null);
            parent_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            height_std_dev?: (number|null);
            weight_std_dev?: (number|null);
            km_distance_to_hatch?: (number|null);
            family_id?: (POGOProtos.Rpc.HoloPokemonFamilyId|null);
            candy_to_evolve?: (number|null);
            km_buddy_distance?: (number|null);
            buddy_size?: (POGOProtos.Rpc.PokemonSettingsProto.BuddySize|null);
            model_height?: (number|null);
            evolution_branch?: (POGOProtos.Rpc.IEvolutionBranchProto[]|null);
            model_scale_v2?: (number|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            event_quick_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
            event_cinematic_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
            buddy_offset_male?: (number[]|null);
            buddy_offset_female?: (number[]|null);
            buddy_scale?: (number|null);
            buddy_portrait_offset?: (number[]|null);
            parent_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            third_move?: (POGOProtos.Rpc.IPokemonThirdMoveAttributesProto|null);
            is_transferable?: (boolean|null);
            is_deployable?: (boolean|null);
            combat_shoulder_camera_angle?: (number[]|null);
            is_tradable?: (boolean|null);
            combat_default_camera_angle?: (number[]|null);
            combat_opponent_focus_camera_angle?: (number[]|null);
            combat_player_focus_camera_angle?: (number[]|null);
            combat_player_pokemon_position_offset?: (number[]|null);
            photobomb_animation_overrides?: (POGOProtos.Rpc.IAnimationOverrideProto[]|null);
            shadow?: (POGOProtos.Rpc.IShadowAttributesProto|null);
            buddy_group_number?: (number|null);
            additional_cp_boost_level?: (number|null);
            elite_quick_move?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            elite_cinematic_move?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            temp_evo_overrides?: (POGOProtos.Rpc.ITempEvoOverrideProto[]|null);
            buddy_walked_mega_energy_award?: (number|null);
            buddy_walked_mega_energy_awards?: (POGOProtos.Rpc.IBuddyWalkedMegaEnergyProto[]|null);
            disable_transfer_to_pokemon_home?: (boolean|null);
            raid_boss_distance_offset?: (number|null);
            form_change?: (POGOProtos.Rpc.IFormChangeProto[]|null);
            buddy_encounter_cameo_local_position?: (number[]|null);
            buddy_encounter_cameo_local_rotation?: (number[]|null);
            size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            allow_noevolve_evolution?: (POGOProtos.Rpc.PokemonDisplayProto.Costume[]|null);
            deny_impersonation?: (boolean|null);
            buddy_portrait_rotation?: (number[]|null);
            non_tm_cinematic_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            deprecated1?: (POGOProtos.Rpc.Item|null);
            exclusive_key_item?: (POGOProtos.Rpc.IPokemonKeyItemSettings|null);
            event_cinematic_move_probability?: (number|null);
            event_quick_move_probability?: (number|null);
            use_iris_flying_placement?: (boolean|null);
            iris_photo_emote_1?: (string|null);
            iris_photo_emote_2?: (string|null);
            iris_flying_height_limit_meters?: (number|null);
            ibfc?: (POGOProtos.Rpc.IIbfcProto|null);
            group?: (POGOProtos.Rpc.BreadGroupSettings.BreadTierGroup|null);
            iris_photo_hue_order?: (number|null);
            iris_photo_shiny_hue_order?: (number|null);
            bread_overrides?: (POGOProtos.Rpc.IBreadOverrideProto[]|null);
            pokemon_class_override?: (POGOProtos.Rpc.IPokemonClassOverridesProto|null);
        }

        class PokemonSettingsProto implements IPokemonSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonSettingsProto);
            public unique_id: POGOProtos.Rpc.HoloPokemonId;
            public model_scale: number;
            public type1: POGOProtos.Rpc.HoloPokemonType;
            public type2: POGOProtos.Rpc.HoloPokemonType;
            public camera?: (POGOProtos.Rpc.IPokemonCameraAttributesProto|null);
            public encounter?: (POGOProtos.Rpc.IPokemonEncounterAttributesProto|null);
            public stats?: (POGOProtos.Rpc.IPokemonStatsAttributesProto|null);
            public quick_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public cinematic_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public anim_time: number[];
            public evolution: POGOProtos.Rpc.HoloPokemonId[];
            public evolution_pips: number;
            public pokemon_class: POGOProtos.Rpc.HoloPokemonClass;
            public pokedex_height_m: number;
            public pokedex_weight_kg: number;
            public parent_id: POGOProtos.Rpc.HoloPokemonId;
            public height_std_dev: number;
            public weight_std_dev: number;
            public km_distance_to_hatch: number;
            public family_id: POGOProtos.Rpc.HoloPokemonFamilyId;
            public candy_to_evolve: number;
            public km_buddy_distance: number;
            public buddy_size: POGOProtos.Rpc.PokemonSettingsProto.BuddySize;
            public model_height: number;
            public evolution_branch: POGOProtos.Rpc.IEvolutionBranchProto[];
            public model_scale_v2: number;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public event_quick_move: POGOProtos.Rpc.HoloPokemonMove;
            public event_cinematic_move: POGOProtos.Rpc.HoloPokemonMove;
            public buddy_offset_male: number[];
            public buddy_offset_female: number[];
            public buddy_scale: number;
            public buddy_portrait_offset: number[];
            public parent_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public third_move?: (POGOProtos.Rpc.IPokemonThirdMoveAttributesProto|null);
            public is_transferable: boolean;
            public is_deployable: boolean;
            public combat_shoulder_camera_angle: number[];
            public is_tradable: boolean;
            public combat_default_camera_angle: number[];
            public combat_opponent_focus_camera_angle: number[];
            public combat_player_focus_camera_angle: number[];
            public combat_player_pokemon_position_offset: number[];
            public photobomb_animation_overrides: POGOProtos.Rpc.IAnimationOverrideProto[];
            public shadow?: (POGOProtos.Rpc.IShadowAttributesProto|null);
            public buddy_group_number: number;
            public additional_cp_boost_level: number;
            public elite_quick_move: POGOProtos.Rpc.HoloPokemonMove[];
            public elite_cinematic_move: POGOProtos.Rpc.HoloPokemonMove[];
            public temp_evo_overrides: POGOProtos.Rpc.ITempEvoOverrideProto[];
            public buddy_walked_mega_energy_award: number;
            public buddy_walked_mega_energy_awards: POGOProtos.Rpc.IBuddyWalkedMegaEnergyProto[];
            public disable_transfer_to_pokemon_home: boolean;
            public raid_boss_distance_offset: number;
            public form_change: POGOProtos.Rpc.IFormChangeProto[];
            public buddy_encounter_cameo_local_position: number[];
            public buddy_encounter_cameo_local_rotation: number[];
            public size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            public allow_noevolve_evolution: POGOProtos.Rpc.PokemonDisplayProto.Costume[];
            public deny_impersonation: boolean;
            public buddy_portrait_rotation: number[];
            public non_tm_cinematic_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public deprecated1: POGOProtos.Rpc.Item;
            public exclusive_key_item?: (POGOProtos.Rpc.IPokemonKeyItemSettings|null);
            public event_cinematic_move_probability: number;
            public event_quick_move_probability: number;
            public use_iris_flying_placement: boolean;
            public iris_photo_emote_1: string;
            public iris_photo_emote_2: string;
            public iris_flying_height_limit_meters: number;
            public ibfc?: (POGOProtos.Rpc.IIbfcProto|null);
            public group: POGOProtos.Rpc.BreadGroupSettings.BreadTierGroup;
            public iris_photo_hue_order: number;
            public iris_photo_shiny_hue_order: number;
            public bread_overrides: POGOProtos.Rpc.IBreadOverrideProto[];
            public pokemon_class_override?: (POGOProtos.Rpc.IPokemonClassOverridesProto|null);
            public static encode(message: POGOProtos.Rpc.IPokemonSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PokemonSettingsProto {

            enum BuddySize {
                BUDDY_MEDIUM = 0,
                BUDDY_SHOULDER = 1,
                BUDDY_BIG = 2,
                BUDDY_FLYING = 3,
                BUDDY_BABY = 4
            }
        }

        interface IPokemonSizeSettingsProto {
            xxs_lower_bound?: (number|null);
            xs_lower_bound?: (number|null);
            mlower_bound?: (number|null);
            mupper_bound?: (number|null);
            xl_upper_bound?: (number|null);
            xxl_upper_bound?: (number|null);
            xxs_scale_multiplier?: (number|null);
            xs_scale_multiplier?: (number|null);
            xl_scale_multiplier?: (number|null);
            xxl_scale_multiplier?: (number|null);
            disable_pokedex_record_display_aggregate?: (boolean|null);
            disable_pokedex_record_display_for_forms?: (boolean|null);
            pokedex_display_pokemon_tracked_threshold?: (number|null);
            record_display_pokemon_tracked_threshold?: (number|null);
        }

        class PokemonSizeSettingsProto implements IPokemonSizeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonSizeSettingsProto);
            public xxs_lower_bound: number;
            public xs_lower_bound: number;
            public mlower_bound: number;
            public mupper_bound: number;
            public xl_upper_bound: number;
            public xxl_upper_bound: number;
            public xxs_scale_multiplier: number;
            public xs_scale_multiplier: number;
            public xl_scale_multiplier: number;
            public xxl_scale_multiplier: number;
            public disable_pokedex_record_display_aggregate: boolean;
            public disable_pokedex_record_display_for_forms: boolean;
            public pokedex_display_pokemon_tracked_threshold: number;
            public record_display_pokemon_tracked_threshold: number;
            public static encode(message: POGOProtos.Rpc.IPokemonSizeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonSizeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonSizeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonSizeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonStaminaUpdateProto {
            pokemon_id?: (number|Long|null);
            updated_stamina?: (number|null);
        }

        class PokemonStaminaUpdateProto implements IPokemonStaminaUpdateProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonStaminaUpdateProto);
            public pokemon_id: (number|Long);
            public updated_stamina: number;
            public static encode(message: POGOProtos.Rpc.IPokemonStaminaUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonStaminaUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonStaminaUpdateProto;
            public static toObject(message: POGOProtos.Rpc.PokemonStaminaUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonStatValueProto {
            pokemon_id?: (number|Long|null);
            value?: (number|null);
            pokemon_creation_time_ms?: (number|Long|null);
        }

        class PokemonStatValueProto implements IPokemonStatValueProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonStatValueProto);
            public pokemon_id: (number|Long);
            public value: number;
            public pokemon_creation_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPokemonStatValueProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonStatValueProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonStatValueProto;
            public static toObject(message: POGOProtos.Rpc.PokemonStatValueProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonStatsAttributesProto {
            base_stamina?: (number|null);
            base_attack?: (number|null);
            base_defense?: (number|null);
            dodge_energy_delta?: (number|null);
        }

        class PokemonStatsAttributesProto implements IPokemonStatsAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonStatsAttributesProto);
            public base_stamina: number;
            public base_attack: number;
            public base_defense: number;
            public dodge_energy_delta: number;
            public static encode(message: POGOProtos.Rpc.IPokemonStatsAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonStatsAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonStatsAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PokemonStatsAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonStatsLimitsProto {
            min_pokemon_level?: (number|null);
            max_pokemon_level?: (number|null);
            min_attack?: (number|null);
            max_attack?: (number|null);
            min_defense?: (number|null);
            max_defense?: (number|null);
            min_hp?: (number|null);
            max_hp?: (number|null);
        }

        class PokemonStatsLimitsProto implements IPokemonStatsLimitsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonStatsLimitsProto);
            public min_pokemon_level: number;
            public max_pokemon_level: number;
            public min_attack: number;
            public max_attack: number;
            public min_defense: number;
            public max_defense: number;
            public min_hp: number;
            public max_hp: number;
            public static encode(message: POGOProtos.Rpc.IPokemonStatsLimitsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonStatsLimitsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonStatsLimitsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonStatsLimitsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonSummaryFortProto {
            fort_summary_id?: (string|null);
            last_modified_ms?: (number|Long|null);
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class PokemonSummaryFortProto implements IPokemonSummaryFortProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonSummaryFortProto);
            public fort_summary_id: string;
            public last_modified_ms: (number|Long);
            public latitude: number;
            public longitude: number;
            public static encode(message: POGOProtos.Rpc.IPokemonSummaryFortProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonSummaryFortProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonSummaryFortProto;
            public static toObject(message: POGOProtos.Rpc.PokemonSummaryFortProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonSurvivalTimeInfo {
            longest_battle_duration_pokemon_time_ms?: (number|null);
            active_pokemon_enter_battle_time_ms?: (number|Long|null);
            longest_battle_duration_pokemon_id?: (number|Long|null);
        }

        class PokemonSurvivalTimeInfo implements IPokemonSurvivalTimeInfo {
            constructor(properties?: POGOProtos.Rpc.IPokemonSurvivalTimeInfo);
            public longest_battle_duration_pokemon_time_ms: number;
            public active_pokemon_enter_battle_time_ms: (number|Long);
            public longest_battle_duration_pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPokemonSurvivalTimeInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonSurvivalTimeInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonSurvivalTimeInfo;
            public static toObject(message: POGOProtos.Rpc.PokemonSurvivalTimeInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonTagColorBinding {
            color?: (POGOProtos.Rpc.PokemonTagColor|null);
            hex_code?: (string|null);
        }

        class PokemonTagColorBinding implements IPokemonTagColorBinding {
            constructor(properties?: POGOProtos.Rpc.IPokemonTagColorBinding);
            public color: POGOProtos.Rpc.PokemonTagColor;
            public hex_code: string;
            public static encode(message: POGOProtos.Rpc.IPokemonTagColorBinding, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonTagColorBinding;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonTagColorBinding;
            public static toObject(message: POGOProtos.Rpc.PokemonTagColorBinding, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonTagProto {
            id?: (number|Long|null);
            name?: (string|null);
            color?: (POGOProtos.Rpc.PokemonTagColor|null);
            sort_index?: (number|null);
        }

        class PokemonTagProto implements IPokemonTagProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonTagProto);
            public id: (number|Long);
            public name: string;
            public color: POGOProtos.Rpc.PokemonTagColor;
            public sort_index: number;
            public static encode(message: POGOProtos.Rpc.IPokemonTagProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonTagProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonTagProto;
            public static toObject(message: POGOProtos.Rpc.PokemonTagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonTagSettingsProto {
            min_player_level_for_pokemon_tagging?: (number|null);
            color_binding?: (POGOProtos.Rpc.IPokemonTagColorBinding[]|null);
            max_num_tags_allowed?: (number|null);
            tag_name_character_limit?: (number|null);
        }

        class PokemonTagSettingsProto implements IPokemonTagSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonTagSettingsProto);
            public min_player_level_for_pokemon_tagging: number;
            public color_binding: POGOProtos.Rpc.IPokemonTagColorBinding[];
            public max_num_tags_allowed: number;
            public tag_name_character_limit: number;
            public static encode(message: POGOProtos.Rpc.IPokemonTagSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonTagSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonTagSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonTagSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonTelemetry {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            cp?: (number|null);
            weight_kg?: (number|null);
            height_m?: (number|null);
            pokemon_level?: (number|null);
        }

        class PokemonTelemetry implements IPokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPokemonTelemetry);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public cp: number;
            public weight_kg: number;
            public height_m: number;
            public pokemon_level: number;
            public static encode(message: POGOProtos.Rpc.IPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.PokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonThirdMoveAttributesProto {
            stardust_to_unlock?: (number|null);
            candy_to_unlock?: (number|null);
        }

        class PokemonThirdMoveAttributesProto implements IPokemonThirdMoveAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonThirdMoveAttributesProto);
            public stardust_to_unlock: number;
            public candy_to_unlock: number;
            public static encode(message: POGOProtos.Rpc.IPokemonThirdMoveAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonThirdMoveAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonThirdMoveAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PokemonThirdMoveAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonTrainingQuestProto {
            stat_courses?: (POGOProtos.Rpc.ITrainingCourseQuestProto[]|null);
        }

        class PokemonTrainingQuestProto implements IPokemonTrainingQuestProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonTrainingQuestProto);
            public stat_courses: POGOProtos.Rpc.ITrainingCourseQuestProto[];
            public static encode(message: POGOProtos.Rpc.IPokemonTrainingQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonTrainingQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonTrainingQuestProto;
            public static toObject(message: POGOProtos.Rpc.PokemonTrainingQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonTrainingTypeGroupProto {
            stat_type?: (POGOProtos.Rpc.PokemonIndividualStatType|null);
            stat_level?: (number|null);
        }

        class PokemonTrainingTypeGroupProto implements IPokemonTrainingTypeGroupProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonTrainingTypeGroupProto);
            public stat_type: POGOProtos.Rpc.PokemonIndividualStatType;
            public stat_level: number;
            public static encode(message: POGOProtos.Rpc.IPokemonTrainingTypeGroupProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonTrainingTypeGroupProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonTrainingTypeGroupProto;
            public static toObject(message: POGOProtos.Rpc.PokemonTrainingTypeGroupProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonUpgradeSettingsProto {
            upgrades_per_level?: (number|null);
            allowed_levels_above_player?: (number|null);
            candy_cost?: (number[]|null);
            stardust_cost?: (number[]|null);
            shadow_stardust_multiplier?: (number|null);
            shadow_candy_multiplier?: (number|null);
            purified_stardust_multiplier?: (number|null);
            purified_candy_multiplier?: (number|null);
            max_normal_upgrade_level?: (number|null);
            default_cp_boost_additional_level?: (number|null);
            xl_candy_min_player_level?: (number|null);
            xl_candy_cost?: (number[]|null);
            xl_candy_min_pokemon_level?: (number|null);
        }

        class PokemonUpgradeSettingsProto implements IPokemonUpgradeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPokemonUpgradeSettingsProto);
            public upgrades_per_level: number;
            public allowed_levels_above_player: number;
            public candy_cost: number[];
            public stardust_cost: number[];
            public shadow_stardust_multiplier: number;
            public shadow_candy_multiplier: number;
            public purified_stardust_multiplier: number;
            public purified_candy_multiplier: number;
            public max_normal_upgrade_level: number;
            public default_cp_boost_additional_level: number;
            public xl_candy_min_player_level: number;
            public xl_candy_cost: number[];
            public xl_candy_min_pokemon_level: number;
            public static encode(message: POGOProtos.Rpc.IPokemonUpgradeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokemonUpgradeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokemonUpgradeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PokemonUpgradeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokestopDisplayProto {
            style_config_address?: (string|null);
        }

        class PokestopDisplayProto implements IPokestopDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IPokestopDisplayProto);
            public style_config_address: string;
            public static encode(message: POGOProtos.Rpc.IPokestopDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokestopDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokestopDisplayProto;
            public static toObject(message: POGOProtos.Rpc.PokestopDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokestopIncidentDisplayProto {
            character_display?: (POGOProtos.Rpc.ICharacterDisplayProto|null);
            invasion_finished?: (POGOProtos.Rpc.IInvasionFinishedDisplayProto|null);
            contest_display?: (POGOProtos.Rpc.IContestDisplayProto|null);
            incident_id?: (string|null);
            incident_start_ms?: (number|Long|null);
            incident_expiration_ms?: (number|Long|null);
            hide_incident?: (boolean|null);
            incident_completed?: (boolean|null);
            incident_display_type?: (POGOProtos.Rpc.IncidentDisplayType|null);
            incident_display_order_priority?: (number|null);
            continue_displaying_incident?: (boolean|null);
            custom_display?: (POGOProtos.Rpc.IPokestopDisplayProto|null);
            is_cross_stop_incident?: (boolean|null);
        }

        class PokestopIncidentDisplayProto implements IPokestopIncidentDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IPokestopIncidentDisplayProto);
            public character_display?: (POGOProtos.Rpc.ICharacterDisplayProto|null);
            public invasion_finished?: (POGOProtos.Rpc.IInvasionFinishedDisplayProto|null);
            public contest_display?: (POGOProtos.Rpc.IContestDisplayProto|null);
            public incident_id: string;
            public incident_start_ms: (number|Long);
            public incident_expiration_ms: (number|Long);
            public hide_incident: boolean;
            public incident_completed: boolean;
            public incident_display_type: POGOProtos.Rpc.IncidentDisplayType;
            public incident_display_order_priority: number;
            public continue_displaying_incident: boolean;
            public custom_display?: (POGOProtos.Rpc.IPokestopDisplayProto|null);
            public is_cross_stop_incident: boolean;
            public MapDisplay?: ("character_display"|"invasion_finished"|"contest_display");
            public static encode(message: POGOProtos.Rpc.IPokestopIncidentDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokestopIncidentDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokestopIncidentDisplayProto;
            public static toObject(message: POGOProtos.Rpc.PokestopIncidentDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokestopReward {
            item_id?: (POGOProtos.Rpc.Item|null);
            item_count?: (number|null);
        }

        class PokestopReward implements IPokestopReward {
            constructor(properties?: POGOProtos.Rpc.IPokestopReward);
            public item_id: POGOProtos.Rpc.Item;
            public item_count: number;
            public static encode(message: POGOProtos.Rpc.IPokestopReward, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PokestopReward;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PokestopReward;
            public static toObject(message: POGOProtos.Rpc.PokestopReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPolygonProto {
            loop?: (POGOProtos.Rpc.ILoopProto[]|null);
        }

        class PolygonProto implements IPolygonProto {
            constructor(properties?: POGOProtos.Rpc.IPolygonProto);
            public loop: POGOProtos.Rpc.ILoopProto[];
            public static encode(message: POGOProtos.Rpc.IPolygonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PolygonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PolygonProto;
            public static toObject(message: POGOProtos.Rpc.PolygonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPolyline {
            coords?: (number[]|null);
        }

        class Polyline implements IPolyline {
            constructor(properties?: POGOProtos.Rpc.IPolyline);
            public coords: number[];
            public static encode(message: POGOProtos.Rpc.IPolyline, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Polyline;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Polyline;
            public static toObject(message: POGOProtos.Rpc.Polyline, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPolylineList {
            polylines?: (POGOProtos.Rpc.IPolyline[]|null);
        }

        class PolylineList implements IPolylineList {
            constructor(properties?: POGOProtos.Rpc.IPolylineList);
            public polylines: POGOProtos.Rpc.IPolyline[];
            public static encode(message: POGOProtos.Rpc.IPolylineList, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PolylineList;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PolylineList;
            public static toObject(message: POGOProtos.Rpc.PolylineList, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPopupControlSettingsProto {
            popup_control_enabled?: (boolean|null);
            hide_medal_earned_pop_up_until_after_first_pokemon?: (boolean|null);
            hide_aware_of_your_surroundings_popup?: (boolean|null);
            hide_weather_warning_popup?: (boolean|null);
            defer_research_dialog?: (boolean|null);
        }

        class PopupControlSettingsProto implements IPopupControlSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPopupControlSettingsProto);
            public popup_control_enabled: boolean;
            public hide_medal_earned_pop_up_until_after_first_pokemon: boolean;
            public hide_aware_of_your_surroundings_popup: boolean;
            public hide_weather_warning_popup: boolean;
            public defer_research_dialog: boolean;
            public static encode(message: POGOProtos.Rpc.IPopupControlSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PopupControlSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PopupControlSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PopupControlSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPortalCurationImageResult {
        }

        class PortalCurationImageResult implements IPortalCurationImageResult {
            constructor(properties?: POGOProtos.Rpc.IPortalCurationImageResult);
            public static encode(message: POGOProtos.Rpc.IPortalCurationImageResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PortalCurationImageResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PortalCurationImageResult;
            public static toObject(message: POGOProtos.Rpc.PortalCurationImageResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PortalCurationImageResult {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FEATURE_DISABLED = 2,
                ALREADY_UPLOADED = 3,
                IMAGE_NOT_FOUND = 4,
                IMAGE_TOO_BIG = 5,
                IMAGE_NOT_SERVABLE = 6,
                PORTAL_NOT_FOUND = 7
            }
        }

        interface IPose {
            id?: (number|null);
            transform?: (POGOProtos.Rpc.ITransform|null);
        }

        class Pose implements IPose {
            constructor(properties?: POGOProtos.Rpc.IPose);
            public id: number;
            public transform?: (POGOProtos.Rpc.ITransform|null);
            public static encode(message: POGOProtos.Rpc.IPose, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Pose;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Pose;
            public static toObject(message: POGOProtos.Rpc.Pose, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPostStaticNewsfeedRequest {
            app_id?: (string|null);
            newsfeed_post?: (POGOProtos.Rpc.INewsfeedPost|null);
            liquid_attributes?: ({ [k: string]: POGOProtos.Rpc.ILiquidAttribute }|null);
            bucket_name?: (string|null);
            environment_id?: (string|null);
            campaign_id?: (number|Long|null);
        }

        class PostStaticNewsfeedRequest implements IPostStaticNewsfeedRequest {
            constructor(properties?: POGOProtos.Rpc.IPostStaticNewsfeedRequest);
            public app_id: string;
            public newsfeed_post?: (POGOProtos.Rpc.INewsfeedPost|null);
            public liquid_attributes: { [k: string]: POGOProtos.Rpc.ILiquidAttribute };
            public bucket_name: string;
            public environment_id: string;
            public campaign_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPostStaticNewsfeedRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostStaticNewsfeedRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostStaticNewsfeedRequest;
            public static toObject(message: POGOProtos.Rpc.PostStaticNewsfeedRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPostStaticNewsfeedResponse {
            result?: (POGOProtos.Rpc.PostStaticNewsfeedResponse.Result|null);
        }

        class PostStaticNewsfeedResponse implements IPostStaticNewsfeedResponse {
            constructor(properties?: POGOProtos.Rpc.IPostStaticNewsfeedResponse);
            public result: POGOProtos.Rpc.PostStaticNewsfeedResponse.Result;
            public static encode(message: POGOProtos.Rpc.IPostStaticNewsfeedResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostStaticNewsfeedResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostStaticNewsfeedResponse;
            public static toObject(message: POGOProtos.Rpc.PostStaticNewsfeedResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PostStaticNewsfeedResponse {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_POST_TIMESTAMP = 2,
                INVALID_APP_ID = 3,
                INVALID_NEWSFEED_TITLE = 4,
                INVALID_NEWSFEED_CONTENT = 5,
                SEND_FAILED = 6,
                LIQUID_LOGIC_ERROR = 7,
                LIQUID_LOGIC_ABORTED = 8,
                INVALID_ARGUMENTS = 9
            }
        }

        interface IPostcardBookTelemetry {
            interaction_type?: (POGOProtos.Rpc.PostcardBookTelemetry.PostcardBookInteraction|null);
        }

        class PostcardBookTelemetry implements IPostcardBookTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPostcardBookTelemetry);
            public interaction_type: POGOProtos.Rpc.PostcardBookTelemetry.PostcardBookInteraction;
            public static encode(message: POGOProtos.Rpc.IPostcardBookTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostcardBookTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostcardBookTelemetry;
            public static toObject(message: POGOProtos.Rpc.PostcardBookTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PostcardBookTelemetry {

            enum PostcardBookInteraction {
                OPEN = 0
            }
        }

        interface IPostcardCollectionGmtSettingsProto {
            enabled?: (boolean|null);
            background_pattern_name?: (string|null);
            background_pattern_tile_scale?: (number|null);
            postcard_ui_element_color?: (string|null);
            postcard_ui_text_stroke_color?: (string|null);
            postcard_border_name?: (string|null);
        }

        class PostcardCollectionGmtSettingsProto implements IPostcardCollectionGmtSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPostcardCollectionGmtSettingsProto);
            public enabled: boolean;
            public background_pattern_name: string;
            public background_pattern_tile_scale: number;
            public postcard_ui_element_color: string;
            public postcard_ui_text_stroke_color: string;
            public postcard_border_name: string;
            public static encode(message: POGOProtos.Rpc.IPostcardCollectionGmtSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostcardCollectionGmtSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostcardCollectionGmtSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PostcardCollectionGmtSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPostcardCollectionSettingsProto {
            enabled?: (boolean|null);
            max_note_length_in_characters?: (number|null);
            share_trainer_info_by_default?: (boolean|null);
            mass_deletion_enabled?: (boolean|null);
        }

        class PostcardCollectionSettingsProto implements IPostcardCollectionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPostcardCollectionSettingsProto);
            public enabled: boolean;
            public max_note_length_in_characters: number;
            public share_trainer_info_by_default: boolean;
            public mass_deletion_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IPostcardCollectionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostcardCollectionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostcardCollectionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PostcardCollectionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPostcardCreateDetail {
            postcard_origin?: (number|Long|null);
            received_time_ms?: (number|Long|null);
        }

        class PostcardCreateDetail implements IPostcardCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IPostcardCreateDetail);
            public postcard_origin: (number|Long);
            public received_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPostcardCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostcardCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostcardCreateDetail;
            public static toObject(message: POGOProtos.Rpc.PostcardCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPostcardDisplayProto {
            postcard_id?: (string|null);
            fort_id?: (string|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
            creation_timestamp_ms?: (number|Long|null);
            image_url?: (string|null);
            favorite?: (boolean|null);
            postcard_creator_id?: (string|null);
            postcard_creator_nickname?: (string|null);
            sticker_id?: (string[]|null);
            note?: (string|null);
            fort_name?: (string|null);
            postcard_source?: (POGOProtos.Rpc.PostcardSource|null);
            giftbox_id?: (number|Long|null);
            postcard_creator_codename?: (string|null);
            source_giftbox_id?: (number|Long|null);
            is_sponsored?: (boolean|null);
            already_shared?: (boolean|null);
            postcard_creator_nia_account_id?: (string|null);
            received_in_party?: (boolean|null);
            route_id?: (string|null);
            route_name?: (string|null);
        }

        class PostcardDisplayProto implements IPostcardDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IPostcardDisplayProto);
            public postcard_id: string;
            public fort_id: string;
            public fort_lat: number;
            public fort_lng: number;
            public creation_timestamp_ms: (number|Long);
            public image_url: string;
            public favorite: boolean;
            public postcard_creator_id: string;
            public postcard_creator_nickname: string;
            public sticker_id: string[];
            public note: string;
            public fort_name: string;
            public postcard_source: POGOProtos.Rpc.PostcardSource;
            public giftbox_id: (number|Long);
            public postcard_creator_codename: string;
            public source_giftbox_id: (number|Long);
            public is_sponsored: boolean;
            public already_shared: boolean;
            public postcard_creator_nia_account_id: string;
            public received_in_party: boolean;
            public route_id: string;
            public route_name: string;
            public static encode(message: POGOProtos.Rpc.IPostcardDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PostcardDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PostcardDisplayProto;
            public static toObject(message: POGOProtos.Rpc.PostcardDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPotionAttributesProto {
            sta_percent?: (number|null);
            sta_amount?: (number|null);
        }

        class PotionAttributesProto implements IPotionAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IPotionAttributesProto);
            public sta_percent: number;
            public sta_amount: number;
            public static encode(message: POGOProtos.Rpc.IPotionAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PotionAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PotionAttributesProto;
            public static toObject(message: POGOProtos.Rpc.PotionAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPowerUpPokestopEncounterOutProto {
            result?: (POGOProtos.Rpc.PowerUpPokestopEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class PowerUpPokestopEncounterOutProto implements IPowerUpPokestopEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IPowerUpPokestopEncounterOutProto);
            public result: POGOProtos.Rpc.PowerUpPokestopEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IPowerUpPokestopEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PowerUpPokestopEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PowerUpPokestopEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.PowerUpPokestopEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PowerUpPokestopEncounterOutProto {

            enum Result {
                UNKNOWN = 0,
                SUCCESS = 1,
                NOT_AVAILABLE = 2,
                NOT_IN_RANGE = 3,
                ENCOUNTER_ALREADY_FINISHED = 4,
                POKEMON_INVENTORY_FULL = 5
            }
        }

        interface IPowerUpPokestopEncounterProto {
            encounter_id?: (number|Long|null);
            fort_id?: (string|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
        }

        class PowerUpPokestopEncounterProto implements IPowerUpPokestopEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IPowerUpPokestopEncounterProto);
            public encounter_id: (number|Long);
            public fort_id: string;
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IPowerUpPokestopEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PowerUpPokestopEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PowerUpPokestopEncounterProto;
            public static toObject(message: POGOProtos.Rpc.PowerUpPokestopEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPowerUpPokestopsGlobalSettingsProto {
            enable_power_up_pokestops?: (boolean|null);
            minutes_to_notify_before_pokestop_close?: (number|null);
        }

        class PowerUpPokestopsGlobalSettingsProto implements IPowerUpPokestopsGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPowerUpPokestopsGlobalSettingsProto);
            public enable_power_up_pokestops: boolean;
            public minutes_to_notify_before_pokestop_close: number;
            public static encode(message: POGOProtos.Rpc.IPowerUpPokestopsGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PowerUpPokestopsGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PowerUpPokestopsGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PowerUpPokestopsGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPowerUpPokestopsSharedSettingsProto {
            enable_power_up_pokestops?: (boolean|null);
            power_up_pokestops_min_player_level?: (number|null);
            validate_pokestop_on_fort_search_percent?: (number|null);
        }

        class PowerUpPokestopsSharedSettingsProto implements IPowerUpPokestopsSharedSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPowerUpPokestopsSharedSettingsProto);
            public enable_power_up_pokestops: boolean;
            public power_up_pokestops_min_player_level: number;
            public validate_pokestop_on_fort_search_percent: number;
            public static encode(message: POGOProtos.Rpc.IPowerUpPokestopsSharedSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PowerUpPokestopsSharedSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PowerUpPokestopsSharedSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PowerUpPokestopsSharedSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPreAgeGateMetadata {
            timestamp_ms?: (number|Long|null);
            client_timestamp_ms?: (number|Long|null);
            pre_login_user_id?: (string|null);
            minor?: (boolean|null);
            num_starts?: (number|Long|null);
            client_environment?: (POGOProtos.Rpc.IClientEnvironmentProto|null);
            startup_measurement?: (POGOProtos.Rpc.IStartupMeasurementProto|null);
        }

        class PreAgeGateMetadata implements IPreAgeGateMetadata {
            constructor(properties?: POGOProtos.Rpc.IPreAgeGateMetadata);
            public timestamp_ms: (number|Long);
            public client_timestamp_ms: (number|Long);
            public pre_login_user_id: string;
            public minor: boolean;
            public num_starts: (number|Long);
            public client_environment?: (POGOProtos.Rpc.IClientEnvironmentProto|null);
            public startup_measurement?: (POGOProtos.Rpc.IStartupMeasurementProto|null);
            public static encode(message: POGOProtos.Rpc.IPreAgeGateMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PreAgeGateMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PreAgeGateMetadata;
            public static toObject(message: POGOProtos.Rpc.PreAgeGateMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPreLoginMetadata {
            user_id?: (string|null);
            timestamp_ms?: (number|Long|null);
            client_timestamp_ms?: (number|Long|null);
            pre_login_user_id?: (string|null);
            num_starts?: (number|Long|null);
        }

        class PreLoginMetadata implements IPreLoginMetadata {
            constructor(properties?: POGOProtos.Rpc.IPreLoginMetadata);
            public user_id: string;
            public timestamp_ms: (number|Long);
            public client_timestamp_ms: (number|Long);
            public pre_login_user_id: string;
            public num_starts: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPreLoginMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PreLoginMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PreLoginMetadata;
            public static toObject(message: POGOProtos.Rpc.PreLoginMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPrepareBreadLobbyOutProto {
            result?: (POGOProtos.Rpc.PrepareBreadLobbyOutProto.Result|null);
            bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            server_timestamp_ms?: (number|Long|null);
        }

        class PrepareBreadLobbyOutProto implements IPrepareBreadLobbyOutProto {
            constructor(properties?: POGOProtos.Rpc.IPrepareBreadLobbyOutProto);
            public result: POGOProtos.Rpc.PrepareBreadLobbyOutProto.Result;
            public bread_lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            public server_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPrepareBreadLobbyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PrepareBreadLobbyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PrepareBreadLobbyOutProto;
            public static toObject(message: POGOProtos.Rpc.PrepareBreadLobbyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PrepareBreadLobbyOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_FEATURE_DISABLED = 2,
                ERROR_BREAD_LOBBY_NOT_FOUND = 3,
                ERROR_BREAD_BATTLE_UNAVAILABLE = 4,
                ERROR_NOT_ENOUGH_TIME = 5
            }
        }

        interface IPrepareBreadLobbyProto {
            station_id?: (string|null);
            bread_lobby_id?: (number|Long|null);
            bread_battle_entry_point?: (POGOProtos.Rpc.BreadBattleEntryPoint|null);
        }

        class PrepareBreadLobbyProto implements IPrepareBreadLobbyProto {
            constructor(properties?: POGOProtos.Rpc.IPrepareBreadLobbyProto);
            public station_id: string;
            public bread_lobby_id: (number|Long);
            public bread_battle_entry_point: POGOProtos.Rpc.BreadBattleEntryPoint;
            public static encode(message: POGOProtos.Rpc.IPrepareBreadLobbyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PrepareBreadLobbyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PrepareBreadLobbyProto;
            public static toObject(message: POGOProtos.Rpc.PrepareBreadLobbyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPreviewContributePartyItemOutProto {
            result?: (POGOProtos.Rpc.ContributePartyItemResult|null);
            participant_consumption_preview?: (POGOProtos.Rpc.IParticipantConsumptionAccounting[]|null);
            non_consuming_participants?: (string[]|null);
        }

        class PreviewContributePartyItemOutProto implements IPreviewContributePartyItemOutProto {
            constructor(properties?: POGOProtos.Rpc.IPreviewContributePartyItemOutProto);
            public result: POGOProtos.Rpc.ContributePartyItemResult;
            public participant_consumption_preview: POGOProtos.Rpc.IParticipantConsumptionAccounting[];
            public non_consuming_participants: string[];
            public static encode(message: POGOProtos.Rpc.IPreviewContributePartyItemOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PreviewContributePartyItemOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PreviewContributePartyItemOutProto;
            public static toObject(message: POGOProtos.Rpc.PreviewContributePartyItemOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPreviewContributePartyItemProto {
            contributed_items?: (POGOProtos.Rpc.IItemProto[]|null);
            items?: (POGOProtos.Rpc.IItemProto|null);
        }

        class PreviewContributePartyItemProto implements IPreviewContributePartyItemProto {
            constructor(properties?: POGOProtos.Rpc.IPreviewContributePartyItemProto);
            public contributed_items: POGOProtos.Rpc.IItemProto[];
            public items?: (POGOProtos.Rpc.IItemProto|null);
            public static encode(message: POGOProtos.Rpc.IPreviewContributePartyItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PreviewContributePartyItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PreviewContributePartyItemProto;
            public static toObject(message: POGOProtos.Rpc.PreviewContributePartyItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPreviewProto {
            default_cp_range?: (POGOProtos.Rpc.PreviewProto.ICpRange|null);
            buddy_boosted_cp_range?: (POGOProtos.Rpc.PreviewProto.ICpRange|null);
            evolving_pokemon_default_cp?: (number|null);
            evolving_pokemon_buddy_boosted_cp?: (number|null);
        }

        class PreviewProto implements IPreviewProto {
            constructor(properties?: POGOProtos.Rpc.IPreviewProto);
            public default_cp_range?: (POGOProtos.Rpc.PreviewProto.ICpRange|null);
            public buddy_boosted_cp_range?: (POGOProtos.Rpc.PreviewProto.ICpRange|null);
            public evolving_pokemon_default_cp: number;
            public evolving_pokemon_buddy_boosted_cp: number;
            public static encode(message: POGOProtos.Rpc.IPreviewProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PreviewProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PreviewProto;
            public static toObject(message: POGOProtos.Rpc.PreviewProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PreviewProto {

            interface ICpRange {
                min_cp?: (number|null);
                max_cp?: (number|null);
            }

            class CpRange implements ICpRange {
                constructor(properties?: POGOProtos.Rpc.PreviewProto.ICpRange);
                public min_cp: number;
                public max_cp: number;
                public static encode(message: POGOProtos.Rpc.PreviewProto.ICpRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PreviewProto.CpRange;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PreviewProto.CpRange;
                public static toObject(message: POGOProtos.Rpc.PreviewProto.CpRange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPrimalBoostTypeProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            boost_type?: (POGOProtos.Rpc.HoloPokemonType[]|null);
        }

        class PrimalBoostTypeProto implements IPrimalBoostTypeProto {
            constructor(properties?: POGOProtos.Rpc.IPrimalBoostTypeProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public boost_type: POGOProtos.Rpc.HoloPokemonType[];
            public static encode(message: POGOProtos.Rpc.IPrimalBoostTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PrimalBoostTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PrimalBoostTypeProto;
            public static toObject(message: POGOProtos.Rpc.PrimalBoostTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPrimalEvoSettingsProto {
            common_temp_settings?: (POGOProtos.Rpc.ICommonTempEvoSettingsProto|null);
            max_candy_hoard_size?: (number|null);
            type_boosts?: (POGOProtos.Rpc.IPrimalBoostTypeProto[]|null);
        }

        class PrimalEvoSettingsProto implements IPrimalEvoSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPrimalEvoSettingsProto);
            public common_temp_settings?: (POGOProtos.Rpc.ICommonTempEvoSettingsProto|null);
            public max_candy_hoard_size: number;
            public type_boosts: POGOProtos.Rpc.IPrimalBoostTypeProto[];
            public static encode(message: POGOProtos.Rpc.IPrimalEvoSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PrimalEvoSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PrimalEvoSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PrimalEvoSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProbeProto {
            id?: (string|null);
            payload?: (string|null);
        }

        class ProbeProto implements IProbeProto {
            constructor(properties?: POGOProtos.Rpc.IProbeProto);
            public id: string;
            public payload: string;
            public static encode(message: POGOProtos.Rpc.IProbeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProbeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProbeProto;
            public static toObject(message: POGOProtos.Rpc.ProbeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProbeSettingsProto {
            enable_sidechannel?: (boolean|null);
            enable_adhoc?: (boolean|null);
            adhoc_frequency_sec?: (number|null);
        }

        class ProbeSettingsProto implements IProbeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IProbeSettingsProto);
            public enable_sidechannel: boolean;
            public enable_adhoc: boolean;
            public adhoc_frequency_sec: number;
            public static encode(message: POGOProtos.Rpc.IProbeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProbeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProbeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ProbeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProcessPlayerInboxOutProto {
        }

        class ProcessPlayerInboxOutProto implements IProcessPlayerInboxOutProto {
            constructor(properties?: POGOProtos.Rpc.IProcessPlayerInboxOutProto);
            public static encode(message: POGOProtos.Rpc.IProcessPlayerInboxOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProcessPlayerInboxOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProcessPlayerInboxOutProto;
            public static toObject(message: POGOProtos.Rpc.ProcessPlayerInboxOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProcessPlayerInboxProto {
        }

        class ProcessPlayerInboxProto implements IProcessPlayerInboxProto {
            constructor(properties?: POGOProtos.Rpc.IProcessPlayerInboxProto);
            public static encode(message: POGOProtos.Rpc.IProcessPlayerInboxProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProcessPlayerInboxProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProcessPlayerInboxProto;
            public static toObject(message: POGOProtos.Rpc.ProcessPlayerInboxProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProcessTappableLogEntry {
            tappable_type_id?: (string|null);
            loot?: (POGOProtos.Rpc.ILootProto|null);
        }

        class ProcessTappableLogEntry implements IProcessTappableLogEntry {
            constructor(properties?: POGOProtos.Rpc.IProcessTappableLogEntry);
            public tappable_type_id: string;
            public loot?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IProcessTappableLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProcessTappableLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProcessTappableLogEntry;
            public static toObject(message: POGOProtos.Rpc.ProcessTappableLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProcessTappableOutProto {
            status?: (POGOProtos.Rpc.ProcessTappableOutProto.Status|null);
            reward?: (POGOProtos.Rpc.ILootProto[]|null);
            encounter?: (POGOProtos.Rpc.ITappableEncounterProto|null);
        }

        class ProcessTappableOutProto implements IProcessTappableOutProto {
            constructor(properties?: POGOProtos.Rpc.IProcessTappableOutProto);
            public status: POGOProtos.Rpc.ProcessTappableOutProto.Status;
            public reward: POGOProtos.Rpc.ILootProto[];
            public encounter?: (POGOProtos.Rpc.ITappableEncounterProto|null);
            public static encode(message: POGOProtos.Rpc.IProcessTappableOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProcessTappableOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProcessTappableOutProto;
            public static toObject(message: POGOProtos.Rpc.ProcessTappableOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ProcessTappableOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_FOUND = 2,
                ERROR_ROUTE = 3,
                ERROR_NOT_IN_RANGE = 4
            }
        }

        interface IProcessTappableProto {
            id?: (number[]|null);
            location?: (POGOProtos.Rpc.ITappableLocation|null);
            tappable_type_id?: (string|null);
            encounter_id?: (number|Long|null);
            location_hint_lat?: (number|null);
            location_hint_lng?: (number|null);
        }

        class ProcessTappableProto implements IProcessTappableProto {
            constructor(properties?: POGOProtos.Rpc.IProcessTappableProto);
            public id: number[];
            public location?: (POGOProtos.Rpc.ITappableLocation|null);
            public tappable_type_id: string;
            public encounter_id: (number|Long);
            public location_hint_lat: number;
            public location_hint_lng: number;
            public static encode(message: POGOProtos.Rpc.IProcessTappableProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProcessTappableProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProcessTappableProto;
            public static toObject(message: POGOProtos.Rpc.ProcessTappableProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProfanityCheckOutProto {
            result?: (POGOProtos.Rpc.ProfanityCheckOutProto.Result|null);
            invalid_contents_indexes?: (number[]|null);
        }

        class ProfanityCheckOutProto implements IProfanityCheckOutProto {
            constructor(properties?: POGOProtos.Rpc.IProfanityCheckOutProto);
            public result: POGOProtos.Rpc.ProfanityCheckOutProto.Result;
            public invalid_contents_indexes: number[];
            public static encode(message: POGOProtos.Rpc.IProfanityCheckOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProfanityCheckOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProfanityCheckOutProto;
            public static toObject(message: POGOProtos.Rpc.ProfanityCheckOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ProfanityCheckOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IProfanityCheckProto {
            contents?: (string[]|null);
            accept_author_only?: (boolean|null);
        }

        class ProfanityCheckProto implements IProfanityCheckProto {
            constructor(properties?: POGOProtos.Rpc.IProfanityCheckProto);
            public contents: string[];
            public accept_author_only: boolean;
            public static encode(message: POGOProtos.Rpc.IProfanityCheckProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProfanityCheckProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProfanityCheckProto;
            public static toObject(message: POGOProtos.Rpc.ProfanityCheckProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProfilePageTelemetry {
            profile_page_click_id?: (POGOProtos.Rpc.ProfilePageTelemetryIds|null);
        }

        class ProfilePageTelemetry implements IProfilePageTelemetry {
            constructor(properties?: POGOProtos.Rpc.IProfilePageTelemetry);
            public profile_page_click_id: POGOProtos.Rpc.ProfilePageTelemetryIds;
            public static encode(message: POGOProtos.Rpc.IProfilePageTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProfilePageTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProfilePageTelemetry;
            public static toObject(message: POGOProtos.Rpc.ProfilePageTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProgressQuestOutProto {
            status?: (POGOProtos.Rpc.ProgressQuestOutProto.Status|null);
            quest?: (POGOProtos.Rpc.IClientQuestProto|null);
        }

        class ProgressQuestOutProto implements IProgressQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.IProgressQuestOutProto);
            public status: POGOProtos.Rpc.ProgressQuestOutProto.Status;
            public quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            public static encode(message: POGOProtos.Rpc.IProgressQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProgressQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProgressQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.ProgressQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ProgressQuestOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_QUEST_NOT_FOUND = 2,
                ERROR_EXCEEDED_GEOTARGETED_SUBMISSION_LIMIT = 3,
                ERROR_VALIDATION_FAILED = 4
            }
        }

        interface IProgressQuestProto {
            geotargeted_quest_validation?: (POGOProtos.Rpc.IGeotargetedQuestValidation|null);
            quest_id?: (string|null);
            current_progress?: (number|null);
        }

        class ProgressQuestProto implements IProgressQuestProto {
            constructor(properties?: POGOProtos.Rpc.IProgressQuestProto);
            public geotargeted_quest_validation?: (POGOProtos.Rpc.IGeotargetedQuestValidation|null);
            public quest_id: string;
            public current_progress: number;
            public Validation?: "geotargeted_quest_validation";
            public static encode(message: POGOProtos.Rpc.IProgressQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProgressQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProgressQuestProto;
            public static toObject(message: POGOProtos.Rpc.ProgressQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProgressRouteOutProto {
            progression_state?: (POGOProtos.Rpc.ProgressRouteOutProto.ProgressionState|null);
            status?: (POGOProtos.Rpc.RoutePlayStatus.Status|null);
            route_play?: (POGOProtos.Rpc.IRoutePlayProto|null);
            activity_output?: (POGOProtos.Rpc.IRouteActivityResponseProto|null);
            cooldown_finish_ms?: (number|Long|null);
            route_loot?: (POGOProtos.Rpc.ILootProto|null);
            awarded_route_badge?: (POGOProtos.Rpc.IAwardedRouteBadge|null);
            bonus_route_loot?: (POGOProtos.Rpc.ILootProto|null);
        }

        class ProgressRouteOutProto implements IProgressRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.IProgressRouteOutProto);
            public progression_state: POGOProtos.Rpc.ProgressRouteOutProto.ProgressionState;
            public status: POGOProtos.Rpc.RoutePlayStatus.Status;
            public route_play?: (POGOProtos.Rpc.IRoutePlayProto|null);
            public activity_output?: (POGOProtos.Rpc.IRouteActivityResponseProto|null);
            public cooldown_finish_ms: (number|Long);
            public route_loot?: (POGOProtos.Rpc.ILootProto|null);
            public awarded_route_badge?: (POGOProtos.Rpc.IAwardedRouteBadge|null);
            public bonus_route_loot?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IProgressRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProgressRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProgressRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.ProgressRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ProgressRouteOutProto {

            enum ProgressionState {
                UNSET = 0,
                IN_PROGRESS = 1,
                COMPLETE = 2
            }
        }

        interface IProgressRouteProto {
            pause?: (boolean|null);
            waypoint_index?: (number|null);
            skip_activity?: (boolean|null);
            activity_type?: (POGOProtos.Rpc.RouteActivityType.ActivityType|null);
            activity_input?: (POGOProtos.Rpc.IRouteActivityRequestProto|null);
            acquire_reward?: (boolean|null);
        }

        class ProgressRouteProto implements IProgressRouteProto {
            constructor(properties?: POGOProtos.Rpc.IProgressRouteProto);
            public pause?: (boolean|null);
            public waypoint_index: number;
            public skip_activity: boolean;
            public activity_type: POGOProtos.Rpc.RouteActivityType.ActivityType;
            public activity_input?: (POGOProtos.Rpc.IRouteActivityRequestProto|null);
            public acquire_reward: boolean;
            public NullablePause?: "pause";
            public static encode(message: POGOProtos.Rpc.IProgressRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProgressRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProgressRouteProto;
            public static toObject(message: POGOProtos.Rpc.ProgressRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProgressTokenData {
            gym_root_controller_function?: (POGOProtos.Rpc.ProgressTokenData.GymRootControllerFunction|null);
            raid_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidStateFunction|null);
            raid_lobby_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidLobbyStateFunction|null);
            raid_lobby_gui_controller_function?: (POGOProtos.Rpc.ProgressTokenData.RaidLobbyGuiControllerFunction|null);
            raid_battle_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidBattleStateFunction|null);
            raid_resolve_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidResolveStateFunction|null);
            raid_resolve_uicontroller_function?: (POGOProtos.Rpc.ProgressTokenData.RaidResolveUIControllerFunction|null);
            encounter_state_function?: (POGOProtos.Rpc.ProgressTokenData.EncounterStateFunction|null);
            map_explore_state_function?: (POGOProtos.Rpc.ProgressTokenData.MapExploreStateFunction|null);
            line_number?: (number|null);
        }

        class ProgressTokenData implements IProgressTokenData {
            constructor(properties?: POGOProtos.Rpc.IProgressTokenData);
            public gym_root_controller_function?: (POGOProtos.Rpc.ProgressTokenData.GymRootControllerFunction|null);
            public raid_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidStateFunction|null);
            public raid_lobby_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidLobbyStateFunction|null);
            public raid_lobby_gui_controller_function?: (POGOProtos.Rpc.ProgressTokenData.RaidLobbyGuiControllerFunction|null);
            public raid_battle_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidBattleStateFunction|null);
            public raid_resolve_state_function?: (POGOProtos.Rpc.ProgressTokenData.RaidResolveStateFunction|null);
            public raid_resolve_uicontroller_function?: (POGOProtos.Rpc.ProgressTokenData.RaidResolveUIControllerFunction|null);
            public encounter_state_function?: (POGOProtos.Rpc.ProgressTokenData.EncounterStateFunction|null);
            public map_explore_state_function?: (POGOProtos.Rpc.ProgressTokenData.MapExploreStateFunction|null);
            public line_number: number;
            public Token?: ("gym_root_controller_function"|"raid_state_function"|"raid_lobby_state_function"|"raid_lobby_gui_controller_function"|"raid_battle_state_function"|"raid_resolve_state_function"|"raid_resolve_uicontroller_function"|"encounter_state_function"|"map_explore_state_function");
            public static encode(message: POGOProtos.Rpc.IProgressTokenData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProgressTokenData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProgressTokenData;
            public static toObject(message: POGOProtos.Rpc.ProgressTokenData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ProgressTokenData {

            enum EncounterStateFunction {
                NONE_ENCOUNTER_STATE = 0,
                SETUP_ENCOUNTER = 1,
                BEGIN_ENCOUNTER_APPROACH = 2,
                ENCOUNTER_STATE_COMPLETE = 3,
                EXIT_ENCOUNTER_STATE = 4
            }

            enum GymRootControllerFunction {
                NONE_GYM_GYM_ROOT_CONTROLLER = 0,
                EXIT_GYM_GYM_ROOT_CONTROLLER = 1
            }

            enum MapExploreStateFunction {
                NONE_MAP_EXPLORE_STATE = 0,
                GYM_ROOT_COMPLETE = 1
            }

            enum RaidBattleStateFunction {
                NONE_RAID_BATTLE_STATE = 0,
                ENTER_RAID_BATTLE_STATE = 1,
                EXIT_RAID_BATTLE_STATE = 2,
                OBSERVE_BATTLE_FRAMES = 3,
                START_RAID_BATTLE = 4,
                START_RAID_BATTLE_WHEN_READY = 5,
                END_BATTLE_WHEN_READY = 6,
                GET_RAID_BOSS_PROTO = 7
            }

            enum RaidLobbyGuiControllerFunction {
                NONE_RAID_LOBBY_GUI_CONTROLLER = 0,
                INIT_RAID_LOBBY_GUI_CONTROLLER = 1,
                SET_DEPENDANT_VISUALS = 2,
                START_LOBBY_INTRO = 3,
                LOBBY_INTRO = 4,
                ON_LOBBY_INTRO_COMPLETE = 5,
                SHOW_BATTLE_PREP_GUI = 6,
                HANDLE_DISMISS_COMPLETE = 7,
                START_TIMEOUT_SCREEN = 8,
                REJOIN_BATTLE = 9,
                UPDATE_AVATARS = 10,
                START_POLLING_GET_RAID_DETAILS = 11,
                PLAY_BATTLE_INTRO = 12,
                LEAVE_LOBBY = 13,
                ON_POKEMON_INVENTORY_OPENED = 14,
                ON_CLICK_INVENTORY = 15,
                ON_TAP = 16,
                HANDLE_RAID_BATTLE_COMPLETE = 17
            }

            enum RaidLobbyStateFunction {
                NONE_RAID_LOBBY_STATE = 0,
                ENTER_RAID_LOBBY_STATE = 1,
                EXIT_RAID_LOBBY_STATE = 2,
                CREATE_LOBBY = 3,
                CREATE_LOBBY_FOR_REAL = 4,
                START_RAID_BATTLE_STATE = 5,
                CANCEL_RAID_BATTLE_TRANSITION = 6
            }

            enum RaidResolveStateFunction {
                NONE_RAID_RESOLVE_STATE = 0,
                ENTER_RAID_RESOLVE_STATE = 1,
                EXIT_RAID_RESOLVE_STATE = 2,
                INIT_RAID_RESOLVE_STATE = 3
            }

            enum RaidResolveUIControllerFunction {
                NONE_RAID_RESOLVE_UI_CONTROLLER = 0,
                INIT_RAID_RESOLVE_UI_CONTROLLER = 1,
                CLOSE_RAID_RESOLVE_UI_CONTROLLER = 2
            }

            enum RaidStateFunction {
                NONE_RAID_STATE = 0,
                EXIT_GYM_RAID_STATE = 1
            }
        }

        interface IProjectVacationProto {
            enable2020?: (boolean|null);
        }

        class ProjectVacationProto implements IProjectVacationProto {
            constructor(properties?: POGOProtos.Rpc.IProjectVacationProto);
            public enable2020: boolean;
            public static encode(message: POGOProtos.Rpc.IProjectVacationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProjectVacationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProjectVacationProto;
            public static toObject(message: POGOProtos.Rpc.ProjectVacationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProximityContact {
            proximity_token?: (POGOProtos.Rpc.IProximityToken|null);
            timestamp_ms?: (number|Long|null);
            latitude_deg?: (number|null);
            longitude_deg?: (number|null);
        }

        class ProximityContact implements IProximityContact {
            constructor(properties?: POGOProtos.Rpc.IProximityContact);
            public proximity_token?: (POGOProtos.Rpc.IProximityToken|null);
            public timestamp_ms: (number|Long);
            public latitude_deg: number;
            public longitude_deg: number;
            public static encode(message: POGOProtos.Rpc.IProximityContact, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProximityContact;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProximityContact;
            public static toObject(message: POGOProtos.Rpc.ProximityContact, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProximityToken {
            token?: (Uint8Array|null);
            start_time_ms?: (number|Long|null);
            expiration_time_ms?: (number|Long|null);
            iv?: (Uint8Array|null);
        }

        class ProximityToken implements IProximityToken {
            constructor(properties?: POGOProtos.Rpc.IProximityToken);
            public token: Uint8Array;
            public start_time_ms: (number|Long);
            public expiration_time_ms: (number|Long);
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IProximityToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProximityToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProximityToken;
            public static toObject(message: POGOProtos.Rpc.ProximityToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProximityTokenInternal {
            player_id?: (string|null);
            start_time_ms?: (number|Long|null);
            expiration_time_ms?: (number|Long|null);
        }

        class ProximityTokenInternal implements IProximityTokenInternal {
            constructor(properties?: POGOProtos.Rpc.IProximityTokenInternal);
            public player_id: string;
            public start_time_ms: (number|Long);
            public expiration_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IProximityTokenInternal, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProximityTokenInternal;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProximityTokenInternal;
            public static toObject(message: POGOProtos.Rpc.ProximityTokenInternal, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProxyRequestProto {
            action?: (number|null);
            host?: (string|null);
            payload?: (Uint8Array|null);
        }

        class ProxyRequestProto implements IProxyRequestProto {
            constructor(properties?: POGOProtos.Rpc.IProxyRequestProto);
            public action: number;
            public host: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IProxyRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProxyRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProxyRequestProto;
            public static toObject(message: POGOProtos.Rpc.ProxyRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IProxyResponseProto {
            status?: (POGOProtos.Rpc.ProxyResponseProto.Status|null);
            assigned_host?: (string|null);
            payload?: (Uint8Array|null);
        }

        class ProxyResponseProto implements IProxyResponseProto {
            constructor(properties?: POGOProtos.Rpc.IProxyResponseProto);
            public status: POGOProtos.Rpc.ProxyResponseProto.Status;
            public assigned_host: string;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IProxyResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ProxyResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ProxyResponseProto;
            public static toObject(message: POGOProtos.Rpc.ProxyResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ProxyResponseProto {

            enum Status {
                UNSET = 0,
                COMPLETED = 1,
                COMPLETED_AND_REASSIGNED = 2,
                ACTION_NOT_FOUND = 3,
                ASSIGNMENT_ERROR = 4,
                PROXY_UNAUTHORIZED_ERROR = 5,
                INTERNAL_ERROR = 6,
                BAD_REQUEST = 7,
                ACCESS_DENIED = 8,
                TIMEOUT_ERROR = 9,
                RATE_LIMITED = 10
            }
        }

        interface IPtcOAuthSettingsProto {
            ptc_account_linking_enabled?: (boolean|null);
            validation_enabled?: (boolean|null);
            end_time_ms?: (number|Long|null);
            linking_reward_item?: (POGOProtos.Rpc.Item|null);
        }

        class PtcOAuthSettingsProto implements IPtcOAuthSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPtcOAuthSettingsProto);
            public ptc_account_linking_enabled: boolean;
            public validation_enabled: boolean;
            public end_time_ms: (number|Long);
            public linking_reward_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IPtcOAuthSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PtcOAuthSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PtcOAuthSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PtcOAuthSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPtcOAuthToken {
            access_code?: (string|null);
            refresh_token?: (string|null);
            access_token_expiration_ms?: (number|Long|null);
        }

        class PtcOAuthToken implements IPtcOAuthToken {
            constructor(properties?: POGOProtos.Rpc.IPtcOAuthToken);
            public access_code: string;
            public refresh_token: string;
            public access_token_expiration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPtcOAuthToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PtcOAuthToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PtcOAuthToken;
            public static toObject(message: POGOProtos.Rpc.PtcOAuthToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPtcToken {
            token?: (string|null);
            expiration?: (number|null);
        }

        class PtcToken implements IPtcToken {
            constructor(properties?: POGOProtos.Rpc.IPtcToken);
            public token: string;
            public expiration: number;
            public static encode(message: POGOProtos.Rpc.IPtcToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PtcToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PtcToken;
            public static toObject(message: POGOProtos.Rpc.PtcToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPurifyPokemonLogEntry {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            purified_pokemon_uuid?: (number|Long|null);
        }

        class PurifyPokemonLogEntry implements IPurifyPokemonLogEntry {
            constructor(properties?: POGOProtos.Rpc.IPurifyPokemonLogEntry);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public purified_pokemon_uuid: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPurifyPokemonLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PurifyPokemonLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PurifyPokemonLogEntry;
            public static toObject(message: POGOProtos.Rpc.PurifyPokemonLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPurifyPokemonOutProto {
            status?: (POGOProtos.Rpc.PurifyPokemonOutProto.Status|null);
            purified_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class PurifyPokemonOutProto implements IPurifyPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IPurifyPokemonOutProto);
            public status: POGOProtos.Rpc.PurifyPokemonOutProto.Status;
            public purified_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IPurifyPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PurifyPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PurifyPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.PurifyPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PurifyPokemonOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INSUFFICIENT_FUNDS = 3,
                ERROR_POKEMON_DEPLOYED = 4,
                ERROR_POKEMON_NOT_FOUND = 5,
                ERROR_POKEMON_NOT_SHADOW = 6
            }
        }

        interface IPurifyPokemonProto {
            pokemon_id?: (number|Long|null);
        }

        class PurifyPokemonProto implements IPurifyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IPurifyPokemonProto);
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPurifyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PurifyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PurifyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.PurifyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPushGatewayGlobalSettingsProto {
            enable_websocket?: (boolean|null);
            enable_social_inbox?: (boolean|null);
            messaging_frontend_url?: (string|null);
            enable_get_map_objects?: (boolean|null);
            get_map_objects_s2_level?: (number|null);
            get_map_objects_radius_meters?: (number|null);
            get_map_objects_topic_namespace?: (string|null);
            get_map_objects_subscribe_min_interval_ms?: (number|null);
            boot_raid_update_namespace?: (string|null);
        }

        class PushGatewayGlobalSettingsProto implements IPushGatewayGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IPushGatewayGlobalSettingsProto);
            public enable_websocket: boolean;
            public enable_social_inbox: boolean;
            public messaging_frontend_url: string;
            public enable_get_map_objects: boolean;
            public get_map_objects_s2_level: number;
            public get_map_objects_radius_meters: number;
            public get_map_objects_topic_namespace: string;
            public get_map_objects_subscribe_min_interval_ms: number;
            public boot_raid_update_namespace: string;
            public static encode(message: POGOProtos.Rpc.IPushGatewayGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.PushGatewayGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPushGatewayMessage {
            map_objects_update?: (POGOProtos.Rpc.PushGatewayMessage.IMapObjectsUpdate|null);
            raid_lobby_player_count?: (POGOProtos.Rpc.IRaidLobbyCounterData|null);
            boot_raid_update?: (POGOProtos.Rpc.PushGatewayMessage.IBootRaidUpdate|null);
            party_play_proto?: (POGOProtos.Rpc.IPartyRpcProto|null);
            party_update?: (POGOProtos.Rpc.PushGatewayMessage.IPartyUpdate|null);
            raid_participant_proto?: (POGOProtos.Rpc.IRaidParticipantProto|null);
            iris_social_update?: (POGOProtos.Rpc.PushGatewayMessage.IIrisSocialUpdate|null);
            bread_lobby_player_count?: (POGOProtos.Rpc.IBreadLobbyCounterData|null);
            friend_raid_lobby_player_count?: (POGOProtos.Rpc.PushGatewayMessage.IFriendRaidLobbyCountUpdate|null);
            rsvp_player_count?: (POGOProtos.Rpc.PushGatewayMessage.IRsvpCountUpdate|null);
            message_pub_timestamp_ms?: (number|Long|null);
        }

        class PushGatewayMessage implements IPushGatewayMessage {
            constructor(properties?: POGOProtos.Rpc.IPushGatewayMessage);
            public map_objects_update?: (POGOProtos.Rpc.PushGatewayMessage.IMapObjectsUpdate|null);
            public raid_lobby_player_count?: (POGOProtos.Rpc.IRaidLobbyCounterData|null);
            public boot_raid_update?: (POGOProtos.Rpc.PushGatewayMessage.IBootRaidUpdate|null);
            public party_play_proto?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public party_update?: (POGOProtos.Rpc.PushGatewayMessage.IPartyUpdate|null);
            public raid_participant_proto?: (POGOProtos.Rpc.IRaidParticipantProto|null);
            public iris_social_update?: (POGOProtos.Rpc.PushGatewayMessage.IIrisSocialUpdate|null);
            public bread_lobby_player_count?: (POGOProtos.Rpc.IBreadLobbyCounterData|null);
            public friend_raid_lobby_player_count?: (POGOProtos.Rpc.PushGatewayMessage.IFriendRaidLobbyCountUpdate|null);
            public rsvp_player_count?: (POGOProtos.Rpc.PushGatewayMessage.IRsvpCountUpdate|null);
            public message_pub_timestamp_ms: (number|Long);
            public Message?: ("map_objects_update"|"raid_lobby_player_count"|"boot_raid_update"|"party_play_proto"|"party_update"|"raid_participant_proto"|"iris_social_update"|"bread_lobby_player_count"|"friend_raid_lobby_player_count"|"rsvp_player_count");
            public static encode(message: POGOProtos.Rpc.IPushGatewayMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage;
            public static toObject(message: POGOProtos.Rpc.PushGatewayMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PushGatewayMessage {

            interface IFriendRaidLobbyCountUpdate {
                raid_lobby_count?: (number|null);
                fort_id?: (string|null);
            }

            class FriendRaidLobbyCountUpdate implements IFriendRaidLobbyCountUpdate {
                constructor(properties?: POGOProtos.Rpc.PushGatewayMessage.IFriendRaidLobbyCountUpdate);
                public raid_lobby_count: number;
                public fort_id: string;
                public static encode(message: POGOProtos.Rpc.PushGatewayMessage.IFriendRaidLobbyCountUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage.FriendRaidLobbyCountUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage.FriendRaidLobbyCountUpdate;
                public static toObject(message: POGOProtos.Rpc.PushGatewayMessage.FriendRaidLobbyCountUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IIrisSocialUpdate {
                has_pokemon_placement_updates?: (boolean|null);
                pokemon_expression_update?: (POGOProtos.Rpc.IPokemonExpressionUpdateProto|null);
            }

            class IrisSocialUpdate implements IIrisSocialUpdate {
                constructor(properties?: POGOProtos.Rpc.PushGatewayMessage.IIrisSocialUpdate);
                public has_pokemon_placement_updates?: (boolean|null);
                public pokemon_expression_update?: (POGOProtos.Rpc.IPokemonExpressionUpdateProto|null);
                public IrisUpdateData?: ("has_pokemon_placement_updates"|"pokemon_expression_update");
                public static encode(message: POGOProtos.Rpc.PushGatewayMessage.IIrisSocialUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage.IrisSocialUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage.IrisSocialUpdate;
                public static toObject(message: POGOProtos.Rpc.PushGatewayMessage.IrisSocialUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBootRaidUpdate {
                player_join_end_ms?: (number|Long|null);
            }

            class BootRaidUpdate implements IBootRaidUpdate {
                constructor(properties?: POGOProtos.Rpc.PushGatewayMessage.IBootRaidUpdate);
                public player_join_end_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.PushGatewayMessage.IBootRaidUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage.BootRaidUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage.BootRaidUpdate;
                public static toObject(message: POGOProtos.Rpc.PushGatewayMessage.BootRaidUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMapObjectsUpdate {
            }

            class MapObjectsUpdate implements IMapObjectsUpdate {
                constructor(properties?: POGOProtos.Rpc.PushGatewayMessage.IMapObjectsUpdate);
                public static encode(message: POGOProtos.Rpc.PushGatewayMessage.IMapObjectsUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage.MapObjectsUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage.MapObjectsUpdate;
                public static toObject(message: POGOProtos.Rpc.PushGatewayMessage.MapObjectsUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPartyUpdate {
                party_play_proto?: (POGOProtos.Rpc.IPartyRpcProto|null);
                location?: (POGOProtos.Rpc.IPartyLocationPushProto|null);
                zone?: (POGOProtos.Rpc.IPartyZonePushProto|null);
                has_party_update?: (boolean|null);
                player_profile?: (POGOProtos.Rpc.IPartyPlayerProfilePushProto|null);
                joined_player_obfuscation_map?: (POGOProtos.Rpc.IJoinedPlayerObfuscationMapProto|null);
                party_id?: (number|Long|null);
                party_seed?: (number|Long|null);
            }

            class PartyUpdate implements IPartyUpdate {
                constructor(properties?: POGOProtos.Rpc.PushGatewayMessage.IPartyUpdate);
                public party_play_proto?: (POGOProtos.Rpc.IPartyRpcProto|null);
                public location?: (POGOProtos.Rpc.IPartyLocationPushProto|null);
                public zone?: (POGOProtos.Rpc.IPartyZonePushProto|null);
                public has_party_update?: (boolean|null);
                public player_profile?: (POGOProtos.Rpc.IPartyPlayerProfilePushProto|null);
                public joined_player_obfuscation_map?: (POGOProtos.Rpc.IJoinedPlayerObfuscationMapProto|null);
                public party_id: (number|Long);
                public party_seed: (number|Long);
                public PartyUpdateType?: ("party_play_proto"|"location"|"zone"|"has_party_update"|"player_profile");
                public static encode(message: POGOProtos.Rpc.PushGatewayMessage.IPartyUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage.PartyUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage.PartyUpdate;
                public static toObject(message: POGOProtos.Rpc.PushGatewayMessage.PartyUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRsvpCountUpdate {
                rsvp_count?: (number|null);
                map_place_id?: (string|null);
            }

            class RsvpCountUpdate implements IRsvpCountUpdate {
                constructor(properties?: POGOProtos.Rpc.PushGatewayMessage.IRsvpCountUpdate);
                public rsvp_count: number;
                public map_place_id: string;
                public static encode(message: POGOProtos.Rpc.PushGatewayMessage.IRsvpCountUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayMessage.RsvpCountUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayMessage.RsvpCountUpdate;
                public static toObject(message: POGOProtos.Rpc.PushGatewayMessage.RsvpCountUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPushGatewayTelemetry {
            push_gateway_telemetry_id?: (POGOProtos.Rpc.PushGatewayTelemetryIds|null);
        }

        class PushGatewayTelemetry implements IPushGatewayTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPushGatewayTelemetry);
            public push_gateway_telemetry_id: POGOProtos.Rpc.PushGatewayTelemetryIds;
            public static encode(message: POGOProtos.Rpc.IPushGatewayTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayTelemetry;
            public static toObject(message: POGOProtos.Rpc.PushGatewayTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPushGatewayUpstreamErrorTelemetry {
            upstream_response_status?: (number|null);
            token_expire_timestamp?: (number|Long|null);
            client_timestamp?: (number|Long|null);
            server_timestamp?: (number|Long|null);
        }

        class PushGatewayUpstreamErrorTelemetry implements IPushGatewayUpstreamErrorTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPushGatewayUpstreamErrorTelemetry);
            public upstream_response_status: number;
            public token_expire_timestamp: (number|Long);
            public client_timestamp: (number|Long);
            public server_timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPushGatewayUpstreamErrorTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushGatewayUpstreamErrorTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushGatewayUpstreamErrorTelemetry;
            public static toObject(message: POGOProtos.Rpc.PushGatewayUpstreamErrorTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPushNotificationRegistryOutProto {
            result?: (POGOProtos.Rpc.PushNotificationRegistryOutProto.Result|null);
        }

        class PushNotificationRegistryOutProto implements IPushNotificationRegistryOutProto {
            constructor(properties?: POGOProtos.Rpc.IPushNotificationRegistryOutProto);
            public result: POGOProtos.Rpc.PushNotificationRegistryOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IPushNotificationRegistryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushNotificationRegistryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushNotificationRegistryOutProto;
            public static toObject(message: POGOProtos.Rpc.PushNotificationRegistryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PushNotificationRegistryOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_CHANGE = 2
            }
        }

        interface IPushNotificationRegistryProto {
            apn_token?: (POGOProtos.Rpc.IApnToken|null);
            gcm_token?: (POGOProtos.Rpc.IGcmToken|null);
        }

        class PushNotificationRegistryProto implements IPushNotificationRegistryProto {
            constructor(properties?: POGOProtos.Rpc.IPushNotificationRegistryProto);
            public apn_token?: (POGOProtos.Rpc.IApnToken|null);
            public gcm_token?: (POGOProtos.Rpc.IGcmToken|null);
            public static encode(message: POGOProtos.Rpc.IPushNotificationRegistryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushNotificationRegistryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushNotificationRegistryProto;
            public static toObject(message: POGOProtos.Rpc.PushNotificationRegistryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPushNotificationTelemetry {
            notification_id?: (POGOProtos.Rpc.PushNotificationTelemetryIds|null);
            category?: (string|null);
            template_id?: (string|null);
            open_time_ms?: (number|Long|null);
        }

        class PushNotificationTelemetry implements IPushNotificationTelemetry {
            constructor(properties?: POGOProtos.Rpc.IPushNotificationTelemetry);
            public notification_id: POGOProtos.Rpc.PushNotificationTelemetryIds;
            public category: string;
            public template_id: string;
            public open_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IPushNotificationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PushNotificationTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PushNotificationTelemetry;
            public static toObject(message: POGOProtos.Rpc.PushNotificationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPvpBattleDetailProto {
            character?: (POGOProtos.Rpc.NpcBattle.Character|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
        }

        class PvpBattleDetailProto implements IPvpBattleDetailProto {
            constructor(properties?: POGOProtos.Rpc.IPvpBattleDetailProto);
            public character: POGOProtos.Rpc.NpcBattle.Character;
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public static encode(message: POGOProtos.Rpc.IPvpBattleDetailProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PvpBattleDetailProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PvpBattleDetailProto;
            public static toObject(message: POGOProtos.Rpc.PvpBattleDetailProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPvpBattleResultsProto {
            battle_result?: (POGOProtos.Rpc.PvpBattleResultsProto.BattleResult|null);
            player_xp_awarded?: (number|null);
            battle_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class PvpBattleResultsProto implements IPvpBattleResultsProto {
            constructor(properties?: POGOProtos.Rpc.IPvpBattleResultsProto);
            public battle_result: POGOProtos.Rpc.PvpBattleResultsProto.BattleResult;
            public player_xp_awarded: number;
            public battle_item_rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IPvpBattleResultsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PvpBattleResultsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PvpBattleResultsProto;
            public static toObject(message: POGOProtos.Rpc.PvpBattleResultsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace PvpBattleResultsProto {

            enum BattleResult {
                UNSET = 0,
                WIN = 1,
                LOSS = 2,
                DRAW = 3
            }
        }

        interface IPvpNextFeatureFlagsProto {
            pvpn_version?: (number|null);
        }

        class PvpNextFeatureFlagsProto implements IPvpNextFeatureFlagsProto {
            constructor(properties?: POGOProtos.Rpc.IPvpNextFeatureFlagsProto);
            public pvpn_version: number;
            public static encode(message: POGOProtos.Rpc.IPvpNextFeatureFlagsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.PvpNextFeatureFlagsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.PvpNextFeatureFlagsProto;
            public static toObject(message: POGOProtos.Rpc.PvpNextFeatureFlagsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuaternion {
            x?: (number|null);
            y?: (number|null);
            z?: (number|null);
            w?: (number|null);
        }

        class Quaternion implements IQuaternion {
            constructor(properties?: POGOProtos.Rpc.IQuaternion);
            public x: number;
            public y: number;
            public z: number;
            public w: number;
            public static encode(message: POGOProtos.Rpc.IQuaternion, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Quaternion;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Quaternion;
            public static toObject(message: POGOProtos.Rpc.Quaternion, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestBranchDisplayProto {
            title_key?: (string|null);
            description_key?: (string|null);
            image_url?: (string|null);
            button_background_color?: (string|null);
            button_text_key?: (string|null);
            button_background_image_url?: (string|null);
            button_text_color?: (string|null);
            button_text_offset?: (number|null);
            arrow_button_color?: (string|null);
        }

        class QuestBranchDisplayProto implements IQuestBranchDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IQuestBranchDisplayProto);
            public title_key: string;
            public description_key: string;
            public image_url: string;
            public button_background_color: string;
            public button_text_key: string;
            public button_background_image_url: string;
            public button_text_color: string;
            public button_text_offset: number;
            public arrow_button_color: string;
            public static encode(message: POGOProtos.Rpc.IQuestBranchDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestBranchDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestBranchDisplayProto;
            public static toObject(message: POGOProtos.Rpc.QuestBranchDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestBranchRewardProto {
            rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class QuestBranchRewardProto implements IQuestBranchRewardProto {
            constructor(properties?: POGOProtos.Rpc.IQuestBranchRewardProto);
            public rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IQuestBranchRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestBranchRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestBranchRewardProto;
            public static toObject(message: POGOProtos.Rpc.QuestBranchRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestConditionProto {
            with_pokemon_type?: (POGOProtos.Rpc.IWithPokemonTypeProto|null);
            with_pokemon_category?: (POGOProtos.Rpc.IWithPokemonCategoryProto|null);
            with_weather_boost?: (POGOProtos.Rpc.IWithWeatherBoostProto|null);
            with_daily_capture_bonus?: (POGOProtos.Rpc.IWithDailyCaptureBonusProto|null);
            with_daily_spin_bonus?: (POGOProtos.Rpc.IWithDailySpinBonusProto|null);
            with_win_raid_status?: (POGOProtos.Rpc.IWithWinRaidStatusProto|null);
            with_raid_level?: (POGOProtos.Rpc.IWithRaidLevelProto|null);
            with_throw_type?: (POGOProtos.Rpc.IWithThrowTypeProto|null);
            with_win_gym_battle_status?: (POGOProtos.Rpc.IWithWinGymBattleStatusProto|null);
            with_super_effective_charge_move?: (POGOProtos.Rpc.IWithSuperEffectiveChargeMoveProto|null);
            with_item?: (POGOProtos.Rpc.IWithItemProto|null);
            with_unique_pokestop?: (POGOProtos.Rpc.IWithUniquePokestopProto|null);
            with_quest_context?: (POGOProtos.Rpc.IWithQuestContextProto|null);
            with_badge_type?: (POGOProtos.Rpc.IWithBadgeTypeProto|null);
            with_player_level?: (POGOProtos.Rpc.IWithPlayerLevelProto|null);
            with_win_battle_status?: (POGOProtos.Rpc.IWithWinBattleStatusProto|null);
            with_unique_pokemon?: (POGOProtos.Rpc.IWithUniquePokemonProto|null);
            with_npc_combat?: (POGOProtos.Rpc.IWithNpcCombatProto|null);
            with_pvp_combat?: (POGOProtos.Rpc.IWithPvpCombatProto|null);
            with_location?: (POGOProtos.Rpc.IWithLocationProto|null);
            with_distance?: (POGOProtos.Rpc.IWithDistanceProto|null);
            with_invasion_character?: (POGOProtos.Rpc.IWithInvasionCharacterProto|null);
            with_pokemon_alignment?: (POGOProtos.Rpc.IWithPokemonAlignmentProto|null);
            with_buddy?: (POGOProtos.Rpc.IWithBuddyProto|null);
            with_daily_buddy_affection?: (POGOProtos.Rpc.IWithDailyBuddyAffectionProto|null);
            with_pokemon_level?: (POGOProtos.Rpc.IWithPokemonLevelProto|null);
            with_max_cp?: (POGOProtos.Rpc.IWithMaxCpProto|null);
            with_temp_evo_id?: (POGOProtos.Rpc.IWithTempEvoIdProto|null);
            with_gbl_rank?: (POGOProtos.Rpc.IWithGblRankProto|null);
            with_encounter_type?: (POGOProtos.Rpc.IWithEncounterTypeProto|null);
            with_combat_type?: (POGOProtos.Rpc.IWithCombatTypeProto|null);
            with_item_type?: (POGOProtos.Rpc.IWithItemTypeProto|null);
            with_elapsed_time?: (POGOProtos.Rpc.IWithElapsedTimeProto|null);
            with_friend_level?: (POGOProtos.Rpc.IWithFriendLevelProto|null);
            with_pokemon_cp?: (POGOProtos.Rpc.IWithPokemonCpProto|null);
            with_raid_location?: (POGOProtos.Rpc.IWithRaidLocationProto|null);
            with_friends_raid?: (POGOProtos.Rpc.IWithFriendsRaidProto|null);
            with_pokemon_costume?: (POGOProtos.Rpc.IWithPokemonCostumeProto|null);
            with_pokemon_size?: (POGOProtos.Rpc.IWithPokemonSizeProto|null);
            with_device_type?: (POGOProtos.Rpc.IWithDeviceTypeProto|null);
            with_route_travel?: (POGOProtos.Rpc.IWithRouteTravelProto|null);
            with_unique_route?: (POGOProtos.Rpc.IWithUniqueRouteTravelProto|null);
            with_tappable_type?: (POGOProtos.Rpc.IWithTappableTypeProto|null);
            with_auth_provider_type?: (POGOProtos.Rpc.IWithAuthProviderTypeProto|null);
            with_opponent_pokemon_battle_status?: (POGOProtos.Rpc.IWithOpponentPokemonBattleStatusProto|null);
            with_fort_id?: (POGOProtos.Rpc.IWithFortIdProto|null);
            with_pokemon_move?: (POGOProtos.Rpc.IWithPokemonMoveProto|null);
            with_pokemon_form?: (POGOProtos.Rpc.IWithPokemonFormProto|null);
            with_bread_pokemon?: (POGOProtos.Rpc.IWithBreadPokemonProto|null);
            with_bread_dough_pokemon?: (POGOProtos.Rpc.IWithBreadDoughPokemonProto|null);
            with_bread_move_type?: (POGOProtos.Rpc.IWithBreadMoveTypeProto|null);
            with_poi_sponsor_id?: (POGOProtos.Rpc.IWithPoiSponsorIdProto|null);
            with_page_type?: (POGOProtos.Rpc.IWithPageTypeProto|null);
            with_trainee_pokemon_attributes?: (POGOProtos.Rpc.IWithTraineePokemonAttributesProto|null);
            type?: (POGOProtos.Rpc.QuestConditionProto.ConditionType|null);
        }

        class QuestConditionProto implements IQuestConditionProto {
            constructor(properties?: POGOProtos.Rpc.IQuestConditionProto);
            public with_pokemon_type?: (POGOProtos.Rpc.IWithPokemonTypeProto|null);
            public with_pokemon_category?: (POGOProtos.Rpc.IWithPokemonCategoryProto|null);
            public with_weather_boost?: (POGOProtos.Rpc.IWithWeatherBoostProto|null);
            public with_daily_capture_bonus?: (POGOProtos.Rpc.IWithDailyCaptureBonusProto|null);
            public with_daily_spin_bonus?: (POGOProtos.Rpc.IWithDailySpinBonusProto|null);
            public with_win_raid_status?: (POGOProtos.Rpc.IWithWinRaidStatusProto|null);
            public with_raid_level?: (POGOProtos.Rpc.IWithRaidLevelProto|null);
            public with_throw_type?: (POGOProtos.Rpc.IWithThrowTypeProto|null);
            public with_win_gym_battle_status?: (POGOProtos.Rpc.IWithWinGymBattleStatusProto|null);
            public with_super_effective_charge_move?: (POGOProtos.Rpc.IWithSuperEffectiveChargeMoveProto|null);
            public with_item?: (POGOProtos.Rpc.IWithItemProto|null);
            public with_unique_pokestop?: (POGOProtos.Rpc.IWithUniquePokestopProto|null);
            public with_quest_context?: (POGOProtos.Rpc.IWithQuestContextProto|null);
            public with_badge_type?: (POGOProtos.Rpc.IWithBadgeTypeProto|null);
            public with_player_level?: (POGOProtos.Rpc.IWithPlayerLevelProto|null);
            public with_win_battle_status?: (POGOProtos.Rpc.IWithWinBattleStatusProto|null);
            public with_unique_pokemon?: (POGOProtos.Rpc.IWithUniquePokemonProto|null);
            public with_npc_combat?: (POGOProtos.Rpc.IWithNpcCombatProto|null);
            public with_pvp_combat?: (POGOProtos.Rpc.IWithPvpCombatProto|null);
            public with_location?: (POGOProtos.Rpc.IWithLocationProto|null);
            public with_distance?: (POGOProtos.Rpc.IWithDistanceProto|null);
            public with_invasion_character?: (POGOProtos.Rpc.IWithInvasionCharacterProto|null);
            public with_pokemon_alignment?: (POGOProtos.Rpc.IWithPokemonAlignmentProto|null);
            public with_buddy?: (POGOProtos.Rpc.IWithBuddyProto|null);
            public with_daily_buddy_affection?: (POGOProtos.Rpc.IWithDailyBuddyAffectionProto|null);
            public with_pokemon_level?: (POGOProtos.Rpc.IWithPokemonLevelProto|null);
            public with_max_cp?: (POGOProtos.Rpc.IWithMaxCpProto|null);
            public with_temp_evo_id?: (POGOProtos.Rpc.IWithTempEvoIdProto|null);
            public with_gbl_rank?: (POGOProtos.Rpc.IWithGblRankProto|null);
            public with_encounter_type?: (POGOProtos.Rpc.IWithEncounterTypeProto|null);
            public with_combat_type?: (POGOProtos.Rpc.IWithCombatTypeProto|null);
            public with_item_type?: (POGOProtos.Rpc.IWithItemTypeProto|null);
            public with_elapsed_time?: (POGOProtos.Rpc.IWithElapsedTimeProto|null);
            public with_friend_level?: (POGOProtos.Rpc.IWithFriendLevelProto|null);
            public with_pokemon_cp?: (POGOProtos.Rpc.IWithPokemonCpProto|null);
            public with_raid_location?: (POGOProtos.Rpc.IWithRaidLocationProto|null);
            public with_friends_raid?: (POGOProtos.Rpc.IWithFriendsRaidProto|null);
            public with_pokemon_costume?: (POGOProtos.Rpc.IWithPokemonCostumeProto|null);
            public with_pokemon_size?: (POGOProtos.Rpc.IWithPokemonSizeProto|null);
            public with_device_type?: (POGOProtos.Rpc.IWithDeviceTypeProto|null);
            public with_route_travel?: (POGOProtos.Rpc.IWithRouteTravelProto|null);
            public with_unique_route?: (POGOProtos.Rpc.IWithUniqueRouteTravelProto|null);
            public with_tappable_type?: (POGOProtos.Rpc.IWithTappableTypeProto|null);
            public with_auth_provider_type?: (POGOProtos.Rpc.IWithAuthProviderTypeProto|null);
            public with_opponent_pokemon_battle_status?: (POGOProtos.Rpc.IWithOpponentPokemonBattleStatusProto|null);
            public with_fort_id?: (POGOProtos.Rpc.IWithFortIdProto|null);
            public with_pokemon_move?: (POGOProtos.Rpc.IWithPokemonMoveProto|null);
            public with_pokemon_form?: (POGOProtos.Rpc.IWithPokemonFormProto|null);
            public with_bread_pokemon?: (POGOProtos.Rpc.IWithBreadPokemonProto|null);
            public with_bread_dough_pokemon?: (POGOProtos.Rpc.IWithBreadDoughPokemonProto|null);
            public with_bread_move_type?: (POGOProtos.Rpc.IWithBreadMoveTypeProto|null);
            public with_poi_sponsor_id?: (POGOProtos.Rpc.IWithPoiSponsorIdProto|null);
            public with_page_type?: (POGOProtos.Rpc.IWithPageTypeProto|null);
            public with_trainee_pokemon_attributes?: (POGOProtos.Rpc.IWithTraineePokemonAttributesProto|null);
            public type: POGOProtos.Rpc.QuestConditionProto.ConditionType;
            public Condition?: ("with_pokemon_type"|"with_pokemon_category"|"with_weather_boost"|"with_daily_capture_bonus"|"with_daily_spin_bonus"|"with_win_raid_status"|"with_raid_level"|"with_throw_type"|"with_win_gym_battle_status"|"with_super_effective_charge_move"|"with_item"|"with_unique_pokestop"|"with_quest_context"|"with_badge_type"|"with_player_level"|"with_win_battle_status"|"with_unique_pokemon"|"with_npc_combat"|"with_pvp_combat"|"with_location"|"with_distance"|"with_invasion_character"|"with_pokemon_alignment"|"with_buddy"|"with_daily_buddy_affection"|"with_pokemon_level"|"with_max_cp"|"with_temp_evo_id"|"with_gbl_rank"|"with_encounter_type"|"with_combat_type"|"with_item_type"|"with_elapsed_time"|"with_friend_level"|"with_pokemon_cp"|"with_raid_location"|"with_friends_raid"|"with_pokemon_costume"|"with_pokemon_size"|"with_device_type"|"with_route_travel"|"with_unique_route"|"with_tappable_type"|"with_auth_provider_type"|"with_opponent_pokemon_battle_status"|"with_fort_id"|"with_pokemon_move"|"with_pokemon_form"|"with_bread_pokemon"|"with_bread_dough_pokemon"|"with_bread_move_type"|"with_poi_sponsor_id"|"with_page_type"|"with_trainee_pokemon_attributes");
            public static encode(message: POGOProtos.Rpc.IQuestConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestConditionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestConditionProto;
            public static toObject(message: POGOProtos.Rpc.QuestConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestConditionProto {

            enum ConditionType {
                UNSET = 0,
                WITH_POKEMON_TYPE = 1,
                WITH_POKEMON_CATEGORY = 2,
                WITH_WEATHER_BOOST = 3,
                WITH_DAILY_CAPTURE_BONUS = 4,
                WITH_DAILY_SPIN_BONUS = 5,
                WITH_WIN_RAID_STATUS = 6,
                WITH_RAID_LEVEL = 7,
                WITH_THROW_TYPE = 8,
                WITH_WIN_GYM_BATTLE_STATUS = 9,
                WITH_SUPER_EFFECTIVE_CHARGE = 10,
                WITH_ITEM = 11,
                WITH_UNIQUE_POKESTOP = 12,
                WITH_QUEST_CONTEXT = 13,
                WITH_THROW_TYPE_IN_A_ROW = 14,
                WITH_CURVE_BALL = 15,
                WITH_BADGE_TYPE = 16,
                WITH_PLAYER_LEVEL = 17,
                WITH_WIN_BATTLE_STATUS = 18,
                WITH_NEW_FRIEND = 19,
                WITH_DAYS_IN_A_ROW = 20,
                WITH_UNIQUE_POKEMON = 21,
                WITH_NPC_COMBAT = 22,
                WITH_PVP_COMBAT = 23,
                WITH_LOCATION = 24,
                WITH_DISTANCE = 25,
                WITH_POKEMON_ALIGNMENT = 26,
                WITH_INVASION_CHARACTER = 27,
                WITH_BUDDY = 28,
                WITH_BUDDY_INTERESTING_POI = 29,
                WITH_DAILY_BUDDY_AFFECTION = 30,
                WITH_POKEMON_LEVEL = 31,
                WITH_SINGLE_DAY = 32,
                WITH_UNIQUE_POKEMON_TEAM = 33,
                WITH_MAX_CP = 34,
                WITH_LUCKY_POKEMON = 35,
                WITH_LEGENDARY_POKEMON = 36,
                WITH_TEMP_EVO_POKEMON = 37,
                WITH_GBL_RANK = 38,
                WITH_CATCHES_IN_A_ROW = 39,
                WITH_ENCOUNTER_TYPE = 40,
                WITH_COMBAT_TYPE = 41,
                WITH_GEOTARGETED_POI = 42,
                WITH_ITEM_TYPE = 43,
                WITH_RAID_ELAPSED_TIME = 44,
                WITH_FRIEND_LEVEL = 45,
                WITH_STICKER = 46,
                WITH_POKEMON_CP = 47,
                WITH_RAID_LOCATION = 48,
                WITH_FRIENDS_RAID = 49,
                WITH_POKEMON_COSTUME = 50,
                WITH_APPLIED_ITEM = 51,
                WITH_POKEMON_SIZE = 52,
                WITH_TOTAL_DAYS = 53,
                WITH_DEVICE_TYPE = 54,
                WITH_ROUTE_TRAVEL = 55,
                WITH_UNIQUE_ROUTE_TRAVEL = 56,
                WITH_TAPPABLE_TYPE = 57,
                WITH_IN_PARTY = 58,
                WITH_SHINY_POKEMON = 59,
                WITH_ABILITY_PARTY_POWER_DAMAGE_DEALT = 60,
                WITH_AUTH_PROVIDER_TYPE = 61,
                WITH_OPPONENT_POKEMON_BATTLE_STATUS = 62,
                WITH_FORT_ID = 63,
                WITH_POKEMON_MOVE = 64,
                WITH_POKEMON_FORM = 65,
                WITH_BREAD_POKEMON = 66,
                WITH_BREAD_DOUGH_POKEMON = 67,
                WITH_WIN_BREAD_BATTLE = 68,
                WITH_BREAD_MOVE_TYPE = 69,
                WITH_STRONG_POKEMON = 70,
                WITH_POI_SPONSOR_ID = 71,
                WITH_WIN_BREAD_DOUGH_BATTLE = 73,
                WITH_PAGE_TYPE = 74,
                WITH_MAX_POKEMON = 75,
                WITH_TRAINEE_POKEMON_ATTRIBUTES = 76
            }
        }

        interface IQuestCreateDetail {
            origin?: (POGOProtos.Rpc.EncounterType|null);
        }

        class QuestCreateDetail implements IQuestCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IQuestCreateDetail);
            public origin: POGOProtos.Rpc.EncounterType;
            public static encode(message: POGOProtos.Rpc.IQuestCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestCreateDetail;
            public static toObject(message: POGOProtos.Rpc.QuestCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestDialogProto {
            text?: (string|null);
            expression?: (POGOProtos.Rpc.QuestDialogProto.CharacterExpression|null);
            image_uri?: (string|null);
            character?: (POGOProtos.Rpc.QuestDialogProto.Character|null);
            character_offset?: (number[]|null);
            text_background_color?: (string|null);
            character_tint?: (string|null);
            text_title_string_id?: (string|null);
            quest_music_override_key?: (string|null);
        }

        class QuestDialogProto implements IQuestDialogProto {
            constructor(properties?: POGOProtos.Rpc.IQuestDialogProto);
            public text: string;
            public expression: POGOProtos.Rpc.QuestDialogProto.CharacterExpression;
            public image_uri: string;
            public character: POGOProtos.Rpc.QuestDialogProto.Character;
            public character_offset: number[];
            public text_background_color: string;
            public character_tint: string;
            public text_title_string_id: string;
            public quest_music_override_key: string;
            public static encode(message: POGOProtos.Rpc.IQuestDialogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestDialogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestDialogProto;
            public static toObject(message: POGOProtos.Rpc.QuestDialogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestDialogProto {

            enum Character {
                CHARACTER_UNSET = 0,
                PROFESSOR_WILLOW = 1,
                SPECIAL_GUEST_1 = 2,
                SPECIAL_GUEST_2 = 3,
                SPECIAL_GUEST_3 = 4,
                SPECIAL_GUEST_4 = 5,
                SPECIAL_GUEST_5 = 6,
                SPECIAL_GUEST_RHI = 7,
                SPECIAL_GUEST_RHI_2 = 8,
                SPECIAL_GUEST_EXECBLUE = 9,
                SPECIAL_GUEST_EXECRED = 10,
                SPECIAL_GUEST_EXECYELLOW = 11,
                SPECIAL_GUEST_MYSTIC = 12,
                SPECIAL_GUEST_VALOR = 13,
                SPECIAL_GUEST_INSTINCT = 14,
                SPECIAL_GUEST_TRAVELER = 15,
                SPECIAL_GUEST_EXPLORER = 16
            }

            enum CharacterExpression {
                EXPRESSION_UNSET = 0,
                HAPPY = 1,
                SYMPATHETIC = 2,
                ENERGETIC = 3,
                PUSHY = 4,
                IMPATIENT = 5,
                ADMIRATION = 6,
                SAD = 7,
                IDLE = 8,
                IDLE_B = 9,
                GREETING = 10,
                GREETING_B = 11,
                REACT_ANGRY = 12,
                REACT_CELEBRATION = 13,
                REACT_HAPPY = 14,
                REACT_LAUGH = 15,
                REACT_SAD = 16,
                REACT_SCARED = 17,
                REACT_SURPRISED = 18
            }
        }

        interface IQuestDialogTelemetry {
            skipped?: (boolean|null);
            skip_from_page?: (number|null);
            quest_template_id?: (string|null);
        }

        class QuestDialogTelemetry implements IQuestDialogTelemetry {
            constructor(properties?: POGOProtos.Rpc.IQuestDialogTelemetry);
            public skipped: boolean;
            public skip_from_page: number;
            public quest_template_id: string;
            public static encode(message: POGOProtos.Rpc.IQuestDialogTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestDialogTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestDialogTelemetry;
            public static toObject(message: POGOProtos.Rpc.QuestDialogTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestDisplayProto {
            quest_id?: (string|null);
            dialog?: (POGOProtos.Rpc.IQuestDialogProto[]|null);
            description?: (string|null);
            title?: (string|null);
            slot?: (number|null);
            subquest_displays?: (POGOProtos.Rpc.IQuestDisplayProto[]|null);
            story_ending_quest?: (boolean|null);
            story_ending_description?: (string|null);
            tag_color?: (string|null);
            tag_string?: (string|null);
            sponsor_string?: (string|null);
            partner_id?: (string|null);
            icon_name?: (string|null);
            background_name?: (string|null);
            foreground_name?: (string|null);
            progress_interval?: (number|null);
            branches?: (POGOProtos.Rpc.IQuestBranchDisplayProto[]|null);
            force_reshow_branching_quest_dialog_cooldown_ms?: (number|Long|null);
            branching_quest_story_view_button_key?: (string|null);
            branching_quest_story_view_image_url?: (string|null);
            quest_branch_choice_view_background_image_url?: (string|null);
            quest_branch_choice_view_background_color?: (string|null);
            prop_name?: (string|null);
            quest_branch_choice_view_header_background_color?: (string|null);
            quest_branch_choice_view_bottom_gradient_color?: (string|null);
            sort_order?: (number|null);
            story_questline_title?: (string|null);
            empty_narrative_animation_enabled?: (boolean|null);
        }

        class QuestDisplayProto implements IQuestDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IQuestDisplayProto);
            public quest_id: string;
            public dialog: POGOProtos.Rpc.IQuestDialogProto[];
            public description: string;
            public title: string;
            public slot: number;
            public subquest_displays: POGOProtos.Rpc.IQuestDisplayProto[];
            public story_ending_quest: boolean;
            public story_ending_description: string;
            public tag_color: string;
            public tag_string: string;
            public sponsor_string: string;
            public partner_id: string;
            public icon_name: string;
            public background_name: string;
            public foreground_name: string;
            public progress_interval: number;
            public branches: POGOProtos.Rpc.IQuestBranchDisplayProto[];
            public force_reshow_branching_quest_dialog_cooldown_ms: (number|Long);
            public branching_quest_story_view_button_key: string;
            public branching_quest_story_view_image_url: string;
            public quest_branch_choice_view_background_image_url: string;
            public quest_branch_choice_view_background_color: string;
            public prop_name: string;
            public quest_branch_choice_view_header_background_color: string;
            public quest_branch_choice_view_bottom_gradient_color: string;
            public sort_order: number;
            public story_questline_title: string;
            public empty_narrative_animation_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IQuestDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestDisplayProto;
            public static toObject(message: POGOProtos.Rpc.QuestDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestEncounterOutProto {
            result?: (POGOProtos.Rpc.QuestEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
        }

        class QuestEncounterOutProto implements IQuestEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IQuestEncounterOutProto);
            public result: POGOProtos.Rpc.QuestEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IQuestEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.QuestEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestEncounterOutProto {

            enum Result {
                QUEST_ENCOUNTER_UNKNOWN = 0,
                QUEST_ENCOUNTER_SUCCESS = 1,
                QUEST_ENCOUNTER_NOT_AVAILABLE = 2,
                QUEST_ENCOUNTER_ALREADY_FINISHED = 3,
                POKEMON_INVENTORY_FULL = 4
            }
        }

        interface IQuestEncounterProto {
            pokemon_id?: (number|Long|null);
            quest_id?: (string|null);
        }

        class QuestEncounterProto implements IQuestEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IQuestEncounterProto);
            public pokemon_id: (number|Long);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.IQuestEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestEncounterProto;
            public static toObject(message: POGOProtos.Rpc.QuestEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestEvolutionGlobalSettingsProto {
            enable_quest_evolutions?: (boolean|null);
        }

        class QuestEvolutionGlobalSettingsProto implements IQuestEvolutionGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IQuestEvolutionGlobalSettingsProto);
            public enable_quest_evolutions: boolean;
            public static encode(message: POGOProtos.Rpc.IQuestEvolutionGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestEvolutionGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestEvolutionGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.QuestEvolutionGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestEvolutionSettingsProto {
            enable_quest_evolutions?: (boolean|null);
            enable_walking_quest_evolutions?: (boolean|null);
            enable_evolve_in_buddy_page?: (boolean|null);
        }

        class QuestEvolutionSettingsProto implements IQuestEvolutionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IQuestEvolutionSettingsProto);
            public enable_quest_evolutions: boolean;
            public enable_walking_quest_evolutions: boolean;
            public enable_evolve_in_buddy_page: boolean;
            public static encode(message: POGOProtos.Rpc.IQuestEvolutionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestEvolutionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestEvolutionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.QuestEvolutionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestGlobalSettingsProto {
            enable_quests?: (boolean|null);
            max_challenge_quests?: (number|null);
            enable_show_sponsor_name?: (boolean|null);
            force_reshow_branching_quest_dialog_default_cooldown_ms?: (number|Long|null);
        }

        class QuestGlobalSettingsProto implements IQuestGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IQuestGlobalSettingsProto);
            public enable_quests: boolean;
            public max_challenge_quests: number;
            public enable_show_sponsor_name: boolean;
            public force_reshow_branching_quest_dialog_default_cooldown_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IQuestGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.QuestGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestGoalProto {
            condition?: (POGOProtos.Rpc.IQuestConditionProto[]|null);
            target?: (number|null);
        }

        class QuestGoalProto implements IQuestGoalProto {
            constructor(properties?: POGOProtos.Rpc.IQuestGoalProto);
            public condition: POGOProtos.Rpc.IQuestConditionProto[];
            public target: number;
            public static encode(message: POGOProtos.Rpc.IQuestGoalProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestGoalProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestGoalProto;
            public static toObject(message: POGOProtos.Rpc.QuestGoalProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestIncidentProto {
            quest_id?: (string|null);
            context?: (POGOProtos.Rpc.QuestIncidentProto.Context|null);
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
        }

        class QuestIncidentProto implements IQuestIncidentProto {
            constructor(properties?: POGOProtos.Rpc.IQuestIncidentProto);
            public quest_id: string;
            public context: POGOProtos.Rpc.QuestIncidentProto.Context;
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public static encode(message: POGOProtos.Rpc.IQuestIncidentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestIncidentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestIncidentProto;
            public static toObject(message: POGOProtos.Rpc.QuestIncidentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestIncidentProto {

            enum Context {
                UNSET = 0,
                STORY_QUEST_BATTLE = 1,
                TIMED_QUEST_BATTLE = 2
            }
        }

        interface IQuestListTelemetry {
            client_timestamp?: (number|Long|null);
            interaction_type?: (POGOProtos.Rpc.QuestListTelemetry.QuestListInteraction|null);
            quest_list_tab?: (POGOProtos.Rpc.QuestListTelemetry.QuestListTab|null);
        }

        class QuestListTelemetry implements IQuestListTelemetry {
            constructor(properties?: POGOProtos.Rpc.IQuestListTelemetry);
            public client_timestamp: (number|Long);
            public interaction_type: POGOProtos.Rpc.QuestListTelemetry.QuestListInteraction;
            public quest_list_tab: POGOProtos.Rpc.QuestListTelemetry.QuestListTab;
            public static encode(message: POGOProtos.Rpc.IQuestListTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestListTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestListTelemetry;
            public static toObject(message: POGOProtos.Rpc.QuestListTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestListTelemetry {

            enum QuestListInteraction {
                OPEN = 0,
                CLOSED = 1
            }

            enum QuestListTab {
                TAB_ONE = 0,
                TAB_TWO = 1,
                TAB_THREE = 2
            }
        }

        interface IQuestPokemonEncounterProto {
            quest_id?: (string|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            encounter_type?: (POGOProtos.Rpc.EncounterType|null);
            is_hidden_ditto?: (boolean|null);
            ditto?: (POGOProtos.Rpc.IPokemonProto|null);
            poke_ball_override?: (POGOProtos.Rpc.Item|null);
            overwritten_on_flee?: (boolean|null);
            quest_encounter_type?: (POGOProtos.Rpc.QuestEncounterType|null);
        }

        class QuestPokemonEncounterProto implements IQuestPokemonEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IQuestPokemonEncounterProto);
            public quest_id: string;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public encounter_type: POGOProtos.Rpc.EncounterType;
            public is_hidden_ditto: boolean;
            public ditto?: (POGOProtos.Rpc.IPokemonProto|null);
            public poke_ball_override: POGOProtos.Rpc.Item;
            public overwritten_on_flee: boolean;
            public quest_encounter_type: POGOProtos.Rpc.QuestEncounterType;
            public static encode(message: POGOProtos.Rpc.IQuestPokemonEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPokemonEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPokemonEncounterProto;
            public static toObject(message: POGOProtos.Rpc.QuestPokemonEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestPreconditionProto {
            quest_template_id?: (string|null);
            level?: (POGOProtos.Rpc.QuestPreconditionProto.ILevel|null);
            medal?: (POGOProtos.Rpc.QuestPreconditionProto.IMedal|null);
            quests?: (POGOProtos.Rpc.QuestPreconditionProto.IQuests|null);
            month_year_bucket?: (POGOProtos.Rpc.QuestPreconditionProto.IMonthYearBucket|null);
            group?: (POGOProtos.Rpc.QuestPreconditionProto.IGroup|null);
            story_line?: (POGOProtos.Rpc.QuestPreconditionProto.IStorylineProgressConditionProto|null);
            team?: (POGOProtos.Rpc.QuestPreconditionProto.ITeamProto|null);
            campfire_check_in?: (POGOProtos.Rpc.QuestPreconditionProto.ICampfireCheckInConditionProto|null);
            type?: (POGOProtos.Rpc.QuestPreconditionProto.QuestPreconditionType|null);
        }

        class QuestPreconditionProto implements IQuestPreconditionProto {
            constructor(properties?: POGOProtos.Rpc.IQuestPreconditionProto);
            public quest_template_id?: (string|null);
            public level?: (POGOProtos.Rpc.QuestPreconditionProto.ILevel|null);
            public medal?: (POGOProtos.Rpc.QuestPreconditionProto.IMedal|null);
            public quests?: (POGOProtos.Rpc.QuestPreconditionProto.IQuests|null);
            public month_year_bucket?: (POGOProtos.Rpc.QuestPreconditionProto.IMonthYearBucket|null);
            public group?: (POGOProtos.Rpc.QuestPreconditionProto.IGroup|null);
            public story_line?: (POGOProtos.Rpc.QuestPreconditionProto.IStorylineProgressConditionProto|null);
            public team?: (POGOProtos.Rpc.QuestPreconditionProto.ITeamProto|null);
            public campfire_check_in?: (POGOProtos.Rpc.QuestPreconditionProto.ICampfireCheckInConditionProto|null);
            public type: POGOProtos.Rpc.QuestPreconditionProto.QuestPreconditionType;
            public Condition?: ("quest_template_id"|"level"|"medal"|"quests"|"month_year_bucket"|"group"|"story_line"|"team"|"campfire_check_in");
            public static encode(message: POGOProtos.Rpc.IQuestPreconditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto;
            public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestPreconditionProto {

            enum Operator {
                UNSET_OPERATOR = 0,
                EQUALS = 1,
                GREATER_THAN = 2,
                LESS_THAN = 3,
                NOT_EQUALS = 4
            }

            enum QuestPreconditionType {
                QUEST_PRECONDITION_UNSET_QUESTPRECONDITIONTYPE = 0,
                QUEST_PRECONDITION_QUEST = 1,
                QUEST_PRECONDITION_LEVEL = 2,
                QUEST_PRECONDITION_MEDAL = 3,
                QUEST_PRECONDITION_IS_MINOR = 4,
                QUEST_PRECONDITION_EXCLUSIVE_QUESTS = 5,
                QUEST_PRECONDITION_NEVER = 6,
                QUEST_PRECONDITION_RECEIVED_ANY_LISTED_QUEST = 7,
                QUEST_PRECONDITION_MONTH_YEAR_BUCKET = 8,
                QUEST_PRECONDITION_EXCLUSIVE_IN_PROGRESS_GROUP = 9,
                QUEST_PRECONDITION_STORYLINE_PROGRESS = 10,
                QUEST_PRECONDITION_TEAM = 11
            }

            interface ICampfireCheckInConditionProto {
                campfire_event_tag?: (string|null);
            }

            class CampfireCheckInConditionProto implements ICampfireCheckInConditionProto {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.ICampfireCheckInConditionProto);
                public campfire_event_tag: string;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.ICampfireCheckInConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.CampfireCheckInConditionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.CampfireCheckInConditionProto;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.CampfireCheckInConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGroup {
                name?: (POGOProtos.Rpc.QuestPreconditionProto.Group.Name|null);
            }

            class Group implements IGroup {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.IGroup);
                public name: POGOProtos.Rpc.QuestPreconditionProto.Group.Name;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.IGroup, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.Group;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.Group;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.Group, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Group {

                enum Name {
                    UNSET_NAME = 0,
                    GIOVANNI = 1
                }
            }

            interface ILevel {
                operator?: (POGOProtos.Rpc.QuestPreconditionProto.Operator|null);
                level?: (number|null);
            }

            class Level implements ILevel {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.ILevel);
                public operator: POGOProtos.Rpc.QuestPreconditionProto.Operator;
                public level: number;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.ILevel, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.Level;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.Level;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.Level, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMedal {
                type?: (POGOProtos.Rpc.HoloBadgeType|null);
                operator?: (POGOProtos.Rpc.QuestPreconditionProto.Operator|null);
                badge_rank?: (number|null);
            }

            class Medal implements IMedal {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.IMedal);
                public type: POGOProtos.Rpc.HoloBadgeType;
                public operator: POGOProtos.Rpc.QuestPreconditionProto.Operator;
                public badge_rank: number;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.IMedal, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.Medal;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.Medal;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.Medal, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMonthYearBucket {
                year?: (number|null);
                month?: (number|null);
            }

            class MonthYearBucket implements IMonthYearBucket {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.IMonthYearBucket);
                public year: number;
                public month: number;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.IMonthYearBucket, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.MonthYearBucket;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.MonthYearBucket;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.MonthYearBucket, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IQuests {
                quest_template_ids?: (string[]|null);
            }

            class Quests implements IQuests {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.IQuests);
                public quest_template_ids: string[];
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.IQuests, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.Quests;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.Quests;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.Quests, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IStorylineProgressConditionProto {
                mandatory_quest_template_id?: (string[]|null);
                optional_quest_template_id?: (string[]|null);
                optional_quests_completed_min?: (number|null);
                optional_quests_completed_max?: (number|null);
            }

            class StorylineProgressConditionProto implements IStorylineProgressConditionProto {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.IStorylineProgressConditionProto);
                public mandatory_quest_template_id: string[];
                public optional_quest_template_id: string[];
                public optional_quests_completed_min: number;
                public optional_quests_completed_max: number;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.IStorylineProgressConditionProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.StorylineProgressConditionProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.StorylineProgressConditionProto;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.StorylineProgressConditionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITeamProto {
                operator?: (POGOProtos.Rpc.QuestPreconditionProto.Operator|null);
                team?: (POGOProtos.Rpc.Team|null);
            }

            class TeamProto implements ITeamProto {
                constructor(properties?: POGOProtos.Rpc.QuestPreconditionProto.ITeamProto);
                public operator: POGOProtos.Rpc.QuestPreconditionProto.Operator;
                public team: POGOProtos.Rpc.Team;
                public static encode(message: POGOProtos.Rpc.QuestPreconditionProto.ITeamProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestPreconditionProto.TeamProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestPreconditionProto.TeamProto;
                public static toObject(message: POGOProtos.Rpc.QuestPreconditionProto.TeamProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IQuestProto {
            daily_quest?: (POGOProtos.Rpc.IDailyQuestProto|null);
            multi_part?: (POGOProtos.Rpc.IMultiPartQuestProto|null);
            catch_pokemon?: (POGOProtos.Rpc.ICatchPokemonQuestProto|null);
            add_friend?: (POGOProtos.Rpc.IAddFriendQuestProto|null);
            trade_pokemon?: (POGOProtos.Rpc.ITradePokemonQuestProto|null);
            daily_buddy_affection?: (POGOProtos.Rpc.IDailyBuddyAffectionQuestProto|null);
            quest_walk?: (POGOProtos.Rpc.IQuestWalkProto|null);
            evolve_into_pokemon?: (POGOProtos.Rpc.IEvolveIntoPokemonQuestProto|null);
            get_stardust?: (POGOProtos.Rpc.IGetStardustQuestProto|null);
            mini_collection?: (POGOProtos.Rpc.IMiniCollectionProto|null);
            geotargeted_quest?: (POGOProtos.Rpc.IGeotargetedQuestProto|null);
            buddy_evolution_walk?: (POGOProtos.Rpc.IBuddyEvolutionWalkQuestProto|null);
            battle?: (POGOProtos.Rpc.IBattleQuestProto|null);
            take_snapshot?: (POGOProtos.Rpc.ITakeSnapshotQuestProto|null);
            submit_sleep_records?: (POGOProtos.Rpc.ISubmitSleepRecordsQuestProto|null);
            travel_route?: (POGOProtos.Rpc.ITravelRouteQuestProto|null);
            spin_pokestop?: (POGOProtos.Rpc.ISpinPokestopQuestProto|null);
            pokemon_reach_cp?: (POGOProtos.Rpc.IPokemonReachCpQuestProto|null);
            quest_type?: (POGOProtos.Rpc.QuestType|null);
            with_single_day?: (POGOProtos.Rpc.IWithSingleDayProto|null);
            days_in_arow?: (POGOProtos.Rpc.IDaysWithARowQuestProto|null);
            quest_id?: (string|null);
            quest_seed?: (number|Long|null);
            quest_context?: (POGOProtos.Rpc.QuestProto.Context|null);
            template_id?: (string|null);
            progress?: (number|null);
            goal?: (POGOProtos.Rpc.IQuestGoalProto|null);
            status?: (POGOProtos.Rpc.QuestProto.Status|null);
            quest_rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
            creation_timestamp_ms?: (number|Long|null);
            last_update_timestamp_ms?: (number|Long|null);
            completion_timestamp_ms?: (number|Long|null);
            fort_id?: (string|null);
            admin_generated?: (boolean|null);
            stamp_count_override_enabled?: (boolean|null);
            stamp_count_override?: (number|null);
            s2_cell_id?: (number|Long|null);
            story_quest_template_version?: (number|null);
            daily_counter?: (POGOProtos.Rpc.IDailyCounterProto|null);
            reward_pokemon_icon_url?: (string|null);
            end_timestamp_ms?: (number|Long|null);
            is_bonus_challenge?: (boolean|null);
            referral_info?: (POGOProtos.Rpc.QuestProto.IReferralInfoProto|null);
            branch_rewards?: (POGOProtos.Rpc.IQuestBranchRewardProto[]|null);
            dialog_read?: (boolean|null);
            start_timestamp_ms?: (number|Long|null);
            with_total_days?: (POGOProtos.Rpc.IWithTotalDaysProto|null);
            phase_number?: (number|null);
            difficulty?: (POGOProtos.Rpc.QuestProto.Difficulty|null);
            min_complete_timestamp_ms?: (number|Long|null);
            min_player_level?: (number|null);
            time_zone_id?: (string|null);
        }

        class QuestProto implements IQuestProto {
            constructor(properties?: POGOProtos.Rpc.IQuestProto);
            public daily_quest?: (POGOProtos.Rpc.IDailyQuestProto|null);
            public multi_part?: (POGOProtos.Rpc.IMultiPartQuestProto|null);
            public catch_pokemon?: (POGOProtos.Rpc.ICatchPokemonQuestProto|null);
            public add_friend?: (POGOProtos.Rpc.IAddFriendQuestProto|null);
            public trade_pokemon?: (POGOProtos.Rpc.ITradePokemonQuestProto|null);
            public daily_buddy_affection?: (POGOProtos.Rpc.IDailyBuddyAffectionQuestProto|null);
            public quest_walk?: (POGOProtos.Rpc.IQuestWalkProto|null);
            public evolve_into_pokemon?: (POGOProtos.Rpc.IEvolveIntoPokemonQuestProto|null);
            public get_stardust?: (POGOProtos.Rpc.IGetStardustQuestProto|null);
            public mini_collection?: (POGOProtos.Rpc.IMiniCollectionProto|null);
            public geotargeted_quest?: (POGOProtos.Rpc.IGeotargetedQuestProto|null);
            public buddy_evolution_walk?: (POGOProtos.Rpc.IBuddyEvolutionWalkQuestProto|null);
            public battle?: (POGOProtos.Rpc.IBattleQuestProto|null);
            public take_snapshot?: (POGOProtos.Rpc.ITakeSnapshotQuestProto|null);
            public submit_sleep_records?: (POGOProtos.Rpc.ISubmitSleepRecordsQuestProto|null);
            public travel_route?: (POGOProtos.Rpc.ITravelRouteQuestProto|null);
            public spin_pokestop?: (POGOProtos.Rpc.ISpinPokestopQuestProto|null);
            public pokemon_reach_cp?: (POGOProtos.Rpc.IPokemonReachCpQuestProto|null);
            public quest_type: POGOProtos.Rpc.QuestType;
            public with_single_day?: (POGOProtos.Rpc.IWithSingleDayProto|null);
            public days_in_arow?: (POGOProtos.Rpc.IDaysWithARowQuestProto|null);
            public quest_id: string;
            public quest_seed: (number|Long);
            public quest_context: POGOProtos.Rpc.QuestProto.Context;
            public template_id: string;
            public progress: number;
            public goal?: (POGOProtos.Rpc.IQuestGoalProto|null);
            public status: POGOProtos.Rpc.QuestProto.Status;
            public quest_rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public creation_timestamp_ms: (number|Long);
            public last_update_timestamp_ms: (number|Long);
            public completion_timestamp_ms: (number|Long);
            public fort_id: string;
            public admin_generated: boolean;
            public stamp_count_override_enabled: boolean;
            public stamp_count_override: number;
            public s2_cell_id: (number|Long);
            public story_quest_template_version: number;
            public daily_counter?: (POGOProtos.Rpc.IDailyCounterProto|null);
            public reward_pokemon_icon_url: string;
            public end_timestamp_ms: (number|Long);
            public is_bonus_challenge: boolean;
            public referral_info?: (POGOProtos.Rpc.QuestProto.IReferralInfoProto|null);
            public branch_rewards: POGOProtos.Rpc.IQuestBranchRewardProto[];
            public dialog_read: boolean;
            public start_timestamp_ms: (number|Long);
            public with_total_days?: (POGOProtos.Rpc.IWithTotalDaysProto|null);
            public phase_number: number;
            public difficulty: POGOProtos.Rpc.QuestProto.Difficulty;
            public min_complete_timestamp_ms: (number|Long);
            public min_player_level: number;
            public time_zone_id: string;
            public Quest?: ("daily_quest"|"multi_part"|"catch_pokemon"|"add_friend"|"trade_pokemon"|"daily_buddy_affection"|"quest_walk"|"evolve_into_pokemon"|"get_stardust"|"mini_collection"|"geotargeted_quest"|"buddy_evolution_walk"|"battle"|"take_snapshot"|"submit_sleep_records"|"travel_route"|"spin_pokestop"|"pokemon_reach_cp");
            public static encode(message: POGOProtos.Rpc.IQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestProto;
            public static toObject(message: POGOProtos.Rpc.QuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestProto {

            enum Context {
                UNSET = 0,
                STORY_QUEST = 1,
                CHALLENGE_QUEST = 2,
                DAILY_COIN_QUEST = 3,
                TIMED_STORY_QUEST = 4,
                NON_NARRATIVE_STORY_QUEST = 5,
                LEVEL_UP_QUEST = 6,
                TGC_TRACKING_QUEST = 7,
                EVOLUTION_QUEST = 8,
                TIMED_MINI_COLLECTION_QUEST = 9,
                REFERRAL_QUEST = 10,
                BRANCHING_QUEST = 11,
                PARTY_QUEST = 12,
                MP_WALK_QUEST = 13,
                SERVER_CHALLENGE_QUEST = 14,
                TUTORIAL_QUEST = 15,
                PERSONALIZED_TIMED_CHALLENGE_QUEST = 16,
                TIMED_BRANCHING_QUEST = 17,
                EVENT_PASS_BONUS_QUEST = 19,
                WEEKLY_CHALLENGE_QUEST = 20,
                POKEMON_TRAINING_QUEST = 21
            }

            enum Difficulty {
                UNDEFINED = 0,
                VERY_EASY = 1,
                EASY = 2,
                NORMAL = 3,
                HARD = 4,
                VERY_HARD = 5
            }

            enum Status {
                STATUS_UNDEFINED = 0,
                STATUS_ACTIVE = 1,
                STATUS_COMPLETED = 2
            }

            interface IReferralInfoProto {
                referrer_id?: (string|null);
                completion_message_sent?: (boolean|null);
            }

            class ReferralInfoProto implements IReferralInfoProto {
                constructor(properties?: POGOProtos.Rpc.QuestProto.IReferralInfoProto);
                public referrer_id: string;
                public completion_message_sent: boolean;
                public static encode(message: POGOProtos.Rpc.QuestProto.IReferralInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestProto.ReferralInfoProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestProto.ReferralInfoProto;
                public static toObject(message: POGOProtos.Rpc.QuestProto.ReferralInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IQuestRewardProto {
            exp?: (number|null);
            item?: (POGOProtos.Rpc.IItemRewardProto|null);
            stardust?: (number|null);
            candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            avatar_template_id?: (string|null);
            quest_template_id?: (string|null);
            pokemon_encounter?: (POGOProtos.Rpc.IPokemonEncounterRewardProto|null);
            pokecoin?: (number|null);
            xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            level_cap?: (number|null);
            sticker?: (POGOProtos.Rpc.IStickerRewardProto|null);
            mega_resource?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            incident?: (POGOProtos.Rpc.IIncidentRewardProto|null);
            player_attribute?: (POGOProtos.Rpc.IPlayerAttributeRewardProto|null);
            event_badge_id?: (POGOProtos.Rpc.HoloBadgeType|null);
            neutral_avatar_template_id?: (string|null);
            neutral_avatar_item_template?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto|null);
            neutral_avatar_item_display?: (POGOProtos.Rpc.INeutralAvatarLootItemDisplayProto|null);
            pokemon_egg?: (POGOProtos.Rpc.IPokemonEggRewardProto|null);
            pokemon_individual_stat?: (POGOProtos.Rpc.IPokemonIndividualStatRewardProto|null);
            type?: (POGOProtos.Rpc.QuestRewardProto.Type|null);
        }

        class QuestRewardProto implements IQuestRewardProto {
            constructor(properties?: POGOProtos.Rpc.IQuestRewardProto);
            public exp?: (number|null);
            public item?: (POGOProtos.Rpc.IItemRewardProto|null);
            public stardust?: (number|null);
            public candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public avatar_template_id?: (string|null);
            public quest_template_id?: (string|null);
            public pokemon_encounter?: (POGOProtos.Rpc.IPokemonEncounterRewardProto|null);
            public pokecoin?: (number|null);
            public xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public level_cap?: (number|null);
            public sticker?: (POGOProtos.Rpc.IStickerRewardProto|null);
            public mega_resource?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public incident?: (POGOProtos.Rpc.IIncidentRewardProto|null);
            public player_attribute?: (POGOProtos.Rpc.IPlayerAttributeRewardProto|null);
            public event_badge_id?: (POGOProtos.Rpc.HoloBadgeType|null);
            public neutral_avatar_template_id?: (string|null);
            public neutral_avatar_item_template?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto|null);
            public neutral_avatar_item_display?: (POGOProtos.Rpc.INeutralAvatarLootItemDisplayProto|null);
            public pokemon_egg?: (POGOProtos.Rpc.IPokemonEggRewardProto|null);
            public pokemon_individual_stat?: (POGOProtos.Rpc.IPokemonIndividualStatRewardProto|null);
            public type: POGOProtos.Rpc.QuestRewardProto.Type;
            public Reward?: ("exp"|"item"|"stardust"|"candy"|"avatar_template_id"|"quest_template_id"|"pokemon_encounter"|"pokecoin"|"xl_candy"|"level_cap"|"sticker"|"mega_resource"|"incident"|"player_attribute"|"event_badge_id"|"neutral_avatar_template_id"|"neutral_avatar_item_template"|"neutral_avatar_item_display"|"pokemon_egg"|"pokemon_individual_stat");
            public static encode(message: POGOProtos.Rpc.IQuestRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestRewardProto;
            public static toObject(message: POGOProtos.Rpc.QuestRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuestRewardProto {

            enum Type {
                UNSET = 0,
                EXPERIENCE = 1,
                ITEM = 2,
                STARDUST = 3,
                CANDY = 4,
                AVATAR_CLOTHING = 5,
                QUEST = 6,
                POKEMON_ENCOUNTER = 7,
                POKECOIN = 8,
                XL_CANDY = 9,
                LEVEL_CAP = 10,
                STICKER = 11,
                MEGA_RESOURCE = 12,
                INCIDENT = 13,
                PLAYER_ATTRIBUTE = 14,
                EVENT_BADGE = 15,
                POKEMON_EGG = 16
            }
        }

        interface IQuestSettingsProto {
            quest_type?: (POGOProtos.Rpc.QuestType|null);
            daily_quest?: (POGOProtos.Rpc.IDailyQuestSettings|null);
        }

        class QuestSettingsProto implements IQuestSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IQuestSettingsProto);
            public quest_type: POGOProtos.Rpc.QuestType;
            public daily_quest?: (POGOProtos.Rpc.IDailyQuestSettings|null);
            public static encode(message: POGOProtos.Rpc.IQuestSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestSettingsProto;
            public static toObject(message: POGOProtos.Rpc.QuestSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestStampCardProto {
            stamp?: (POGOProtos.Rpc.IQuestStampProto[]|null);
            target?: (number|null);
            remaining_daily_stamps?: (number|null);
            id?: (string|null);
            icon_url?: (string|null);
        }

        class QuestStampCardProto implements IQuestStampCardProto {
            constructor(properties?: POGOProtos.Rpc.IQuestStampCardProto);
            public stamp: POGOProtos.Rpc.IQuestStampProto[];
            public target: number;
            public remaining_daily_stamps: number;
            public id: string;
            public icon_url: string;
            public static encode(message: POGOProtos.Rpc.IQuestStampCardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestStampCardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestStampCardProto;
            public static toObject(message: POGOProtos.Rpc.QuestStampCardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestStampProto {
            context?: (POGOProtos.Rpc.QuestProto.Context|null);
            timestamp_ms?: (number|Long|null);
        }

        class QuestStampProto implements IQuestStampProto {
            constructor(properties?: POGOProtos.Rpc.IQuestStampProto);
            public context: POGOProtos.Rpc.QuestProto.Context;
            public timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IQuestStampProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestStampProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestStampProto;
            public static toObject(message: POGOProtos.Rpc.QuestStampProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestWalkProto {
            quest_start_km_walked?: (number|null);
        }

        class QuestWalkProto implements IQuestWalkProto {
            constructor(properties?: POGOProtos.Rpc.IQuestWalkProto);
            public quest_start_km_walked: number;
            public static encode(message: POGOProtos.Rpc.IQuestWalkProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestWalkProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestWalkProto;
            public static toObject(message: POGOProtos.Rpc.QuestWalkProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuestsProto {
            quest?: (POGOProtos.Rpc.IQuestProto[]|null);
            completed_story_quest?: (string[]|null);
            quest_pokemon_encounter?: (POGOProtos.Rpc.IQuestPokemonEncounterProto[]|null);
            stamp_card?: (POGOProtos.Rpc.IQuestStampCardProto|null);
            quest_incident?: (POGOProtos.Rpc.IQuestIncidentProto[]|null);
        }

        class QuestsProto implements IQuestsProto {
            constructor(properties?: POGOProtos.Rpc.IQuestsProto);
            public quest: POGOProtos.Rpc.IQuestProto[];
            public completed_story_quest: string[];
            public quest_pokemon_encounter: POGOProtos.Rpc.IQuestPokemonEncounterProto[];
            public stamp_card?: (POGOProtos.Rpc.IQuestStampCardProto|null);
            public quest_incident: POGOProtos.Rpc.IQuestIncidentProto[];
            public static encode(message: POGOProtos.Rpc.IQuestsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuestsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuestsProto;
            public static toObject(message: POGOProtos.Rpc.QuestsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuitCombatData {
            rpc_id?: (number|null);
        }

        class QuitCombatData implements IQuitCombatData {
            constructor(properties?: POGOProtos.Rpc.IQuitCombatData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IQuitCombatData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuitCombatData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuitCombatData;
            public static toObject(message: POGOProtos.Rpc.QuitCombatData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuitCombatOutProto {
            result?: (POGOProtos.Rpc.QuitCombatOutProto.Result|null);
            combat?: (POGOProtos.Rpc.ICombatProto|null);
        }

        class QuitCombatOutProto implements IQuitCombatOutProto {
            constructor(properties?: POGOProtos.Rpc.IQuitCombatOutProto);
            public result: POGOProtos.Rpc.QuitCombatOutProto.Result;
            public combat?: (POGOProtos.Rpc.ICombatProto|null);
            public static encode(message: POGOProtos.Rpc.IQuitCombatOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuitCombatOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuitCombatOutProto;
            public static toObject(message: POGOProtos.Rpc.QuitCombatOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace QuitCombatOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_COMBAT_NOT_FOUND = 2,
                ERROR_INVALID_COMBAT_STATE = 3,
                ERROR_PLAYER_NOT_IN_COMBAT = 4
            }
        }

        interface IQuitCombatProto {
            combat_id?: (string|null);
        }

        class QuitCombatProto implements IQuitCombatProto {
            constructor(properties?: POGOProtos.Rpc.IQuitCombatProto);
            public combat_id: string;
            public static encode(message: POGOProtos.Rpc.IQuitCombatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuitCombatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuitCombatProto;
            public static toObject(message: POGOProtos.Rpc.QuitCombatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IQuitCombatResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            quit_combat_out_proto?: (POGOProtos.Rpc.IQuitCombatOutProto|null);
        }

        class QuitCombatResponseData implements IQuitCombatResponseData {
            constructor(properties?: POGOProtos.Rpc.IQuitCombatResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public quit_combat_out_proto?: (POGOProtos.Rpc.IQuitCombatOutProto|null);
            public static encode(message: POGOProtos.Rpc.IQuitCombatResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.QuitCombatResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.QuitCombatResponseData;
            public static toObject(message: POGOProtos.Rpc.QuitCombatResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidClientLog {
            header?: (POGOProtos.Rpc.IRaidLogHeader|null);
            entries?: (POGOProtos.Rpc.ILogEntry[]|null);
        }

        class RaidClientLog implements IRaidClientLog {
            constructor(properties?: POGOProtos.Rpc.IRaidClientLog);
            public header?: (POGOProtos.Rpc.IRaidLogHeader|null);
            public entries: POGOProtos.Rpc.ILogEntry[];
            public static encode(message: POGOProtos.Rpc.IRaidClientLog, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidClientLog;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidClientLog;
            public static toObject(message: POGOProtos.Rpc.RaidClientLog, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidClientSettingsProto {
            remote_raid_enabled?: (boolean|null);
            max_remote_raid_passes?: (number|null);
            remote_damage_modifier?: (number|null);
            remote_raids_min_player_level?: (number|null);
            max_num_friend_invites?: (number|null);
            friend_invite_cutoff_time_sec?: (number|null);
            can_invite_friends_in_person?: (boolean|null);
            can_invite_friends_remotely?: (boolean|null);
            max_players_per_lobby?: (number|null);
            max_remote_players_per_lobby?: (number|null);
            invite_cooldown_duration_millis?: (number|Long|null);
            max_num_friend_invites_per_action?: (number|null);
            unsupported_raid_levels_for_friend_invites?: (POGOProtos.Rpc.RaidLevel[]|null);
            unsupported_remote_raid_levels?: (POGOProtos.Rpc.RaidLevel[]|null);
            is_nearby_raid_notification_disabled?: (boolean|null);
            remote_raid_iap_prompt_skus?: (string[]|null);
            raid_level_music_overrides?: (POGOProtos.Rpc.IRaidMusicOverrideConfig[]|null);
            raid_feature_flags?: (POGOProtos.Rpc.IRaidFeatureFlags|null);
            boot_raid_enabled?: (boolean|null);
            friend_requests_enabled?: (boolean|null);
            remote_raid_distance_validation?: (boolean|null);
            popup_time_ms?: (number|null);
            failed_friend_invite_info_enabled?: (boolean|null);
            min_players_to_boot?: (number|null);
            boot_cutoff_ms?: (number|null);
            boot_solo_ms?: (number|null);
            ob_int32?: (number|null);
            ob_bool?: (boolean|null);
            pokemon_music_overrides?: (POGOProtos.Rpc.IPokemonMusicOverrideConfig[]|null);
        }

        class RaidClientSettingsProto implements IRaidClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRaidClientSettingsProto);
            public remote_raid_enabled: boolean;
            public max_remote_raid_passes: number;
            public remote_damage_modifier: number;
            public remote_raids_min_player_level: number;
            public max_num_friend_invites: number;
            public friend_invite_cutoff_time_sec: number;
            public can_invite_friends_in_person: boolean;
            public can_invite_friends_remotely: boolean;
            public max_players_per_lobby: number;
            public max_remote_players_per_lobby: number;
            public invite_cooldown_duration_millis: (number|Long);
            public max_num_friend_invites_per_action: number;
            public unsupported_raid_levels_for_friend_invites: POGOProtos.Rpc.RaidLevel[];
            public unsupported_remote_raid_levels: POGOProtos.Rpc.RaidLevel[];
            public is_nearby_raid_notification_disabled: boolean;
            public remote_raid_iap_prompt_skus: string[];
            public raid_level_music_overrides: POGOProtos.Rpc.IRaidMusicOverrideConfig[];
            public raid_feature_flags?: (POGOProtos.Rpc.IRaidFeatureFlags|null);
            public boot_raid_enabled: boolean;
            public friend_requests_enabled: boolean;
            public remote_raid_distance_validation: boolean;
            public popup_time_ms: number;
            public failed_friend_invite_info_enabled: boolean;
            public min_players_to_boot: number;
            public boot_cutoff_ms: number;
            public boot_solo_ms: number;
            public ob_int32: number;
            public ob_bool: boolean;
            public pokemon_music_overrides: POGOProtos.Rpc.IPokemonMusicOverrideConfig[];
            public static encode(message: POGOProtos.Rpc.IRaidClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RaidClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidCreateDetail {
            is_exclusive?: (boolean|null);
            is_mega?: (boolean|null);
            player_captured_s2_cell_id?: (number|Long|null);
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
        }

        class RaidCreateDetail implements IRaidCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IRaidCreateDetail);
            public is_exclusive: boolean;
            public is_mega: boolean;
            public player_captured_s2_cell_id: (number|Long);
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public static encode(message: POGOProtos.Rpc.IRaidCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidCreateDetail;
            public static toObject(message: POGOProtos.Rpc.RaidCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidDetails {
            fort_id?: (string|null);
            raid_seed?: (number|Long|null);
            lat?: (number|null);
            lng?: (number|null);
            fort_name?: (string|null);
            image_url?: (string|null);
            raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
        }

        class RaidDetails implements IRaidDetails {
            constructor(properties?: POGOProtos.Rpc.IRaidDetails);
            public fort_id: string;
            public raid_seed: (number|Long);
            public lat: number;
            public lng: number;
            public fort_name: string;
            public image_url: string;
            public raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            public static encode(message: POGOProtos.Rpc.IRaidDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidDetails;
            public static toObject(message: POGOProtos.Rpc.RaidDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidEggNotificationTelemetry {
            notification_sent_datetime?: (string|null);
            notification_clicked_datetime?: (string|null);
            raid_seed?: (number|Long|null);
        }

        class RaidEggNotificationTelemetry implements IRaidEggNotificationTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRaidEggNotificationTelemetry);
            public notification_sent_datetime: string;
            public notification_clicked_datetime: string;
            public raid_seed: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRaidEggNotificationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidEggNotificationTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidEggNotificationTelemetry;
            public static toObject(message: POGOProtos.Rpc.RaidEggNotificationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidEncounterProto {
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            encounter_id?: (number|Long|null);
            spawnpoint_id?: (string|null);
            capture_probabilities?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            throws_remaining?: (number|null);
            raid_level?: (POGOProtos.Rpc.RaidLevel|null);
            fort_id?: (string|null);
            is_event_legendary?: (boolean|null);
            raid_ball?: (POGOProtos.Rpc.Item|null);
            applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto[]|null);
        }

        class RaidEncounterProto implements IRaidEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IRaidEncounterProto);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public encounter_id: (number|Long);
            public spawnpoint_id: string;
            public capture_probabilities?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public throws_remaining: number;
            public raid_level: POGOProtos.Rpc.RaidLevel;
            public fort_id: string;
            public is_event_legendary: boolean;
            public raid_ball: POGOProtos.Rpc.Item;
            public applied_bonus: POGOProtos.Rpc.IAppliedBonusProto[];
            public static encode(message: POGOProtos.Rpc.IRaidEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidEncounterProto;
            public static toObject(message: POGOProtos.Rpc.RaidEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidEndData {
            type?: (POGOProtos.Rpc.RaidEndData.Type|null);
        }

        class RaidEndData implements IRaidEndData {
            constructor(properties?: POGOProtos.Rpc.IRaidEndData);
            public type: POGOProtos.Rpc.RaidEndData.Type;
            public static encode(message: POGOProtos.Rpc.IRaidEndData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidEndData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidEndData;
            public static toObject(message: POGOProtos.Rpc.RaidEndData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RaidEndData {

            enum Type {
                NO_END = 0,
                LEAVE_LOBBY = 1,
                TIME_OUT = 2,
                ENCOUNTER_POKEMON_NOT_CAUGHT = 3,
                ENCOUNTER_POKEMON_CAUGHT = 4,
                WITH_ERROR = 5
            }
        }

        interface IRaidFeatureFlags {
            use_cached_raid_boss_pokemon?: (boolean|null);
            raid_experiment?: (POGOProtos.Rpc.BattleExperiment[]|null);
            usable_items?: (POGOProtos.Rpc.IItemProto[]|null);
            usable_trainer_abilities?: (POGOProtos.Rpc.TrainerAbility[]|null);
            enable_dodge_swipe_vfx_bread_battle?: (boolean|null);
            enable_dodge_swipe_vfx_raids?: (boolean|null);
        }

        class RaidFeatureFlags implements IRaidFeatureFlags {
            constructor(properties?: POGOProtos.Rpc.IRaidFeatureFlags);
            public use_cached_raid_boss_pokemon: boolean;
            public raid_experiment: POGOProtos.Rpc.BattleExperiment[];
            public usable_items: POGOProtos.Rpc.IItemProto[];
            public usable_trainer_abilities: POGOProtos.Rpc.TrainerAbility[];
            public enable_dodge_swipe_vfx_bread_battle: boolean;
            public enable_dodge_swipe_vfx_raids: boolean;
            public static encode(message: POGOProtos.Rpc.IRaidFeatureFlags, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidFeatureFlags;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidFeatureFlags;
            public static toObject(message: POGOProtos.Rpc.RaidFeatureFlags, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidFriendActivityProto {
            fort_id?: (string|null);
            raid_seed?: (number|Long|null);
            raid_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            raid_level?: (POGOProtos.Rpc.RaidLevel|null);
            end_time_ms?: (number|Long|null);
        }

        class RaidFriendActivityProto implements IRaidFriendActivityProto {
            constructor(properties?: POGOProtos.Rpc.IRaidFriendActivityProto);
            public fort_id: string;
            public raid_seed: (number|Long);
            public raid_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public raid_level: POGOProtos.Rpc.RaidLevel;
            public end_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRaidFriendActivityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidFriendActivityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidFriendActivityProto;
            public static toObject(message: POGOProtos.Rpc.RaidFriendActivityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidInfoProto {
            raid_seed?: (number|Long|null);
            raid_spawn_ms?: (number|Long|null);
            raid_battle_ms?: (number|Long|null);
            raid_end_ms?: (number|Long|null);
            raid_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            raid_level?: (POGOProtos.Rpc.RaidLevel|null);
            complete?: (boolean|null);
            is_raid_hidden?: (boolean|null);
            is_scheduled_raid?: (boolean|null);
            is_free?: (boolean|null);
            campaign_id?: (string|null);
            raid_ball?: (POGOProtos.Rpc.Item|null);
            visual_effects?: (POGOProtos.Rpc.IRaidVisualEffect[]|null);
            raid_visual_level?: (number|Long|null);
            raid_visual_plaque_type?: (POGOProtos.Rpc.RaidVisualType|null);
            raid_plaque_pip_style?: (POGOProtos.Rpc.RaidPlaquePipStyle|null);
            mascot_character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter|null);
            boot_raid_enabled?: (boolean|null);
            reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            default_raid_ball?: (POGOProtos.Rpc.Item|null);
        }

        class RaidInfoProto implements IRaidInfoProto {
            constructor(properties?: POGOProtos.Rpc.IRaidInfoProto);
            public raid_seed: (number|Long);
            public raid_spawn_ms: (number|Long);
            public raid_battle_ms: (number|Long);
            public raid_end_ms: (number|Long);
            public raid_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public raid_level: POGOProtos.Rpc.RaidLevel;
            public complete: boolean;
            public is_raid_hidden: boolean;
            public is_scheduled_raid: boolean;
            public is_free: boolean;
            public campaign_id: string;
            public raid_ball: POGOProtos.Rpc.Item;
            public visual_effects: POGOProtos.Rpc.IRaidVisualEffect[];
            public raid_visual_level: (number|Long);
            public raid_visual_plaque_type: POGOProtos.Rpc.RaidVisualType;
            public raid_plaque_pip_style: POGOProtos.Rpc.RaidPlaquePipStyle;
            public mascot_character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter;
            public boot_raid_enabled: boolean;
            public reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public default_raid_ball: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IRaidInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidInfoProto;
            public static toObject(message: POGOProtos.Rpc.RaidInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidInteractionSourceTelemetry {
            interaction_source?: (POGOProtos.Rpc.RaidInteractionSource|null);
            is_nearby_menu_v2_enabled?: (boolean|null);
            raid_seed?: (number|Long|null);
        }

        class RaidInteractionSourceTelemetry implements IRaidInteractionSourceTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRaidInteractionSourceTelemetry);
            public interaction_source: POGOProtos.Rpc.RaidInteractionSource;
            public is_nearby_menu_v2_enabled: boolean;
            public raid_seed: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRaidInteractionSourceTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidInteractionSourceTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidInteractionSourceTelemetry;
            public static toObject(message: POGOProtos.Rpc.RaidInteractionSourceTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidInvitationDetails {
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            raid_seed?: (number|Long|null);
            raid_invitation_expire_ms?: (number|Long|null);
            raid_level?: (POGOProtos.Rpc.RaidLevel|null);
            gym_name?: (string|null);
            image_url?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            raid_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            raid_pokemon_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            inviter_id?: (string|null);
            inviter_nickname?: (string|null);
            inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            inviter_team?: (POGOProtos.Rpc.Team|null);
            raid_pokemon_temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            raid_pokemon_costume?: (POGOProtos.Rpc.PokemonDisplayProto.Costume|null);
            raid_visual_level?: (number|Long|null);
            inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class RaidInvitationDetails implements IRaidInvitationDetails {
            constructor(properties?: POGOProtos.Rpc.IRaidInvitationDetails);
            public gym_id: string;
            public lobby_id: number[];
            public raid_seed: (number|Long);
            public raid_invitation_expire_ms: (number|Long);
            public raid_level: POGOProtos.Rpc.RaidLevel;
            public gym_name: string;
            public image_url: string;
            public latitude: number;
            public longitude: number;
            public raid_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public raid_pokemon_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public inviter_id: string;
            public inviter_nickname: string;
            public inviter_avatar?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public inviter_team: POGOProtos.Rpc.Team;
            public raid_pokemon_temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public raid_pokemon_costume: POGOProtos.Rpc.PokemonDisplayProto.Costume;
            public raid_visual_level: (number|Long);
            public inviter_neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.IRaidInvitationDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidInvitationDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidInvitationDetails;
            public static toObject(message: POGOProtos.Rpc.RaidInvitationDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidInviteFriendsSettingsProto {
            raid_invite_min_level?: (number|null);
        }

        class RaidInviteFriendsSettingsProto implements IRaidInviteFriendsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRaidInviteFriendsSettingsProto);
            public raid_invite_min_level: number;
            public static encode(message: POGOProtos.Rpc.IRaidInviteFriendsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidInviteFriendsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidInviteFriendsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RaidInviteFriendsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidJoinInformationProto {
            lobby_creation_ms?: (number|Long|null);
            lobby_end_join_ms?: (number|Long|null);
        }

        class RaidJoinInformationProto implements IRaidJoinInformationProto {
            constructor(properties?: POGOProtos.Rpc.IRaidJoinInformationProto);
            public lobby_creation_ms: (number|Long);
            public lobby_end_join_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRaidJoinInformationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidJoinInformationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidJoinInformationProto;
            public static toObject(message: POGOProtos.Rpc.RaidJoinInformationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidLobbyAvailabilityInformationProto {
            raid_lobby_unavailable?: (boolean|null);
        }

        class RaidLobbyAvailabilityInformationProto implements IRaidLobbyAvailabilityInformationProto {
            constructor(properties?: POGOProtos.Rpc.IRaidLobbyAvailabilityInformationProto);
            public raid_lobby_unavailable: boolean;
            public static encode(message: POGOProtos.Rpc.IRaidLobbyAvailabilityInformationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidLobbyAvailabilityInformationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidLobbyAvailabilityInformationProto;
            public static toObject(message: POGOProtos.Rpc.RaidLobbyAvailabilityInformationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidLobbyCounterData {
            gym_id?: (string|null);
            player_count?: (number|null);
            lobby_join_end_ms?: (number|Long|null);
        }

        class RaidLobbyCounterData implements IRaidLobbyCounterData {
            constructor(properties?: POGOProtos.Rpc.IRaidLobbyCounterData);
            public gym_id: string;
            public player_count: number;
            public lobby_join_end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRaidLobbyCounterData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidLobbyCounterData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidLobbyCounterData;
            public static toObject(message: POGOProtos.Rpc.RaidLobbyCounterData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidLobbyCounterRequest {
            gym_id?: (string|null);
        }

        class RaidLobbyCounterRequest implements IRaidLobbyCounterRequest {
            constructor(properties?: POGOProtos.Rpc.IRaidLobbyCounterRequest);
            public gym_id: string;
            public static encode(message: POGOProtos.Rpc.IRaidLobbyCounterRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidLobbyCounterRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidLobbyCounterRequest;
            public static toObject(message: POGOProtos.Rpc.RaidLobbyCounterRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidLobbyCounterSettingsProto {
            polling_enabled?: (boolean|null);
            polling_interval_ms?: (number|null);
            subscribe_enabled?: (boolean|null);
            publish_enabled?: (boolean|null);
            map_display_enabled?: (boolean|null);
            nearby_display_enabled?: (boolean|null);
            show_counter_radius_meters?: (number|null);
            subscribe_s2_level?: (number|null);
            max_count_to_update?: (number|null);
            subscription_namespace?: (string|null);
            polling_radius_meters?: (number|null);
            publish_cutoff_time_ms?: (number|null);
        }

        class RaidLobbyCounterSettingsProto implements IRaidLobbyCounterSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRaidLobbyCounterSettingsProto);
            public polling_enabled: boolean;
            public polling_interval_ms: number;
            public subscribe_enabled: boolean;
            public publish_enabled: boolean;
            public map_display_enabled: boolean;
            public nearby_display_enabled: boolean;
            public show_counter_radius_meters: number;
            public subscribe_s2_level: number;
            public max_count_to_update: number;
            public subscription_namespace: string;
            public polling_radius_meters: number;
            public publish_cutoff_time_ms: number;
            public static encode(message: POGOProtos.Rpc.IRaidLobbyCounterSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidLobbyCounterSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidLobbyCounterSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RaidLobbyCounterSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidLogHeader {
            gym_id?: (string|null);
            raid_seed?: (number|Long|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
            time_root_ms?: (number|Long|null);
            raid_battle_id?: (string|null);
        }

        class RaidLogHeader implements IRaidLogHeader {
            constructor(properties?: POGOProtos.Rpc.IRaidLogHeader);
            public gym_id: string;
            public raid_seed: (number|Long);
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public time_root_ms: (number|Long);
            public raid_battle_id: string;
            public static encode(message: POGOProtos.Rpc.IRaidLogHeader, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidLogHeader;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidLogHeader;
            public static toObject(message: POGOProtos.Rpc.RaidLogHeader, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidMusicOverrideConfig {
            raid_level?: (POGOProtos.Rpc.RaidLevel|null);
            battle_music_key?: (string|null);
        }

        class RaidMusicOverrideConfig implements IRaidMusicOverrideConfig {
            constructor(properties?: POGOProtos.Rpc.IRaidMusicOverrideConfig);
            public raid_level: POGOProtos.Rpc.RaidLevel;
            public battle_music_key: string;
            public static encode(message: POGOProtos.Rpc.IRaidMusicOverrideConfig, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidMusicOverrideConfig;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidMusicOverrideConfig;
            public static toObject(message: POGOProtos.Rpc.RaidMusicOverrideConfig, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidParticipantProto {
            join_information?: (POGOProtos.Rpc.IRaidJoinInformationProto|null);
            lobby_availability?: (POGOProtos.Rpc.IRaidLobbyAvailabilityInformationProto|null);
            player_id?: (string|null);
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            latitude?: (number|null);
            longitude?: (number|null);
        }

        class RaidParticipantProto implements IRaidParticipantProto {
            constructor(properties?: POGOProtos.Rpc.IRaidParticipantProto);
            public join_information?: (POGOProtos.Rpc.IRaidJoinInformationProto|null);
            public lobby_availability?: (POGOProtos.Rpc.IRaidLobbyAvailabilityInformationProto|null);
            public player_id: string;
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public raid_info?: (POGOProtos.Rpc.IRaidInfoProto|null);
            public latitude: number;
            public longitude: number;
            public ActivityInformation?: ("join_information"|"lobby_availability");
            public static encode(message: POGOProtos.Rpc.IRaidParticipantProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidParticipantProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidParticipantProto;
            public static toObject(message: POGOProtos.Rpc.RaidParticipantProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidPlayerStatProto {
            stat_id?: (POGOProtos.Rpc.RaidPlayerStatProto.StatType|null);
            player_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            stat_value?: (number|null);
            pokemon?: (POGOProtos.Rpc.IRaidPlayerStatsPokemonProto|null);
            featured?: (boolean|null);
            attacker_index?: (number|null);
        }

        class RaidPlayerStatProto implements IRaidPlayerStatProto {
            constructor(properties?: POGOProtos.Rpc.IRaidPlayerStatProto);
            public stat_id: POGOProtos.Rpc.RaidPlayerStatProto.StatType;
            public player_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
            public stat_value: number;
            public pokemon?: (POGOProtos.Rpc.IRaidPlayerStatsPokemonProto|null);
            public featured: boolean;
            public attacker_index: number;
            public static encode(message: POGOProtos.Rpc.IRaidPlayerStatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidPlayerStatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidPlayerStatProto;
            public static toObject(message: POGOProtos.Rpc.RaidPlayerStatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RaidPlayerStatProto {

            enum StatType {
                UNSET_RAID_STAT = 0,
                FINAL_STRIKE_PLAYER = 1,
                DAMAGE_DEALT_PLAYER = 2,
                REMOTE_DISTANCE_PLAYER = 4,
                USE_MEGA_EVO_PLAYER = 5,
                USE_BUDDY_PLAYER = 6,
                CUSTOMIZE_AVATAR_PLAYER = 7,
                NUM_FRIENDS_IN_RAID_PLAYER = 8,
                RECENT_WALKING_DISTANCE_PLAYER = 10,
                NUM_CHARGED_ATTACKS_PLAYER = 11,
                SURVIVAL_DURATION_POKEMON = 15,
                POKEMON_HEIGHT_POKEMON = 22
            }
        }

        interface IRaidPlayerStatsGlobalSettingsProto {
            enabled?: (boolean|null);
            enabled_pokemon?: (boolean|null);
            enabled_avatar_spin?: (boolean|null);
        }

        class RaidPlayerStatsGlobalSettingsProto implements IRaidPlayerStatsGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRaidPlayerStatsGlobalSettingsProto);
            public enabled: boolean;
            public enabled_pokemon: boolean;
            public enabled_avatar_spin: boolean;
            public static encode(message: POGOProtos.Rpc.IRaidPlayerStatsGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidPlayerStatsGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidPlayerStatsGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RaidPlayerStatsGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidPlayerStatsPokemonProto {
            holo_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
        }

        class RaidPlayerStatsPokemonProto implements IRaidPlayerStatsPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IRaidPlayerStatsPokemonProto);
            public holo_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IRaidPlayerStatsPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidPlayerStatsPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidPlayerStatsPokemonProto;
            public static toObject(message: POGOProtos.Rpc.RaidPlayerStatsPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidPlayerStatsProto {
            stats?: (POGOProtos.Rpc.IRaidPlayerStatProto[]|null);
        }

        class RaidPlayerStatsProto implements IRaidPlayerStatsProto {
            constructor(properties?: POGOProtos.Rpc.IRaidPlayerStatsProto);
            public stats: POGOProtos.Rpc.IRaidPlayerStatProto[];
            public static encode(message: POGOProtos.Rpc.IRaidPlayerStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidPlayerStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidPlayerStatsProto;
            public static toObject(message: POGOProtos.Rpc.RaidPlayerStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidProto {
            raid_seed?: (number|Long|null);
            started_ms?: (number|Long|null);
            completed_ms?: (number|Long|null);
            encounter_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            completed_battle?: (boolean|null);
            received_rewards?: (boolean|null);
            finished_encounter?: (boolean|null);
            received_default_rewards?: (boolean|null);
            incremented_raid_friends?: (boolean|null);
            completed_battle_ms?: (number|Long|null);
            is_remote?: (boolean|null);
            reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class RaidProto implements IRaidProto {
            constructor(properties?: POGOProtos.Rpc.IRaidProto);
            public raid_seed: (number|Long);
            public started_ms: (number|Long);
            public completed_ms: (number|Long);
            public encounter_pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public completed_battle: boolean;
            public received_rewards: boolean;
            public finished_encounter: boolean;
            public received_default_rewards: boolean;
            public incremented_raid_friends: boolean;
            public completed_battle_ms: (number|Long);
            public is_remote: boolean;
            public reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IRaidProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidProto;
            public static toObject(message: POGOProtos.Rpc.RaidProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidRewardsLogEntry {
            result?: (POGOProtos.Rpc.RaidRewardsLogEntry.Result|null);
            items?: (POGOProtos.Rpc.IItemProto[]|null);
            default_rewards?: (POGOProtos.Rpc.IItemProto[]|null);
            stardust?: (number|null);
            stickers?: (POGOProtos.Rpc.ILootItemProto[]|null);
            is_mega?: (boolean|null);
            mega_resource?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            temp_evo_raid_status?: (POGOProtos.Rpc.RaidRewardsLogEntry.TempEvoRaidStatus|null);
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            defender_alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment|null);
            candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
        }

        class RaidRewardsLogEntry implements IRaidRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IRaidRewardsLogEntry);
            public result: POGOProtos.Rpc.RaidRewardsLogEntry.Result;
            public items: POGOProtos.Rpc.IItemProto[];
            public default_rewards: POGOProtos.Rpc.IItemProto[];
            public stardust: number;
            public stickers: POGOProtos.Rpc.ILootItemProto[];
            public is_mega: boolean;
            public mega_resource?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public temp_evo_raid_status: POGOProtos.Rpc.RaidRewardsLogEntry.TempEvoRaidStatus;
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public defender_alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment;
            public candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public xl_candy?: (POGOProtos.Rpc.IPokemonCandyRewardProto|null);
            public static encode(message: POGOProtos.Rpc.IRaidRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.RaidRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RaidRewardsLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }

            enum TempEvoRaidStatus {
                NONE = 0,
                IS_MEGA = 1,
                IS_PRIMAL = 2
            }
        }

        interface IRaidTelemetry {
            raid_telemetry_id?: (POGOProtos.Rpc.RaidTelemetryIds|null);
            bundle_version?: (string|null);
            time_since_enter_raid?: (number|null);
            time_since_last_raid_telemetry?: (number|null);
            raid_level?: (number|null);
            private_lobby?: (boolean|null);
            ticket_item?: (string|null);
            num_players_in_lobby?: (number|null);
            battle_party_number?: (number|null);
        }

        class RaidTelemetry implements IRaidTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRaidTelemetry);
            public raid_telemetry_id: POGOProtos.Rpc.RaidTelemetryIds;
            public bundle_version: string;
            public time_since_enter_raid: number;
            public time_since_last_raid_telemetry: number;
            public raid_level: number;
            public private_lobby: boolean;
            public ticket_item: string;
            public num_players_in_lobby: number;
            public battle_party_number: number;
            public static encode(message: POGOProtos.Rpc.IRaidTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidTelemetry;
            public static toObject(message: POGOProtos.Rpc.RaidTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidTicketProto {
            ticket_id?: (string|null);
            item?: (POGOProtos.Rpc.Item|null);
        }

        class RaidTicketProto implements IRaidTicketProto {
            constructor(properties?: POGOProtos.Rpc.IRaidTicketProto);
            public ticket_id: string;
            public item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IRaidTicketProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidTicketProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidTicketProto;
            public static toObject(message: POGOProtos.Rpc.RaidTicketProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidTicketsProto {
            raid_ticket?: (POGOProtos.Rpc.IRaidTicketProto[]|null);
        }

        class RaidTicketsProto implements IRaidTicketsProto {
            constructor(properties?: POGOProtos.Rpc.IRaidTicketsProto);
            public raid_ticket: POGOProtos.Rpc.IRaidTicketProto[];
            public static encode(message: POGOProtos.Rpc.IRaidTicketsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidTicketsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidTicketsProto;
            public static toObject(message: POGOProtos.Rpc.RaidTicketsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidVisualEffect {
            effect_asset_key?: (string|null);
            start_millis?: (number|Long|null);
            stop_millis?: (number|Long|null);
        }

        class RaidVisualEffect implements IRaidVisualEffect {
            constructor(properties?: POGOProtos.Rpc.IRaidVisualEffect);
            public effect_asset_key: string;
            public start_millis: (number|Long);
            public stop_millis: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRaidVisualEffect, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidVisualEffect;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidVisualEffect;
            public static toObject(message: POGOProtos.Rpc.RaidVisualEffect, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidVnextClientLogProto {
            header?: (POGOProtos.Rpc.IRaidLogHeader|null);
            entries?: (POGOProtos.Rpc.RaidVnextClientLogProto.IVnextLogEntryProto[]|null);
        }

        class RaidVnextClientLogProto implements IRaidVnextClientLogProto {
            constructor(properties?: POGOProtos.Rpc.IRaidVnextClientLogProto);
            public header?: (POGOProtos.Rpc.IRaidLogHeader|null);
            public entries: POGOProtos.Rpc.RaidVnextClientLogProto.IVnextLogEntryProto[];
            public static encode(message: POGOProtos.Rpc.IRaidVnextClientLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidVnextClientLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidVnextClientLogProto;
            public static toObject(message: POGOProtos.Rpc.RaidVnextClientLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RaidVnextClientLogProto {

            interface IVnextLogEntryProto {
                header?: (POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.IVnextHeaderProto|null);
            }

            class VnextLogEntryProto implements IVnextLogEntryProto {
                constructor(properties?: POGOProtos.Rpc.RaidVnextClientLogProto.IVnextLogEntryProto);
                public header?: (POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.IVnextHeaderProto|null);
                public static encode(message: POGOProtos.Rpc.RaidVnextClientLogProto.IVnextLogEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto;
                public static toObject(message: POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace VnextLogEntryProto {

                interface IVnextHeaderProto {
                    type?: (POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.VnextHeaderProto.HeaderType|null);
                    time_now_offset_ms?: (number|null);
                }

                class VnextHeaderProto implements IVnextHeaderProto {
                    constructor(properties?: POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.IVnextHeaderProto);
                    public type: POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.VnextHeaderProto.HeaderType;
                    public time_now_offset_ms: number;
                    public static encode(message: POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.IVnextHeaderProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.VnextHeaderProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.VnextHeaderProto;
                    public static toObject(message: POGOProtos.Rpc.RaidVnextClientLogProto.VnextLogEntryProto.VnextHeaderProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace VnextHeaderProto {

                    enum HeaderType {
                        NO_TYPE = 0
                    }
                }
            }
        }

        interface IRangeProto {
            min?: (number|null);
            max?: (number|null);
        }

        class RangeProto implements IRangeProto {
            constructor(properties?: POGOProtos.Rpc.IRangeProto);
            public min: number;
            public max: number;
            public static encode(message: POGOProtos.Rpc.IRangeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RangeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RangeProto;
            public static toObject(message: POGOProtos.Rpc.RangeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRateRouteOutProto {
            result?: (POGOProtos.Rpc.RateRouteOutProto.Result|null);
        }

        class RateRouteOutProto implements IRateRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.IRateRouteOutProto);
            public result: POGOProtos.Rpc.RateRouteOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IRateRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RateRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RateRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.RateRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RateRouteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ROUTE_NOT_FOUND = 2,
                ERROR_RATE_LIMITED = 3,
                ERROR_ALREADY_RATED = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IRateRouteProto {
            star_rating?: (number|null);
            route_id?: (string|null);
        }

        class RateRouteProto implements IRateRouteProto {
            constructor(properties?: POGOProtos.Rpc.IRateRouteProto);
            public star_rating: number;
            public route_id: string;
            public static encode(message: POGOProtos.Rpc.IRateRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RateRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RateRouteProto;
            public static toObject(message: POGOProtos.Rpc.RateRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReadPointOfInterestDescriptionTelemetry {
            result?: (string|null);
            fort_id?: (string|null);
            fort_type?: (number|null);
            partner_id?: (string|null);
            campaign_id?: (string|null);
        }

        class ReadPointOfInterestDescriptionTelemetry implements IReadPointOfInterestDescriptionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IReadPointOfInterestDescriptionTelemetry);
            public result: string;
            public fort_id: string;
            public fort_type: number;
            public partner_id: string;
            public campaign_id: string;
            public static encode(message: POGOProtos.Rpc.IReadPointOfInterestDescriptionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReadPointOfInterestDescriptionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReadPointOfInterestDescriptionTelemetry;
            public static toObject(message: POGOProtos.Rpc.ReadPointOfInterestDescriptionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReadQuestDialogOutProto {
            status?: (POGOProtos.Rpc.ReadQuestDialogOutProto.Status|null);
        }

        class ReadQuestDialogOutProto implements IReadQuestDialogOutProto {
            constructor(properties?: POGOProtos.Rpc.IReadQuestDialogOutProto);
            public status: POGOProtos.Rpc.ReadQuestDialogOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IReadQuestDialogOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReadQuestDialogOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReadQuestDialogOutProto;
            public static toObject(message: POGOProtos.Rpc.ReadQuestDialogOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReadQuestDialogOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_QUEST_NOT_FOUND = 2,
                ERROR_NO_DIALOG = 3
            }
        }

        interface IReadQuestDialogProto {
            quest_id?: (string|null);
        }

        class ReadQuestDialogProto implements IReadQuestDialogProto {
            constructor(properties?: POGOProtos.Rpc.IReadQuestDialogProto);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.IReadQuestDialogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReadQuestDialogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReadQuestDialogProto;
            public static toObject(message: POGOProtos.Rpc.ReadQuestDialogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReassignPlayerOutProto {
            result?: (POGOProtos.Rpc.ReassignPlayerOutProto.Result|null);
            reassigned_instance?: (number|null);
        }

        class ReassignPlayerOutProto implements IReassignPlayerOutProto {
            constructor(properties?: POGOProtos.Rpc.IReassignPlayerOutProto);
            public result: POGOProtos.Rpc.ReassignPlayerOutProto.Result;
            public reassigned_instance: number;
            public static encode(message: POGOProtos.Rpc.IReassignPlayerOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReassignPlayerOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReassignPlayerOutProto;
            public static toObject(message: POGOProtos.Rpc.ReassignPlayerOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReassignPlayerOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IReassignPlayerProto {
            current_instance?: (number|null);
        }

        class ReassignPlayerProto implements IReassignPlayerProto {
            constructor(properties?: POGOProtos.Rpc.IReassignPlayerProto);
            public current_instance: number;
            public static encode(message: POGOProtos.Rpc.IReassignPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReassignPlayerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReassignPlayerProto;
            public static toObject(message: POGOProtos.Rpc.ReassignPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRecallRouteDraftOutProto {
            result?: (POGOProtos.Rpc.RecallRouteDraftOutProto.Result|null);
            recalled_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
        }

        class RecallRouteDraftOutProto implements IRecallRouteDraftOutProto {
            constructor(properties?: POGOProtos.Rpc.IRecallRouteDraftOutProto);
            public result: POGOProtos.Rpc.RecallRouteDraftOutProto.Result;
            public recalled_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            public static encode(message: POGOProtos.Rpc.IRecallRouteDraftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RecallRouteDraftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RecallRouteDraftOutProto;
            public static toObject(message: POGOProtos.Rpc.RecallRouteDraftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RecallRouteDraftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_ROUTE = 3,
                ERROR_MODERATION_FAILURE = 4,
                ERROR_ALREADY_RECALLED = 5,
                ERROR_TOO_MANY_RECALLS = 6
            }
        }

        interface IRecallRouteDraftProto {
            route_id?: (string|null);
            delete_route_draft?: (boolean|null);
        }

        class RecallRouteDraftProto implements IRecallRouteDraftProto {
            constructor(properties?: POGOProtos.Rpc.IRecallRouteDraftProto);
            public route_id: string;
            public delete_route_draft: boolean;
            public static encode(message: POGOProtos.Rpc.IRecallRouteDraftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RecallRouteDraftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RecallRouteDraftProto;
            public static toObject(message: POGOProtos.Rpc.RecallRouteDraftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRecommendedSearchProto {
            search_label?: (string|null);
            prepended_search_string?: (string|null);
            search_key?: (string|null);
            appended_search_string?: (string|null);
        }

        class RecommendedSearchProto implements IRecommendedSearchProto {
            constructor(properties?: POGOProtos.Rpc.IRecommendedSearchProto);
            public search_label: string;
            public prepended_search_string: string;
            public search_key: string;
            public appended_search_string: string;
            public static encode(message: POGOProtos.Rpc.IRecommendedSearchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RecommendedSearchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RecommendedSearchProto;
            public static toObject(message: POGOProtos.Rpc.RecommendedSearchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRectProto {
            lo?: (POGOProtos.Rpc.IPointProto|null);
            hi?: (POGOProtos.Rpc.IPointProto|null);
        }

        class RectProto implements IRectProto {
            constructor(properties?: POGOProtos.Rpc.IRectProto);
            public lo?: (POGOProtos.Rpc.IPointProto|null);
            public hi?: (POGOProtos.Rpc.IPointProto|null);
            public static encode(message: POGOProtos.Rpc.IRectProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RectProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RectProto;
            public static toObject(message: POGOProtos.Rpc.RectProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRecurringChallengeScheduleProto {
            timezone_id?: (string|null);
            day_and_time_start_time?: (POGOProtos.Rpc.IDayOfWeekAndTimeProto|null);
            start_timestamp_ms?: (number|Long|null);
            day_and_time_end_time?: (POGOProtos.Rpc.IDayOfWeekAndTimeProto|null);
            end_timestamp_ms?: (number|Long|null);
        }

        class RecurringChallengeScheduleProto implements IRecurringChallengeScheduleProto {
            constructor(properties?: POGOProtos.Rpc.IRecurringChallengeScheduleProto);
            public timezone_id: string;
            public day_and_time_start_time?: (POGOProtos.Rpc.IDayOfWeekAndTimeProto|null);
            public start_timestamp_ms?: (number|Long|null);
            public day_and_time_end_time?: (POGOProtos.Rpc.IDayOfWeekAndTimeProto|null);
            public end_timestamp_ms?: (number|Long|null);
            public StartTime?: ("day_and_time_start_time"|"start_timestamp_ms");
            public EndTime?: ("day_and_time_end_time"|"end_timestamp_ms");
            public static encode(message: POGOProtos.Rpc.IRecurringChallengeScheduleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RecurringChallengeScheduleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RecurringChallengeScheduleProto;
            public static toObject(message: POGOProtos.Rpc.RecurringChallengeScheduleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRecycleItemOutProto {
            result?: (POGOProtos.Rpc.RecycleItemOutProto.Result|null);
            new_count?: (number|null);
        }

        class RecycleItemOutProto implements IRecycleItemOutProto {
            constructor(properties?: POGOProtos.Rpc.IRecycleItemOutProto);
            public result: POGOProtos.Rpc.RecycleItemOutProto.Result;
            public new_count: number;
            public static encode(message: POGOProtos.Rpc.IRecycleItemOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RecycleItemOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RecycleItemOutProto;
            public static toObject(message: POGOProtos.Rpc.RecycleItemOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RecycleItemOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_ENOUGH_COPIES = 2,
                ERROR_CANNOT_RECYCLE_INCUBATORS = 3
            }
        }

        interface IRecycleItemProto {
            item?: (POGOProtos.Rpc.Item|null);
            count?: (number|null);
        }

        class RecycleItemProto implements IRecycleItemProto {
            constructor(properties?: POGOProtos.Rpc.IRecycleItemProto);
            public item: POGOProtos.Rpc.Item;
            public count: number;
            public static encode(message: POGOProtos.Rpc.IRecycleItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RecycleItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RecycleItemProto;
            public static toObject(message: POGOProtos.Rpc.RecycleItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRedeemPasscodeRequestProto {
            passcode?: (string|null);
        }

        class RedeemPasscodeRequestProto implements IRedeemPasscodeRequestProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemPasscodeRequestProto);
            public passcode: string;
            public static encode(message: POGOProtos.Rpc.IRedeemPasscodeRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemPasscodeRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemPasscodeRequestProto;
            public static toObject(message: POGOProtos.Rpc.RedeemPasscodeRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRedeemPasscodeResponseProto {
            result?: (POGOProtos.Rpc.RedeemPasscodeResponseProto.Result|null);
            acquired_item?: (POGOProtos.Rpc.RedeemPasscodeResponseProto.IAcquiredItem[]|null);
            acquired_items_proto?: (Uint8Array|null);
            passcode?: (string|null);
        }

        class RedeemPasscodeResponseProto implements IRedeemPasscodeResponseProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemPasscodeResponseProto);
            public result: POGOProtos.Rpc.RedeemPasscodeResponseProto.Result;
            public acquired_item: POGOProtos.Rpc.RedeemPasscodeResponseProto.IAcquiredItem[];
            public acquired_items_proto: Uint8Array;
            public passcode: string;
            public static encode(message: POGOProtos.Rpc.IRedeemPasscodeResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemPasscodeResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemPasscodeResponseProto;
            public static toObject(message: POGOProtos.Rpc.RedeemPasscodeResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RedeemPasscodeResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NOT_AVAILABLE = 2,
                OVER_INVENTORY_LIMIT = 3,
                ALREADY_REDEEMED = 4,
                OVER_PLAYER_REDEMPTION_LIMIT = 5
            }

            interface IAcquiredItem {
                item?: (string|null);
                count?: (number|Long|null);
            }

            class AcquiredItem implements IAcquiredItem {
                constructor(properties?: POGOProtos.Rpc.RedeemPasscodeResponseProto.IAcquiredItem);
                public item: string;
                public count: (number|Long);
                public static encode(message: POGOProtos.Rpc.RedeemPasscodeResponseProto.IAcquiredItem, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemPasscodeResponseProto.AcquiredItem;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemPasscodeResponseProto.AcquiredItem;
                public static toObject(message: POGOProtos.Rpc.RedeemPasscodeResponseProto.AcquiredItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IRedeemPasscodeRewardProto {
            items?: (POGOProtos.Rpc.IRedeemedItemProto[]|null);
            avatar_items?: (POGOProtos.Rpc.IRedeemedAvatarItemProto[]|null);
            egg_pokemon?: (POGOProtos.Rpc.IPokemonProto[]|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto[]|null);
            poke_candy?: (POGOProtos.Rpc.IPokeCandyProto[]|null);
            stardust?: (number|null);
            pokecoins?: (number|null);
            badges?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            redeemed_stickers?: (POGOProtos.Rpc.IRedeemedStickerProto[]|null);
            quest_ids?: (string[]|null);
            neutral_avatar_item_ids?: (string[]|null);
            neutral_avatar_item_templates?: (POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto[]|null);
        }

        class RedeemPasscodeRewardProto implements IRedeemPasscodeRewardProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemPasscodeRewardProto);
            public items: POGOProtos.Rpc.IRedeemedItemProto[];
            public avatar_items: POGOProtos.Rpc.IRedeemedAvatarItemProto[];
            public egg_pokemon: POGOProtos.Rpc.IPokemonProto[];
            public pokemon: POGOProtos.Rpc.IPokemonProto[];
            public poke_candy: POGOProtos.Rpc.IPokeCandyProto[];
            public stardust: number;
            public pokecoins: number;
            public badges: POGOProtos.Rpc.HoloBadgeType[];
            public redeemed_stickers: POGOProtos.Rpc.IRedeemedStickerProto[];
            public quest_ids: string[];
            public neutral_avatar_item_ids: string[];
            public neutral_avatar_item_templates: POGOProtos.Rpc.INeutralAvatarLootItemTemplateProto[];
            public static encode(message: POGOProtos.Rpc.IRedeemPasscodeRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemPasscodeRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemPasscodeRewardProto;
            public static toObject(message: POGOProtos.Rpc.RedeemPasscodeRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRedeemTicketGiftForFriendOutProto {
            status?: (POGOProtos.Rpc.RedeemTicketGiftForFriendOutProto.Status|null);
            gifting_eligibility?: (POGOProtos.Rpc.IGiftingEligibilityStatusProto|null);
        }

        class RedeemTicketGiftForFriendOutProto implements IRedeemTicketGiftForFriendOutProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemTicketGiftForFriendOutProto);
            public status: POGOProtos.Rpc.RedeemTicketGiftForFriendOutProto.Status;
            public gifting_eligibility?: (POGOProtos.Rpc.IGiftingEligibilityStatusProto|null);
            public static encode(message: POGOProtos.Rpc.IRedeemTicketGiftForFriendOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemTicketGiftForFriendOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemTicketGiftForFriendOutProto;
            public static toObject(message: POGOProtos.Rpc.RedeemTicketGiftForFriendOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RedeemTicketGiftForFriendOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                FAILURE_ELIGIBILITY = 3,
                FAILURE_GIFT_NOT_FOUND = 4
            }
        }

        interface IRedeemTicketGiftForFriendProto {
            gifting_iap_item?: (POGOProtos.Rpc.IGiftingIapItemProto|null);
            recipient_friend_id?: (string|null);
        }

        class RedeemTicketGiftForFriendProto implements IRedeemTicketGiftForFriendProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemTicketGiftForFriendProto);
            public gifting_iap_item?: (POGOProtos.Rpc.IGiftingIapItemProto|null);
            public recipient_friend_id: string;
            public static encode(message: POGOProtos.Rpc.IRedeemTicketGiftForFriendProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemTicketGiftForFriendProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemTicketGiftForFriendProto;
            public static toObject(message: POGOProtos.Rpc.RedeemTicketGiftForFriendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRedeemedAvatarItemProto {
            avatar_template_id?: (string|null);
            item_count?: (number|null);
        }

        class RedeemedAvatarItemProto implements IRedeemedAvatarItemProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemedAvatarItemProto);
            public avatar_template_id: string;
            public item_count: number;
            public static encode(message: POGOProtos.Rpc.IRedeemedAvatarItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemedAvatarItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemedAvatarItemProto;
            public static toObject(message: POGOProtos.Rpc.RedeemedAvatarItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRedeemedItemProto {
            item?: (POGOProtos.Rpc.Item|null);
            item_count?: (number|null);
        }

        class RedeemedItemProto implements IRedeemedItemProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemedItemProto);
            public item: POGOProtos.Rpc.Item;
            public item_count: number;
            public static encode(message: POGOProtos.Rpc.IRedeemedItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemedItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemedItemProto;
            public static toObject(message: POGOProtos.Rpc.RedeemedItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRedeemedStickerProto {
            sticker_id?: (string|null);
            count?: (number|null);
        }

        class RedeemedStickerProto implements IRedeemedStickerProto {
            constructor(properties?: POGOProtos.Rpc.IRedeemedStickerProto);
            public sticker_id: string;
            public count: number;
            public static encode(message: POGOProtos.Rpc.IRedeemedStickerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RedeemedStickerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RedeemedStickerProto;
            public static toObject(message: POGOProtos.Rpc.RedeemedStickerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReferralMilestonesProto {
            referrer_niantic_id?: (string|null);
            referee_niantic_id?: (string|null);
            referrer_player_id?: (string|null);
            referee_player_id?: (string|null);
            milestones_template_id?: (string|null);
            version?: (number|null);
            milestone?: ({ [k: string]: POGOProtos.Rpc.ReferralMilestonesProto.IMilestoneProto }|null);
        }

        class ReferralMilestonesProto implements IReferralMilestonesProto {
            constructor(properties?: POGOProtos.Rpc.IReferralMilestonesProto);
            public referrer_niantic_id?: (string|null);
            public referee_niantic_id?: (string|null);
            public referrer_player_id?: (string|null);
            public referee_player_id?: (string|null);
            public milestones_template_id: string;
            public version: number;
            public milestone: { [k: string]: POGOProtos.Rpc.ReferralMilestonesProto.IMilestoneProto };
            public NianticId?: ("referrer_niantic_id"|"referee_niantic_id");
            public PlayerId?: ("referrer_player_id"|"referee_player_id");
            public static encode(message: POGOProtos.Rpc.IReferralMilestonesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReferralMilestonesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReferralMilestonesProto;
            public static toObject(message: POGOProtos.Rpc.ReferralMilestonesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReferralMilestonesProto {

            interface IMilestoneProto {
                name_key?: (string|null);
                status?: (POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.Status|null);
                reward?: (Uint8Array[]|null);
                milestone_template_id?: (string|null);
                version?: (number|null);
                name_template_variable?: (POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.ITemplateVariableProto[]|null);
                viewed_by_client?: (boolean|null);
                created_timestamp_ms?: (number|Long|null);
            }

            class MilestoneProto implements IMilestoneProto {
                constructor(properties?: POGOProtos.Rpc.ReferralMilestonesProto.IMilestoneProto);
                public name_key: string;
                public status: POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.Status;
                public reward: Uint8Array[];
                public milestone_template_id: string;
                public version: number;
                public name_template_variable: POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.ITemplateVariableProto[];
                public viewed_by_client: boolean;
                public created_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.ReferralMilestonesProto.IMilestoneProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto;
                public static toObject(message: POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace MilestoneProto {

                enum Status {
                    UNSET = 0,
                    ACTIVE = 1,
                    ACHIEVED = 2,
                    ACTIVE_HIDDEN = 3,
                    ACHIEVED_HIDDEN = 4,
                    REWARDS_CLAIMED = 5
                }

                interface ITemplateVariableProto {
                    name?: (string|null);
                    literal?: (string|null);
                }

                class TemplateVariableProto implements ITemplateVariableProto {
                    constructor(properties?: POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.ITemplateVariableProto);
                    public name: string;
                    public literal: string;
                    public static encode(message: POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.ITemplateVariableProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.TemplateVariableProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.TemplateVariableProto;
                    public static toObject(message: POGOProtos.Rpc.ReferralMilestonesProto.MilestoneProto.TemplateVariableProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IReferralSettingsProto {
            feature_enabled?: (boolean|null);
            recent_features?: (POGOProtos.Rpc.ReferralSettingsProto.IRecentFeatureProto[]|null);
            add_referrer_grace_period_ms?: (number|Long|null);
            client_get_milestone_interval_ms?: (number|Long|null);
            min_num_days_without_session_for_lapsed_player?: (number|null);
            deep_link_url?: (string|null);
            image_share_referral_enabled?: (boolean|null);
        }

        class ReferralSettingsProto implements IReferralSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IReferralSettingsProto);
            public feature_enabled: boolean;
            public recent_features: POGOProtos.Rpc.ReferralSettingsProto.IRecentFeatureProto[];
            public add_referrer_grace_period_ms: (number|Long);
            public client_get_milestone_interval_ms: (number|Long);
            public min_num_days_without_session_for_lapsed_player: number;
            public deep_link_url: string;
            public image_share_referral_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IReferralSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReferralSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReferralSettingsProto;
            public static toObject(message: POGOProtos.Rpc.ReferralSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReferralSettingsProto {

            interface IRecentFeatureProto {
                icon_type?: (POGOProtos.Rpc.BonusBoxProto.IconType|null);
                feature_name?: (string|null);
                description?: (string|null);
            }

            class RecentFeatureProto implements IRecentFeatureProto {
                constructor(properties?: POGOProtos.Rpc.ReferralSettingsProto.IRecentFeatureProto);
                public icon_type: POGOProtos.Rpc.BonusBoxProto.IconType;
                public feature_name: string;
                public description: string;
                public static encode(message: POGOProtos.Rpc.ReferralSettingsProto.IRecentFeatureProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReferralSettingsProto.RecentFeatureProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReferralSettingsProto.RecentFeatureProto;
                public static toObject(message: POGOProtos.Rpc.ReferralSettingsProto.RecentFeatureProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IReferralTelemetry {
            referral_telemetry_id?: (POGOProtos.Rpc.ReferralTelemetryIds|null);
            referral_role?: (POGOProtos.Rpc.ReferralRole|null);
            milestone_description_string_key?: (string|null);
            referral_source?: (POGOProtos.Rpc.ReferralSource|null);
        }

        class ReferralTelemetry implements IReferralTelemetry {
            constructor(properties?: POGOProtos.Rpc.IReferralTelemetry);
            public referral_telemetry_id: POGOProtos.Rpc.ReferralTelemetryIds;
            public referral_role: POGOProtos.Rpc.ReferralRole;
            public milestone_description_string_key: string;
            public referral_source: POGOProtos.Rpc.ReferralSource;
            public static encode(message: POGOProtos.Rpc.IReferralTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReferralTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReferralTelemetry;
            public static toObject(message: POGOProtos.Rpc.ReferralTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRefreshProximityTokensRequestProto {
            first_token_start_time_ms?: (number|Long|null);
        }

        class RefreshProximityTokensRequestProto implements IRefreshProximityTokensRequestProto {
            constructor(properties?: POGOProtos.Rpc.IRefreshProximityTokensRequestProto);
            public first_token_start_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRefreshProximityTokensRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RefreshProximityTokensRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RefreshProximityTokensRequestProto;
            public static toObject(message: POGOProtos.Rpc.RefreshProximityTokensRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRefreshProximityTokensResponseProto {
            proximity_token?: (POGOProtos.Rpc.IProximityToken[]|null);
        }

        class RefreshProximityTokensResponseProto implements IRefreshProximityTokensResponseProto {
            constructor(properties?: POGOProtos.Rpc.IRefreshProximityTokensResponseProto);
            public proximity_token: POGOProtos.Rpc.IProximityToken[];
            public static encode(message: POGOProtos.Rpc.IRefreshProximityTokensResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RefreshProximityTokensResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RefreshProximityTokensResponseProto;
            public static toObject(message: POGOProtos.Rpc.RefreshProximityTokensResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRegisterBackgroundDeviceActionProto {
            device_type?: (string|null);
            device_id?: (string|null);
        }

        class RegisterBackgroundDeviceActionProto implements IRegisterBackgroundDeviceActionProto {
            constructor(properties?: POGOProtos.Rpc.IRegisterBackgroundDeviceActionProto);
            public device_type: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IRegisterBackgroundDeviceActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RegisterBackgroundDeviceActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RegisterBackgroundDeviceActionProto;
            public static toObject(message: POGOProtos.Rpc.RegisterBackgroundDeviceActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRegisterBackgroundDeviceResponseProto {
            status?: (POGOProtos.Rpc.RegisterBackgroundDeviceResponseProto.Status|null);
            token?: (POGOProtos.Rpc.IBackgroundToken|null);
        }

        class RegisterBackgroundDeviceResponseProto implements IRegisterBackgroundDeviceResponseProto {
            constructor(properties?: POGOProtos.Rpc.IRegisterBackgroundDeviceResponseProto);
            public status: POGOProtos.Rpc.RegisterBackgroundDeviceResponseProto.Status;
            public token?: (POGOProtos.Rpc.IBackgroundToken|null);
            public static encode(message: POGOProtos.Rpc.IRegisterBackgroundDeviceResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RegisterBackgroundDeviceResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RegisterBackgroundDeviceResponseProto;
            public static toObject(message: POGOProtos.Rpc.RegisterBackgroundDeviceResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RegisterBackgroundDeviceResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IRegisterSfidaRequest {
            sfida_id?: (string|null);
            device_type?: (POGOProtos.Rpc.RegisterSfidaRequest.DeviceType|null);
        }

        class RegisterSfidaRequest implements IRegisterSfidaRequest {
            constructor(properties?: POGOProtos.Rpc.IRegisterSfidaRequest);
            public sfida_id: string;
            public device_type: POGOProtos.Rpc.RegisterSfidaRequest.DeviceType;
            public static encode(message: POGOProtos.Rpc.IRegisterSfidaRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RegisterSfidaRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RegisterSfidaRequest;
            public static toObject(message: POGOProtos.Rpc.RegisterSfidaRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RegisterSfidaRequest {

            enum DeviceType {
                SFIDA = 0,
                UNSET = -1,
                PALMA = 1,
                WAINA = 2
            }
        }

        interface IRegisterSfidaResponse {
            access_token?: (Uint8Array|null);
        }

        class RegisterSfidaResponse implements IRegisterSfidaResponse {
            constructor(properties?: POGOProtos.Rpc.IRegisterSfidaResponse);
            public access_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IRegisterSfidaResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RegisterSfidaResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RegisterSfidaResponse;
            public static toObject(message: POGOProtos.Rpc.RegisterSfidaResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReleasePokemonOutProto {
            status?: (POGOProtos.Rpc.ReleasePokemonOutProto.Status|null);
            candy_awarded?: (number|null);
            xl_candy_awarded?: (number|null);
            xl_candy_awarded_per_id?: ({ [k: string]: number }|null);
        }

        class ReleasePokemonOutProto implements IReleasePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IReleasePokemonOutProto);
            public status: POGOProtos.Rpc.ReleasePokemonOutProto.Status;
            public candy_awarded: number;
            public xl_candy_awarded: number;
            public xl_candy_awarded_per_id: { [k: string]: number };
            public static encode(message: POGOProtos.Rpc.IReleasePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReleasePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReleasePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.ReleasePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReleasePokemonOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                POKEMON_DEPLOYED = 2,
                FAILED = 3,
                ERROR_POKEMON_IS_EGG = 4,
                ERROR_POKEMON_IS_BUDDY = 5,
                ERROR_FUSION_POKEMON = 6,
                ERROR_FUSION_COMPONENT_POKEMON = 7
            }
        }

        interface IReleasePokemonProto {
            pokemon_id?: (number|Long|null);
            pokemon_ids?: ((number|Long)[]|null);
        }

        class ReleasePokemonProto implements IReleasePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IReleasePokemonProto);
            public pokemon_id: (number|Long);
            public pokemon_ids: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IReleasePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReleasePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReleasePokemonProto;
            public static toObject(message: POGOProtos.Rpc.ReleasePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReleasePokemonTelemetry {
            pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
        }

        class ReleasePokemonTelemetry implements IReleasePokemonTelemetry {
            constructor(properties?: POGOProtos.Rpc.IReleasePokemonTelemetry);
            public pokemon?: (POGOProtos.Rpc.IPokemonTelemetry|null);
            public static encode(message: POGOProtos.Rpc.IReleasePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReleasePokemonTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReleasePokemonTelemetry;
            public static toObject(message: POGOProtos.Rpc.ReleasePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReleaseStationedPokemonOutProto {
            result?: (POGOProtos.Rpc.ReleaseStationedPokemonOutProto.Result|null);
        }

        class ReleaseStationedPokemonOutProto implements IReleaseStationedPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IReleaseStationedPokemonOutProto);
            public result: POGOProtos.Rpc.ReleaseStationedPokemonOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IReleaseStationedPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReleaseStationedPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReleaseStationedPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.ReleaseStationedPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReleaseStationedPokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_POKEMON = 2,
                INVALID_STATION = 3
            }
        }

        interface IReleaseStationedPokemonProto {
            station_id?: (string|null);
            pokemon_id?: (number|Long|null);
        }

        class ReleaseStationedPokemonProto implements IReleaseStationedPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IReleaseStationedPokemonProto);
            public station_id: string;
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IReleaseStationedPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReleaseStationedPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReleaseStationedPokemonProto;
            public static toObject(message: POGOProtos.Rpc.ReleaseStationedPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemoteGiftPingRequestProto {
        }

        class RemoteGiftPingRequestProto implements IRemoteGiftPingRequestProto {
            constructor(properties?: POGOProtos.Rpc.IRemoteGiftPingRequestProto);
            public static encode(message: POGOProtos.Rpc.IRemoteGiftPingRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoteGiftPingRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoteGiftPingRequestProto;
            public static toObject(message: POGOProtos.Rpc.RemoteGiftPingRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemoteGiftPingResponseProto {
            result?: (POGOProtos.Rpc.RemoteGiftPingResponseProto.Result|null);
        }

        class RemoteGiftPingResponseProto implements IRemoteGiftPingResponseProto {
            constructor(properties?: POGOProtos.Rpc.IRemoteGiftPingResponseProto);
            public result: POGOProtos.Rpc.RemoteGiftPingResponseProto.Result;
            public static encode(message: POGOProtos.Rpc.IRemoteGiftPingResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoteGiftPingResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoteGiftPingResponseProto;
            public static toObject(message: POGOProtos.Rpc.RemoteGiftPingResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemoteGiftPingResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                STILL_IN_COOL_DOWN = 2,
                BUDDY_NOT_SET = 3,
                ERROR_INVENTORY_FULL = 4,
                ERROR_NO_REMOTE_GIFTS = 5
            }
        }

        interface IRemoteRaidTelemetry {
            remote_raid_telemetry_id?: (POGOProtos.Rpc.RemoteRaidTelemetryIds|null);
            remote_raid_join_source?: (POGOProtos.Rpc.RemoteRaidJoinSource|null);
            remote_raid_invite_accept_source?: (POGOProtos.Rpc.RemoteRaidInviteAcceptSource|null);
        }

        class RemoteRaidTelemetry implements IRemoteRaidTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRemoteRaidTelemetry);
            public remote_raid_telemetry_id: POGOProtos.Rpc.RemoteRaidTelemetryIds;
            public remote_raid_join_source: POGOProtos.Rpc.RemoteRaidJoinSource;
            public remote_raid_invite_accept_source: POGOProtos.Rpc.RemoteRaidInviteAcceptSource;
            public static encode(message: POGOProtos.Rpc.IRemoteRaidTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoteRaidTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoteRaidTelemetry;
            public static toObject(message: POGOProtos.Rpc.RemoteRaidTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemoveLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
            status?: (POGOProtos.Rpc.RemoveLoginActionOutProto.Status|null);
        }

        class RemoveLoginActionOutProto implements IRemoveLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IRemoveLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public status: POGOProtos.Rpc.RemoveLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IRemoveLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoveLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoveLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.RemoveLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemoveLoginActionOutProto {

            enum Status {
                UNSET = 0,
                LOGIN_NOT_REMOVABLE = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IRemoveLoginActionProto {
            identity_provider?: (POGOProtos.Rpc.AuthIdentityProvider|null);
            auth_provider_id?: (string|null);
        }

        class RemoveLoginActionProto implements IRemoveLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IRemoveLoginActionProto);
            public identity_provider: POGOProtos.Rpc.AuthIdentityProvider;
            public auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IRemoveLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoveLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoveLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.RemoveLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemovePokemonSizeLeaderboardEntryOutProto {
            status?: (POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryOutProto.Status|null);
        }

        class RemovePokemonSizeLeaderboardEntryOutProto implements IRemovePokemonSizeLeaderboardEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryOutProto);
            public status: POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemovePokemonSizeLeaderboardEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ENTRY_TO_REMOVE_NOT_FOUND = 3,
                POKEMON_TO_REMOVE_DIFFERENT = 4
            }
        }

        interface IRemovePokemonSizeLeaderboardEntryProto {
            contest_id?: (string|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id_to_remove?: (number|Long|null);
        }

        class RemovePokemonSizeLeaderboardEntryProto implements IRemovePokemonSizeLeaderboardEntryProto {
            constructor(properties?: POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryProto);
            public contest_id: string;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id_to_remove: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRemovePokemonSizeLeaderboardEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryProto;
            public static toObject(message: POGOProtos.Rpc.RemovePokemonSizeLeaderboardEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemovePtcLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
            status?: (POGOProtos.Rpc.RemovePtcLoginActionOutProto.Status|null);
        }

        class RemovePtcLoginActionOutProto implements IRemovePtcLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IRemovePtcLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public status: POGOProtos.Rpc.RemovePtcLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IRemovePtcLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemovePtcLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemovePtcLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.RemovePtcLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemovePtcLoginActionOutProto {

            enum Status {
                UNSET = 0,
                LOGIN_NOT_REMOVABLE = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IRemovePtcLoginActionProto {
        }

        class RemovePtcLoginActionProto implements IRemovePtcLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IRemovePtcLoginActionProto);
            public static encode(message: POGOProtos.Rpc.IRemovePtcLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemovePtcLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemovePtcLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.RemovePtcLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemoveQuestOutProto {
            status?: (POGOProtos.Rpc.RemoveQuestOutProto.Status|null);
        }

        class RemoveQuestOutProto implements IRemoveQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.IRemoveQuestOutProto);
            public status: POGOProtos.Rpc.RemoveQuestOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IRemoveQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoveQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoveQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.RemoveQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemoveQuestOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_QUEST_NOT_FOUND = 2,
                ERROR_STORY_QUEST_NOT_REMOVABLE = 3
            }
        }

        interface IRemoveQuestProto {
            quest_id?: (string|null);
        }

        class RemoveQuestProto implements IRemoveQuestProto {
            constructor(properties?: POGOProtos.Rpc.IRemoveQuestProto);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.IRemoveQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoveQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoveQuestProto;
            public static toObject(message: POGOProtos.Rpc.RemoveQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemoveSaveForLaterOutProto {
            result?: (POGOProtos.Rpc.RemoveSaveForLaterOutProto.Result|null);
        }

        class RemoveSaveForLaterOutProto implements IRemoveSaveForLaterOutProto {
            constructor(properties?: POGOProtos.Rpc.IRemoveSaveForLaterOutProto);
            public result: POGOProtos.Rpc.RemoveSaveForLaterOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IRemoveSaveForLaterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoveSaveForLaterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoveSaveForLaterOutProto;
            public static toObject(message: POGOProtos.Rpc.RemoveSaveForLaterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemoveSaveForLaterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_SAVE_FOR_LATER_NOT_FOUND = 2,
                ERROR_SAVE_FOR_LATER_NOT_ENABLED = 3
            }
        }

        interface IRemoveSaveForLaterProto {
            save_for_later_seed?: (string|null);
        }

        class RemoveSaveForLaterProto implements IRemoveSaveForLaterProto {
            constructor(properties?: POGOProtos.Rpc.IRemoveSaveForLaterProto);
            public save_for_later_seed: string;
            public static encode(message: POGOProtos.Rpc.IRemoveSaveForLaterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemoveSaveForLaterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemoveSaveForLaterProto;
            public static toObject(message: POGOProtos.Rpc.RemoveSaveForLaterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRemovedParticipant {
            player_id?: (string|null);
            removed_reason?: (POGOProtos.Rpc.RemovedParticipant.Reason|null);
            quest_id?: (string|null);
            quest_progress?: (number|null);
        }

        class RemovedParticipant implements IRemovedParticipant {
            constructor(properties?: POGOProtos.Rpc.IRemovedParticipant);
            public player_id: string;
            public removed_reason: POGOProtos.Rpc.RemovedParticipant.Reason;
            public quest_id: string;
            public quest_progress: number;
            public static encode(message: POGOProtos.Rpc.IRemovedParticipant, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RemovedParticipant;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RemovedParticipant;
            public static toObject(message: POGOProtos.Rpc.RemovedParticipant, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RemovedParticipant {

            enum Reason {
                UNSET = 0,
                REMOVED_BY_HOST = 1,
                REMOVED_BY_OPS = 2,
                REMOVED_REASON_LEFT = 3
            }
        }

        interface IReplaceLoginActionOutProto {
            success?: (boolean|null);
            login_detail?: (POGOProtos.Rpc.ILoginDetail[]|null);
            status?: (POGOProtos.Rpc.ReplaceLoginActionOutProto.Status|null);
        }

        class ReplaceLoginActionOutProto implements IReplaceLoginActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IReplaceLoginActionOutProto);
            public success: boolean;
            public login_detail: POGOProtos.Rpc.ILoginDetail[];
            public status: POGOProtos.Rpc.ReplaceLoginActionOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IReplaceLoginActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReplaceLoginActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReplaceLoginActionOutProto;
            public static toObject(message: POGOProtos.Rpc.ReplaceLoginActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReplaceLoginActionOutProto {

            enum Status {
                UNSET = 0,
                AUTH_FAILURE = 1,
                LOGIN_TAKEN = 2,
                LOGIN_ALREADY_HAVE = 3,
                LOGIN_NOT_REPLACEABLE = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface IReplaceLoginActionProto {
            existing_identity_provider?: (POGOProtos.Rpc.AuthIdentityProvider|null);
            new_login?: (POGOProtos.Rpc.IAddLoginActionProto|null);
            auth_provider_id?: (string|null);
        }

        class ReplaceLoginActionProto implements IReplaceLoginActionProto {
            constructor(properties?: POGOProtos.Rpc.IReplaceLoginActionProto);
            public existing_identity_provider: POGOProtos.Rpc.AuthIdentityProvider;
            public new_login?: (POGOProtos.Rpc.IAddLoginActionProto|null);
            public auth_provider_id: string;
            public static encode(message: POGOProtos.Rpc.IReplaceLoginActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReplaceLoginActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReplaceLoginActionProto;
            public static toObject(message: POGOProtos.Rpc.ReplaceLoginActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReplenishMpAttributesProto {
            mp_amount?: (number|null);
        }

        class ReplenishMpAttributesProto implements IReplenishMpAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IReplenishMpAttributesProto);
            public mp_amount: number;
            public static encode(message: POGOProtos.Rpc.IReplenishMpAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReplenishMpAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReplenishMpAttributesProto;
            public static toObject(message: POGOProtos.Rpc.ReplenishMpAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReportAdFeedbackRequest {
            game_id?: (string|null);
            user_id?: (string|null);
            guid?: (string|null);
            encrypted_ad_token?: (Uint8Array|null);
            ad_feedback_report?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedbackReport|null);
        }

        class ReportAdFeedbackRequest implements IReportAdFeedbackRequest {
            constructor(properties?: POGOProtos.Rpc.IReportAdFeedbackRequest);
            public game_id: string;
            public user_id: string;
            public guid: string;
            public encrypted_ad_token: Uint8Array;
            public ad_feedback_report?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedbackReport|null);
            public static encode(message: POGOProtos.Rpc.IReportAdFeedbackRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdFeedbackRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdFeedbackRequest;
            public static toObject(message: POGOProtos.Rpc.ReportAdFeedbackRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReportAdFeedbackResponse {
            status?: (POGOProtos.Rpc.ReportAdFeedbackResponse.Status|null);
        }

        class ReportAdFeedbackResponse implements IReportAdFeedbackResponse {
            constructor(properties?: POGOProtos.Rpc.IReportAdFeedbackResponse);
            public status: POGOProtos.Rpc.ReportAdFeedbackResponse.Status;
            public static encode(message: POGOProtos.Rpc.IReportAdFeedbackResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdFeedbackResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdFeedbackResponse;
            public static toObject(message: POGOProtos.Rpc.ReportAdFeedbackResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReportAdFeedbackResponse {

            enum Status {
                SUCCESS = 0,
                ERROR = 1
            }
        }

        interface IReportAdInteractionProto {
            view_impression?: (POGOProtos.Rpc.ReportAdInteractionProto.IViewImpressionInteraction|null);
            view_fullscreen?: (POGOProtos.Rpc.ReportAdInteractionProto.IViewFullscreenInteraction|null);
            fullscreen_interaction?: (POGOProtos.Rpc.ReportAdInteractionProto.IFullScreenInteraction|null);
            cta_clicked?: (POGOProtos.Rpc.ReportAdInteractionProto.ICTAClickInteraction|null);
            ad_spawned?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdSpawnInteraction|null);
            ad_dismissed?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdDismissalInteraction|null);
            view_web_ar?: (POGOProtos.Rpc.ReportAdInteractionProto.IViewWebArInteraction|null);
            video_ad_loaded?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdLoaded|null);
            video_ad_balloon_opened?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdBalloonOpened|null);
            video_ad_clicked_on_balloon_cta?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClickedOnBalloonCta|null);
            video_ad_opened?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdOpened|null);
            video_ad_closed?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClosed|null);
            video_ad_player_rewarded?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdPlayerRewarded|null);
            video_ad_cta_clicked?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdCTAClicked|null);
            video_ad_reward_eligible?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdRewardEligible|null);
            video_ad_failure?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdFailure|null);
            get_reward_info?: (POGOProtos.Rpc.ReportAdInteractionProto.IGetRewardInfo|null);
            web_ar_camera_permission_response?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionResponse|null);
            web_ar_camera_permission_request_sent?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionRequestSent|null);
            web_ar_audience_device_status?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArAudienceDeviceStatus|null);
            web_ar_ad_failure?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArAdFailure|null);
            ar_engine_interaction?: (POGOProtos.Rpc.ReportAdInteractionProto.IArEngineInteraction|null);
            game_id?: (string|null);
            user_id?: (string|null);
            guid?: (string|null);
            encrypted_ad_token?: (Uint8Array|null);
            ad_event_uuid?: (string|null);
            application_id?: (string|null);
            ad_type?: (POGOProtos.Rpc.ReportAdInteractionProto.AdType|null);
            google_managed_ad?: (POGOProtos.Rpc.ReportAdInteractionProto.IGoogleManagedAdDetails|null);
        }

        class ReportAdInteractionProto implements IReportAdInteractionProto {
            constructor(properties?: POGOProtos.Rpc.IReportAdInteractionProto);
            public view_impression?: (POGOProtos.Rpc.ReportAdInteractionProto.IViewImpressionInteraction|null);
            public view_fullscreen?: (POGOProtos.Rpc.ReportAdInteractionProto.IViewFullscreenInteraction|null);
            public fullscreen_interaction?: (POGOProtos.Rpc.ReportAdInteractionProto.IFullScreenInteraction|null);
            public cta_clicked?: (POGOProtos.Rpc.ReportAdInteractionProto.ICTAClickInteraction|null);
            public ad_spawned?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdSpawnInteraction|null);
            public ad_dismissed?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdDismissalInteraction|null);
            public view_web_ar?: (POGOProtos.Rpc.ReportAdInteractionProto.IViewWebArInteraction|null);
            public video_ad_loaded?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdLoaded|null);
            public video_ad_balloon_opened?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdBalloonOpened|null);
            public video_ad_clicked_on_balloon_cta?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClickedOnBalloonCta|null);
            public video_ad_opened?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdOpened|null);
            public video_ad_closed?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClosed|null);
            public video_ad_player_rewarded?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdPlayerRewarded|null);
            public video_ad_cta_clicked?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdCTAClicked|null);
            public video_ad_reward_eligible?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdRewardEligible|null);
            public video_ad_failure?: (POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdFailure|null);
            public get_reward_info?: (POGOProtos.Rpc.ReportAdInteractionProto.IGetRewardInfo|null);
            public web_ar_camera_permission_response?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionResponse|null);
            public web_ar_camera_permission_request_sent?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionRequestSent|null);
            public web_ar_audience_device_status?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArAudienceDeviceStatus|null);
            public web_ar_ad_failure?: (POGOProtos.Rpc.ReportAdInteractionProto.IWebArAdFailure|null);
            public ar_engine_interaction?: (POGOProtos.Rpc.ReportAdInteractionProto.IArEngineInteraction|null);
            public game_id: string;
            public user_id: string;
            public guid: string;
            public encrypted_ad_token: Uint8Array;
            public ad_event_uuid: string;
            public application_id: string;
            public ad_type: POGOProtos.Rpc.ReportAdInteractionProto.AdType;
            public google_managed_ad?: (POGOProtos.Rpc.ReportAdInteractionProto.IGoogleManagedAdDetails|null);
            public InteractionType?: ("view_impression"|"view_fullscreen"|"fullscreen_interaction"|"cta_clicked"|"ad_spawned"|"ad_dismissed"|"view_web_ar"|"video_ad_loaded"|"video_ad_balloon_opened"|"video_ad_clicked_on_balloon_cta"|"video_ad_opened"|"video_ad_closed"|"video_ad_player_rewarded"|"video_ad_cta_clicked"|"video_ad_reward_eligible"|"video_ad_failure"|"get_reward_info"|"web_ar_camera_permission_response"|"web_ar_camera_permission_request_sent"|"web_ar_audience_device_status"|"web_ar_ad_failure"|"ar_engine_interaction");
            public static encode(message: POGOProtos.Rpc.IReportAdInteractionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto;
            public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReportAdInteractionProto {

            enum AdType {
                AD_TYPE_UNKNOWN = 0,
                AD_TYPE_SPONSORED_GIFT = 1,
                AD_TYPE_SPONSORED_BALLOON = 2,
                AD_TYPE_SPONSORED_BALLOON_WASABI = 3,
                AD_TYPE_SPONSORED_BALLOON_GOOGLE_MANAGED_AD = 4,
                AD_TYPE_SPONSORED_BALLOON_AR_AD = 5,
                AD_TYPE_SPONSORED_BALLOON_VIDEO_AD = 6,
                AD_TYPE_AR_AD_MARKON = 7
            }

            interface IWebArAdFailure {
                failure_type?: (POGOProtos.Rpc.ReportAdInteractionProto.WebArAdFailure.FailureType|null);
                failure_reason?: (string|null);
            }

            class WebArAdFailure implements IWebArAdFailure {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IWebArAdFailure);
                public failure_type: POGOProtos.Rpc.ReportAdInteractionProto.WebArAdFailure.FailureType;
                public failure_reason: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IWebArAdFailure, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.WebArAdFailure;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.WebArAdFailure;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.WebArAdFailure, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace WebArAdFailure {

                enum FailureType {
                    UNKNOWN = 0,
                    WEB_AR_REWARD_FAILURE = 1,
                    WEB_AR_WEBVIEW_FAILURE = 2,
                    WEB_AR_CAMERA_PERMISSION_DENIED_FAILURE = 3
                }
            }

            interface IArEngineInteraction {
                metadata?: ({ [k: string]: string }|null);
                data?: ({ [k: string]: string }|null);
            }

            class ArEngineInteraction implements IArEngineInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IArEngineInteraction);
                public metadata: { [k: string]: string };
                public data: { [k: string]: string };
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IArEngineInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.ArEngineInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.ArEngineInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.ArEngineInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAdDismissalInteraction {
                ad_dismissal_type?: (POGOProtos.Rpc.ReportAdInteractionProto.AdDismissalInteraction.AdDismissalType|null);
            }

            class AdDismissalInteraction implements IAdDismissalInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IAdDismissalInteraction);
                public ad_dismissal_type: POGOProtos.Rpc.ReportAdInteractionProto.AdDismissalInteraction.AdDismissalType;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IAdDismissalInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.AdDismissalInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.AdDismissalInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.AdDismissalInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AdDismissalInteraction {

                enum AdDismissalType {
                    AD_DISMISSAL_UNKNOWN = 0,
                    AD_DISMISSAL_TR_DISPLACES_AD_BALLOON = 1,
                    AD_DISMISSAL_NEW_AD_BALLOON_DISPLACES_OLD = 2,
                    AD_DISMISSAL_AD_BALLOON_AUTO_DISMISS = 3,
                    AD_DISMISSAL_PLAYER_OPTED_OUT_OF_ADS = 4
                }
            }

            interface IAdFeedback {
                content?: (string|null);
            }

            class AdFeedback implements IAdFeedback {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedback);
                public content: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedback, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.AdFeedback;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.AdFeedback;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.AdFeedback, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAdFeedbackReport {
                gam_ad_response_id?: (string|null);
                feedback?: (POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedback[]|null);
            }

            class AdFeedbackReport implements IAdFeedbackReport {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedbackReport);
                public gam_ad_response_id: string;
                public feedback: POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedback[];
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IAdFeedbackReport, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.AdFeedbackReport;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.AdFeedbackReport;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.AdFeedbackReport, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IAdSpawnInteraction {
                spawn_success?: (boolean|null);
                ad_inhibition_type?: (POGOProtos.Rpc.ReportAdInteractionProto.AdSpawnInteraction.AdInhibitionType|null);
            }

            class AdSpawnInteraction implements IAdSpawnInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IAdSpawnInteraction);
                public spawn_success: boolean;
                public ad_inhibition_type: POGOProtos.Rpc.ReportAdInteractionProto.AdSpawnInteraction.AdInhibitionType;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IAdSpawnInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.AdSpawnInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.AdSpawnInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.AdSpawnInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AdSpawnInteraction {

                enum AdInhibitionType {
                    AD_INHIBITION_UNKNOWN = 0,
                    AD_INHIBITION_TR_PREVENTS_BALLOON_SPAWN = 1,
                    AD_INHIBITION_CLIENT_ERROR = 2,
                    AD_INHIBITION_DISABLED_IN_GMT = 3,
                    AD_INHIBITION_PLAYER_OPTED_OUT_OF_ADS = 4
                }
            }

            interface ICTAClickInteraction {
                cta_url?: (string|null);
            }

            class CTAClickInteraction implements ICTAClickInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.ICTAClickInteraction);
                public cta_url: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.ICTAClickInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.CTAClickInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.CTAClickInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.CTAClickInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFullScreenInteraction {
                fullscreen_image_url?: (string|null);
                total_residence_time_ms?: (number|Long|null);
                time_away_ms?: (number|Long|null);
                took_screenshot?: (boolean|null);
            }

            class FullScreenInteraction implements IFullScreenInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IFullScreenInteraction);
                public fullscreen_image_url: string;
                public total_residence_time_ms: (number|Long);
                public time_away_ms: (number|Long);
                public took_screenshot: boolean;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IFullScreenInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.FullScreenInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.FullScreenInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.FullScreenInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetRewardInfo {
                valid_gift_token?: (boolean|null);
            }

            class GetRewardInfo implements IGetRewardInfo {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IGetRewardInfo);
                public valid_gift_token: boolean;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IGetRewardInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.GetRewardInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.GetRewardInfo;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.GetRewardInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGoogleManagedAdDetails {
                gam_order_id?: (string|null);
                gam_line_item_id?: (string|null);
                gam_creative_id?: (string|null);
            }

            class GoogleManagedAdDetails implements IGoogleManagedAdDetails {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IGoogleManagedAdDetails);
                public gam_order_id: string;
                public gam_line_item_id: string;
                public gam_creative_id: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IGoogleManagedAdDetails, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.GoogleManagedAdDetails;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.GoogleManagedAdDetails;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.GoogleManagedAdDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdBalloonOpened {
            }

            class VideoAdBalloonOpened implements IVideoAdBalloonOpened {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdBalloonOpened);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdBalloonOpened, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdBalloonOpened;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdBalloonOpened;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdBalloonOpened, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdClickedOnBalloonCta {
            }

            class VideoAdClickedOnBalloonCta implements IVideoAdClickedOnBalloonCta {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClickedOnBalloonCta);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClickedOnBalloonCta, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdClickedOnBalloonCta;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdClickedOnBalloonCta;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdClickedOnBalloonCta, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdClosed {
                complete_video_watched?: (boolean|null);
                total_watch_time_ms?: (number|Long|null);
            }

            class VideoAdClosed implements IVideoAdClosed {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClosed);
                public complete_video_watched: boolean;
                public total_watch_time_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdClosed, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdClosed;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdClosed;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdClosed, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdCTAClicked {
                cta_url?: (string|null);
            }

            class VideoAdCTAClicked implements IVideoAdCTAClicked {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdCTAClicked);
                public cta_url: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdCTAClicked, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdCTAClicked;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdCTAClicked;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdCTAClicked, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdFailure {
                failure_type?: (POGOProtos.Rpc.ReportAdInteractionProto.VideoAdFailure.FailureType|null);
            }

            class VideoAdFailure implements IVideoAdFailure {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdFailure);
                public failure_type: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdFailure.FailureType;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdFailure, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdFailure;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdFailure;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdFailure, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace VideoAdFailure {

                enum FailureType {
                    UNKNOWN = 0,
                    VIDEO_LOAD_FAILURE = 1,
                    VIDEO_REWARD_FAILURE = 2
                }
            }

            interface IVideoAdLoaded {
                total_load_time_ms?: (number|Long|null);
            }

            class VideoAdLoaded implements IVideoAdLoaded {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdLoaded);
                public total_load_time_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdLoaded, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdLoaded;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdLoaded;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdLoaded, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdOpened {
            }

            class VideoAdOpened implements IVideoAdOpened {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdOpened);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdOpened, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdOpened;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdOpened;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdOpened, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdPlayerRewarded {
            }

            class VideoAdPlayerRewarded implements IVideoAdPlayerRewarded {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdPlayerRewarded);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdPlayerRewarded, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdPlayerRewarded;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdPlayerRewarded;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdPlayerRewarded, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVideoAdRewardEligible {
            }

            class VideoAdRewardEligible implements IVideoAdRewardEligible {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdRewardEligible);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IVideoAdRewardEligible, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdRewardEligible;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.VideoAdRewardEligible;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.VideoAdRewardEligible, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IViewFullscreenInteraction {
                fullscreen_image_url?: (string|null);
            }

            class ViewFullscreenInteraction implements IViewFullscreenInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IViewFullscreenInteraction);
                public fullscreen_image_url: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IViewFullscreenInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.ViewFullscreenInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.ViewFullscreenInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.ViewFullscreenInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IViewImpressionInteraction {
                preview_image_url?: (string|null);
                is_persisted_gift?: (boolean|null);
            }

            class ViewImpressionInteraction implements IViewImpressionInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IViewImpressionInteraction);
                public preview_image_url: string;
                public is_persisted_gift: boolean;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IViewImpressionInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.ViewImpressionInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.ViewImpressionInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.ViewImpressionInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IViewWebArInteraction {
                web_ar_url?: (string|null);
            }

            class ViewWebArInteraction implements IViewWebArInteraction {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IViewWebArInteraction);
                public web_ar_url: string;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IViewWebArInteraction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.ViewWebArInteraction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.ViewWebArInteraction;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.ViewWebArInteraction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWebArAudienceDeviceStatus {
                is_webcam_enabled?: (boolean|null);
            }

            class WebArAudienceDeviceStatus implements IWebArAudienceDeviceStatus {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IWebArAudienceDeviceStatus);
                public is_webcam_enabled: boolean;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IWebArAudienceDeviceStatus, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.WebArAudienceDeviceStatus;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.WebArAudienceDeviceStatus;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.WebArAudienceDeviceStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWebArCameraPermissionRequestSent {
            }

            class WebArCameraPermissionRequestSent implements IWebArCameraPermissionRequestSent {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionRequestSent);
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionRequestSent, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.WebArCameraPermissionRequestSent;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.WebArCameraPermissionRequestSent;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.WebArCameraPermissionRequestSent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWebArCameraPermissionResponse {
                allow_camera_permission?: (boolean|null);
            }

            class WebArCameraPermissionResponse implements IWebArCameraPermissionResponse {
                constructor(properties?: POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionResponse);
                public allow_camera_permission: boolean;
                public static encode(message: POGOProtos.Rpc.ReportAdInteractionProto.IWebArCameraPermissionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionProto.WebArCameraPermissionResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionProto.WebArCameraPermissionResponse;
                public static toObject(message: POGOProtos.Rpc.ReportAdInteractionProto.WebArCameraPermissionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IReportAdInteractionResponse {
            status?: (POGOProtos.Rpc.ReportAdInteractionResponse.Status|null);
        }

        class ReportAdInteractionResponse implements IReportAdInteractionResponse {
            constructor(properties?: POGOProtos.Rpc.IReportAdInteractionResponse);
            public status: POGOProtos.Rpc.ReportAdInteractionResponse.Status;
            public static encode(message: POGOProtos.Rpc.IReportAdInteractionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportAdInteractionResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportAdInteractionResponse;
            public static toObject(message: POGOProtos.Rpc.ReportAdInteractionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReportAdInteractionResponse {

            enum Status {
                SUCCESS = 0,
                MALFORMED = 1,
                EXPIRED = 2
            }
        }

        interface IReportProximityContactsRequestProto {
            contacts?: (POGOProtos.Rpc.IProximityContact[]|null);
        }

        class ReportProximityContactsRequestProto implements IReportProximityContactsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IReportProximityContactsRequestProto);
            public contacts: POGOProtos.Rpc.IProximityContact[];
            public static encode(message: POGOProtos.Rpc.IReportProximityContactsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportProximityContactsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportProximityContactsRequestProto;
            public static toObject(message: POGOProtos.Rpc.ReportProximityContactsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReportProximityContactsResponseProto {
        }

        class ReportProximityContactsResponseProto implements IReportProximityContactsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IReportProximityContactsResponseProto);
            public static encode(message: POGOProtos.Rpc.IReportProximityContactsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportProximityContactsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportProximityContactsResponseProto;
            public static toObject(message: POGOProtos.Rpc.ReportProximityContactsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReportRouteOutProto {
            result?: (POGOProtos.Rpc.ReportRouteOutProto.Result|null);
            consolation_reward?: (POGOProtos.Rpc.ILootProto|null);
        }

        class ReportRouteOutProto implements IReportRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.IReportRouteOutProto);
            public result: POGOProtos.Rpc.ReportRouteOutProto.Result;
            public consolation_reward?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IReportRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.ReportRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReportRouteOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ROUTE_NOT_FOUND = 2,
                ERROR_TOO_MANY_REPORTS = 3,
                ERROR_UNKNOWN = 4,
                ERROR_REPORTED_THIS_RECENTLY = 5
            }
        }

        interface IReportRouteProto {
            route_id?: (string|null);
            route_violations?: (POGOProtos.Rpc.ReportRouteProto.Violation[]|null);
            quality_issues?: (POGOProtos.Rpc.ReportRouteProto.QualityIssue[]|null);
            gameplay_issues?: (POGOProtos.Rpc.ReportRouteProto.GameplayIssue[]|null);
        }

        class ReportRouteProto implements IReportRouteProto {
            constructor(properties?: POGOProtos.Rpc.IReportRouteProto);
            public route_id: string;
            public route_violations: POGOProtos.Rpc.ReportRouteProto.Violation[];
            public quality_issues: POGOProtos.Rpc.ReportRouteProto.QualityIssue[];
            public gameplay_issues: POGOProtos.Rpc.ReportRouteProto.GameplayIssue[];
            public static encode(message: POGOProtos.Rpc.IReportRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportRouteProto;
            public static toObject(message: POGOProtos.Rpc.ReportRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReportRouteProto {

            enum GameplayIssue {
                UNSET_GAMEPLAY_ISSUE = 0,
                NO_ZYGARDE_CELLS = 1,
                BUDDY_CANDY_BONUS_NOT_WORKING = 2,
                INCENSE_BONUS_NOT_WORKING = 3,
                INSUFFICIENT_REWARDS = 4,
                COULD_NOT_COMPLETE_ROUTE = 5,
                ROUTE_PAUSED_INCORRECTLY = 6,
                DISTANCE_TRACKED_INCORRECT = 7,
                GPS_DRIFT = 8
            }

            enum QualityIssue {
                UNSET_QUALITY_ISSUE = 0,
                ROUTE_NAME_OR_DESCRIPTION_ERRONEOUS = 1,
                ROUTE_NAME_OR_DESCRIPTION_UNCLEAR_OR_INACCURATE = 2,
                ROUTE_DIFFICULT_TO_FOLLOW = 3,
                ROUTE_FREQUENT_OVERLAP = 4,
                ROUTE_TOO_SHORT_OR_LONG = 5,
                ROUTE_TOO_STRENUOUS = 6,
                ROUTE_POOR_CONNECTIVITY = 7
            }

            enum Violation {
                UNSET = 0,
                PRIVATE_RESIDENCE = 1,
                SENSITIVE_LOCATION = 2,
                ADULT_ESTABLISHMENT = 3,
                GRADE_SCHOOL = 4,
                INACCESSIBLE = 5,
                DANGEROUS = 6,
                TEMPORARY_OBSTRUCTION = 7,
                CHILD_SAFETY = 8,
                DANGEROUS_GOODS = 9,
                SEXUAL_OR_VIOLENT = 10,
                SELF_HARM = 11,
                HARASSMENT_OR_HATE_SPEECH = 12,
                PERSONAL_INFO = 13,
                GAME_CHEATS_OR_SPAM = 14,
                PRIVACY_INVASION_ABUSIVE = 15,
                OTHER_INAPPROPRIATE = 16,
                MISINFORMATION = 17,
                IMPERSONATION = 18,
                EXTREMISM = 19,
                SEXUAL = 1001,
                VIOLENT = 1002,
                HARASSMENT = 1201,
                HATE_SPEECH = 1202,
                GAME_CHEATS = 1401,
                SPAM = 1402
            }
        }

        interface IReportStationOutProto {
            result?: (POGOProtos.Rpc.ReportStationOutProto.Result|null);
        }

        class ReportStationOutProto implements IReportStationOutProto {
            constructor(properties?: POGOProtos.Rpc.IReportStationOutProto);
            public result: POGOProtos.Rpc.ReportStationOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IReportStationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportStationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportStationOutProto;
            public static toObject(message: POGOProtos.Rpc.ReportStationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ReportStationOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ALREADY_REPORTED = 2,
                INVALID_REQUEST = 3,
                ERROR_OTHER = 4
            }
        }

        interface IReportStationProto {
            station_id?: (string|null);
            report_reason?: (string|null);
            violations?: (POGOProtos.Rpc.ReportRouteProto.Violation[]|null);
        }

        class ReportStationProto implements IReportStationProto {
            constructor(properties?: POGOProtos.Rpc.IReportStationProto);
            public station_id: string;
            public report_reason: string;
            public violations: POGOProtos.Rpc.ReportRouteProto.Violation[];
            public static encode(message: POGOProtos.Rpc.IReportStationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReportStationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReportStationProto;
            public static toObject(message: POGOProtos.Rpc.ReportStationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IReviveAttributesProto {
            sta_percent?: (number|null);
        }

        class ReviveAttributesProto implements IReviveAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IReviveAttributesProto);
            public sta_percent: number;
            public static encode(message: POGOProtos.Rpc.IReviveAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ReviveAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ReviveAttributesProto;
            public static toObject(message: POGOProtos.Rpc.ReviveAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRewardedSpendItemProto {
            item?: (string|null);
            quantity?: (number|null);
        }

        class RewardedSpendItemProto implements IRewardedSpendItemProto {
            constructor(properties?: POGOProtos.Rpc.IRewardedSpendItemProto);
            public item: string;
            public quantity: number;
            public static encode(message: POGOProtos.Rpc.IRewardedSpendItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RewardedSpendItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RewardedSpendItemProto;
            public static toObject(message: POGOProtos.Rpc.RewardedSpendItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRewardedSpendStateProto {
            start_timestamp_ms?: (number|Long|null);
            earned_points?: (number|Long|null);
            claimed_tier_points?: (number|Long|null);
            earned_tier_points?: (number|Long|null);
            earned_tier?: (number|null);
        }

        class RewardedSpendStateProto implements IRewardedSpendStateProto {
            constructor(properties?: POGOProtos.Rpc.IRewardedSpendStateProto);
            public start_timestamp_ms: (number|Long);
            public earned_points: (number|Long);
            public claimed_tier_points: (number|Long);
            public earned_tier_points: (number|Long);
            public earned_tier: number;
            public static encode(message: POGOProtos.Rpc.IRewardedSpendStateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RewardedSpendStateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RewardedSpendStateProto;
            public static toObject(message: POGOProtos.Rpc.RewardedSpendStateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRewardedSpendTierListProto {
            rewarded_spend_tiers?: (POGOProtos.Rpc.IRewardedSpendTierProto[]|null);
            start_time_ms?: (number|Long|null);
            end_time_ms?: (number|Long|null);
        }

        class RewardedSpendTierListProto implements IRewardedSpendTierListProto {
            constructor(properties?: POGOProtos.Rpc.IRewardedSpendTierListProto);
            public rewarded_spend_tiers: POGOProtos.Rpc.IRewardedSpendTierProto[];
            public start_time_ms: (number|Long);
            public end_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRewardedSpendTierListProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RewardedSpendTierListProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RewardedSpendTierListProto;
            public static toObject(message: POGOProtos.Rpc.RewardedSpendTierListProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRewardedSpendTierProto {
            min_reward_point?: (number|null);
            rewarded_spend_items?: (POGOProtos.Rpc.IRewardedSpendItemProto[]|null);
        }

        class RewardedSpendTierProto implements IRewardedSpendTierProto {
            constructor(properties?: POGOProtos.Rpc.IRewardedSpendTierProto);
            public min_reward_point: number;
            public rewarded_spend_items: POGOProtos.Rpc.IRewardedSpendItemProto[];
            public static encode(message: POGOProtos.Rpc.IRewardedSpendTierProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RewardedSpendTierProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RewardedSpendTierProto;
            public static toObject(message: POGOProtos.Rpc.RewardedSpendTierProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRewardsPerContestProto {
            contest_id?: (string|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
        }

        class RewardsPerContestProto implements IRewardsPerContestProto {
            constructor(properties?: POGOProtos.Rpc.IRewardsPerContestProto);
            public contest_id: string;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IRewardsPerContestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RewardsPerContestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RewardsPerContestProto;
            public static toObject(message: POGOProtos.Rpc.RewardsPerContestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoadMetadata {
            is_tunnel?: (boolean|null);
            railway_is_siding?: (boolean|null);
            network?: (string|null);
            shield_text?: (string|null);
            route?: (string|null);
        }

        class RoadMetadata implements IRoadMetadata {
            constructor(properties?: POGOProtos.Rpc.IRoadMetadata);
            public is_tunnel: boolean;
            public railway_is_siding: boolean;
            public network: string;
            public shield_text: string;
            public route: string;
            public static encode(message: POGOProtos.Rpc.IRoadMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoadMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoadMetadata;
            public static toObject(message: POGOProtos.Rpc.RoadMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRocketBalloonDisplayProto {
            type?: (POGOProtos.Rpc.RocketBalloonDisplayProto.BalloonType|null);
            incident_display?: (POGOProtos.Rpc.IRocketBalloonIncidentDisplayProto|null);
        }

        class RocketBalloonDisplayProto implements IRocketBalloonDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IRocketBalloonDisplayProto);
            public type: POGOProtos.Rpc.RocketBalloonDisplayProto.BalloonType;
            public incident_display?: (POGOProtos.Rpc.IRocketBalloonIncidentDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IRocketBalloonDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RocketBalloonDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RocketBalloonDisplayProto;
            public static toObject(message: POGOProtos.Rpc.RocketBalloonDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RocketBalloonDisplayProto {

            enum BalloonType {
                ROCKET = 0,
                ROCKET_B = 1
            }
        }

        interface IRocketBalloonGlobalSettingsProto {
            min_player_level?: (number|null);
        }

        class RocketBalloonGlobalSettingsProto implements IRocketBalloonGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRocketBalloonGlobalSettingsProto);
            public min_player_level: number;
            public static encode(message: POGOProtos.Rpc.IRocketBalloonGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RocketBalloonGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RocketBalloonGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RocketBalloonGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRocketBalloonIncidentDisplayProto {
            incident_id?: (string|null);
            incident_display_type?: (POGOProtos.Rpc.IncidentDisplayType|null);
        }

        class RocketBalloonIncidentDisplayProto implements IRocketBalloonIncidentDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IRocketBalloonIncidentDisplayProto);
            public incident_id: string;
            public incident_display_type: POGOProtos.Rpc.IncidentDisplayType;
            public static encode(message: POGOProtos.Rpc.IRocketBalloonIncidentDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RocketBalloonIncidentDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RocketBalloonIncidentDisplayProto;
            public static toObject(message: POGOProtos.Rpc.RocketBalloonIncidentDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRollBackProto {
            rollback_percentage?: (number|null);
            code_gate_owner?: (string|null);
            expiration_timestamp_ms?: (number|Long|null);
        }

        class RollBackProto implements IRollBackProto {
            constructor(properties?: POGOProtos.Rpc.IRollBackProto);
            public rollback_percentage: number;
            public code_gate_owner: string;
            public expiration_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRollBackProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RollBackProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RollBackProto;
            public static toObject(message: POGOProtos.Rpc.RollBackProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoom {
            room_id?: (string|null);
            peers?: (number[]|null);
            capacity?: (number|null);
            experience_id?: (string|null);
            name?: (string|null);
            description?: (string|null);
            passcode_enabled?: (boolean|null);
            app_id?: (string|null);
            endpoint?: (string|null);
        }

        class Room implements IRoom {
            constructor(properties?: POGOProtos.Rpc.IRoom);
            public room_id: string;
            public peers: number[];
            public capacity: number;
            public experience_id: string;
            public name: string;
            public description: string;
            public passcode_enabled: boolean;
            public app_id: string;
            public endpoint: string;
            public static encode(message: POGOProtos.Rpc.IRoom, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Room;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Room;
            public static toObject(message: POGOProtos.Rpc.Room, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRotateGuestLoginSecretTokenRequestProto {
            secret?: (Uint8Array|null);
            api_key?: (string|null);
            device_id?: (string|null);
        }

        class RotateGuestLoginSecretTokenRequestProto implements IRotateGuestLoginSecretTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.IRotateGuestLoginSecretTokenRequestProto);
            public secret: Uint8Array;
            public api_key: string;
            public device_id: string;
            public static encode(message: POGOProtos.Rpc.IRotateGuestLoginSecretTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RotateGuestLoginSecretTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RotateGuestLoginSecretTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.RotateGuestLoginSecretTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRotateGuestLoginSecretTokenResponseProto {
            status?: (POGOProtos.Rpc.RotateGuestLoginSecretTokenResponseProto.Status|null);
            new_secret?: (Uint8Array|null);
        }

        class RotateGuestLoginSecretTokenResponseProto implements IRotateGuestLoginSecretTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.IRotateGuestLoginSecretTokenResponseProto);
            public status: POGOProtos.Rpc.RotateGuestLoginSecretTokenResponseProto.Status;
            public new_secret: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IRotateGuestLoginSecretTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RotateGuestLoginSecretTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RotateGuestLoginSecretTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.RotateGuestLoginSecretTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RotateGuestLoginSecretTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                UNKNOWN_ERROR = 2,
                UNAUTHORIZED = 3,
                INVALID_AUTH_TOKEN = 4
            }
        }

        interface IRouteActivityRequestProto {
            pokemon_trade_request?: (POGOProtos.Rpc.RouteActivityRequestProto.IPokemonTradeRequest|null);
            pokemon_compare_request?: (POGOProtos.Rpc.RouteActivityRequestProto.IPokemonCompareRequest|null);
            gift_trade_request?: (POGOProtos.Rpc.RouteActivityRequestProto.IGiftTradeRequest|null);
        }

        class RouteActivityRequestProto implements IRouteActivityRequestProto {
            constructor(properties?: POGOProtos.Rpc.IRouteActivityRequestProto);
            public pokemon_trade_request?: (POGOProtos.Rpc.RouteActivityRequestProto.IPokemonTradeRequest|null);
            public pokemon_compare_request?: (POGOProtos.Rpc.RouteActivityRequestProto.IPokemonCompareRequest|null);
            public gift_trade_request?: (POGOProtos.Rpc.RouteActivityRequestProto.IGiftTradeRequest|null);
            public RequestData?: ("pokemon_trade_request"|"pokemon_compare_request"|"gift_trade_request");
            public static encode(message: POGOProtos.Rpc.IRouteActivityRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityRequestProto;
            public static toObject(message: POGOProtos.Rpc.RouteActivityRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteActivityRequestProto {

            interface IGiftTradeRequest {
            }

            class GiftTradeRequest implements IGiftTradeRequest {
                constructor(properties?: POGOProtos.Rpc.RouteActivityRequestProto.IGiftTradeRequest);
                public static encode(message: POGOProtos.Rpc.RouteActivityRequestProto.IGiftTradeRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityRequestProto.GiftTradeRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityRequestProto.GiftTradeRequest;
                public static toObject(message: POGOProtos.Rpc.RouteActivityRequestProto.GiftTradeRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonCompareRequest {
            }

            class PokemonCompareRequest implements IPokemonCompareRequest {
                constructor(properties?: POGOProtos.Rpc.RouteActivityRequestProto.IPokemonCompareRequest);
                public static encode(message: POGOProtos.Rpc.RouteActivityRequestProto.IPokemonCompareRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityRequestProto.PokemonCompareRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityRequestProto.PokemonCompareRequest;
                public static toObject(message: POGOProtos.Rpc.RouteActivityRequestProto.PokemonCompareRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonTradeRequest {
                pokemon_id?: (number|Long|null);
            }

            class PokemonTradeRequest implements IPokemonTradeRequest {
                constructor(properties?: POGOProtos.Rpc.RouteActivityRequestProto.IPokemonTradeRequest);
                public pokemon_id: (number|Long);
                public static encode(message: POGOProtos.Rpc.RouteActivityRequestProto.IPokemonTradeRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityRequestProto.PokemonTradeRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityRequestProto.PokemonTradeRequest;
                public static toObject(message: POGOProtos.Rpc.RouteActivityRequestProto.PokemonTradeRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IRouteActivityResponseProto {
            pokemon_trade_response?: (POGOProtos.Rpc.RouteActivityResponseProto.IPokemonTradeResponse|null);
            pokemon_compare_response?: (POGOProtos.Rpc.RouteActivityResponseProto.IPokemonCompareResponse|null);
            gift_trade_response?: (POGOProtos.Rpc.RouteActivityResponseProto.IGiftTradeResponse|null);
            activity_reward?: (POGOProtos.Rpc.ILootProto|null);
            postcard_data?: (POGOProtos.Rpc.IActivityPostcardData|null);
        }

        class RouteActivityResponseProto implements IRouteActivityResponseProto {
            constructor(properties?: POGOProtos.Rpc.IRouteActivityResponseProto);
            public pokemon_trade_response?: (POGOProtos.Rpc.RouteActivityResponseProto.IPokemonTradeResponse|null);
            public pokemon_compare_response?: (POGOProtos.Rpc.RouteActivityResponseProto.IPokemonCompareResponse|null);
            public gift_trade_response?: (POGOProtos.Rpc.RouteActivityResponseProto.IGiftTradeResponse|null);
            public activity_reward?: (POGOProtos.Rpc.ILootProto|null);
            public postcard_data?: (POGOProtos.Rpc.IActivityPostcardData|null);
            public ResponseData?: ("pokemon_trade_response"|"pokemon_compare_response"|"gift_trade_response");
            public static encode(message: POGOProtos.Rpc.IRouteActivityResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityResponseProto;
            public static toObject(message: POGOProtos.Rpc.RouteActivityResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteActivityResponseProto {

            interface IGiftTradeResponse {
            }

            class GiftTradeResponse implements IGiftTradeResponse {
                constructor(properties?: POGOProtos.Rpc.RouteActivityResponseProto.IGiftTradeResponse);
                public static encode(message: POGOProtos.Rpc.RouteActivityResponseProto.IGiftTradeResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityResponseProto.GiftTradeResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityResponseProto.GiftTradeResponse;
                public static toObject(message: POGOProtos.Rpc.RouteActivityResponseProto.GiftTradeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonCompareResponse {
            }

            class PokemonCompareResponse implements IPokemonCompareResponse {
                constructor(properties?: POGOProtos.Rpc.RouteActivityResponseProto.IPokemonCompareResponse);
                public static encode(message: POGOProtos.Rpc.RouteActivityResponseProto.IPokemonCompareResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityResponseProto.PokemonCompareResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityResponseProto.PokemonCompareResponse;
                public static toObject(message: POGOProtos.Rpc.RouteActivityResponseProto.PokemonCompareResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonTradeResponse {
                result?: (POGOProtos.Rpc.RouteActivityResponseProto.PokemonTradeResponse.Result|null);
                pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            }

            class PokemonTradeResponse implements IPokemonTradeResponse {
                constructor(properties?: POGOProtos.Rpc.RouteActivityResponseProto.IPokemonTradeResponse);
                public result: POGOProtos.Rpc.RouteActivityResponseProto.PokemonTradeResponse.Result;
                public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                public static encode(message: POGOProtos.Rpc.RouteActivityResponseProto.IPokemonTradeResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityResponseProto.PokemonTradeResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityResponseProto.PokemonTradeResponse;
                public static toObject(message: POGOProtos.Rpc.RouteActivityResponseProto.PokemonTradeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PokemonTradeResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_INVALID_POKEMON = 2
                }
            }
        }

        interface IRouteActivityType {
        }

        class RouteActivityType implements IRouteActivityType {
            constructor(properties?: POGOProtos.Rpc.IRouteActivityType);
            public static encode(message: POGOProtos.Rpc.IRouteActivityType, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteActivityType;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteActivityType;
            public static toObject(message: POGOProtos.Rpc.RouteActivityType, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteActivityType {

            enum ActivityType {
                UNSET = 0,
                NO_ACTIVITY = 1,
                ACTIVITY_POKEMON_TRADE = 2,
                ACTIVITY_POKEMON_COMPARE = 3,
                ACTIVITY_GIFT_TRADE = 4
            }
        }

        interface IRouteBadgeLevel {
        }

        class RouteBadgeLevel implements IRouteBadgeLevel {
            constructor(properties?: POGOProtos.Rpc.IRouteBadgeLevel);
            public static encode(message: POGOProtos.Rpc.IRouteBadgeLevel, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteBadgeLevel;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteBadgeLevel;
            public static toObject(message: POGOProtos.Rpc.RouteBadgeLevel, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteBadgeLevel {

            enum BadgeLevel {
                ROUTE_BADGE_UNSET = 0,
                ROUTE_BADGE_BRONZE = 1,
                ROUTE_BADGE_SILVER = 2,
                ROUTE_BADGE_GOLD = 3
            }
        }

        interface IRouteBadgeListEntry {
            route_id?: (string|null);
            route_type?: (POGOProtos.Rpc.RouteType|null);
            start_lat?: (number|null);
            start_lng?: (number|null);
            route_name?: (string|null);
            route_image_url?: (string|null);
            last_play_end_time?: (number|Long|null);
            num_completions?: (number|null);
            route_duration_seconds?: (number|Long|null);
            num_unique_stamps_collected?: (number|null);
        }

        class RouteBadgeListEntry implements IRouteBadgeListEntry {
            constructor(properties?: POGOProtos.Rpc.IRouteBadgeListEntry);
            public route_id: string;
            public route_type: POGOProtos.Rpc.RouteType;
            public start_lat: number;
            public start_lng: number;
            public route_name: string;
            public route_image_url: string;
            public last_play_end_time: (number|Long);
            public num_completions: number;
            public route_duration_seconds: (number|Long);
            public num_unique_stamps_collected: number;
            public static encode(message: POGOProtos.Rpc.IRouteBadgeListEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteBadgeListEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteBadgeListEntry;
            public static toObject(message: POGOProtos.Rpc.RouteBadgeListEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteBadgeSettingsProto {
            target?: (number[]|null);
        }

        class RouteBadgeSettingsProto implements IRouteBadgeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteBadgeSettingsProto);
            public target: number[];
            public static encode(message: POGOProtos.Rpc.IRouteBadgeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteBadgeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteBadgeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RouteBadgeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteCreationProto {
            created_time?: (number|Long|null);
            last_update_time?: (number|Long|null);
            status?: (POGOProtos.Rpc.RouteCreationProto.Status|null);
            rejection_reason?: (POGOProtos.Rpc.RouteCreationProto.IRejectionReason[]|null);
            rejected_hash?: ((number|Long)[]|null);
            route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            paused?: (boolean|null);
            moderation_report_id?: (string|null);
            editable_post_rejection?: (boolean|null);
        }

        class RouteCreationProto implements IRouteCreationProto {
            constructor(properties?: POGOProtos.Rpc.IRouteCreationProto);
            public created_time: (number|Long);
            public last_update_time: (number|Long);
            public status: POGOProtos.Rpc.RouteCreationProto.Status;
            public rejection_reason: POGOProtos.Rpc.RouteCreationProto.IRejectionReason[];
            public rejected_hash: (number|Long)[];
            public route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public paused: boolean;
            public moderation_report_id: string;
            public editable_post_rejection: boolean;
            public static encode(message: POGOProtos.Rpc.IRouteCreationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteCreationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteCreationProto;
            public static toObject(message: POGOProtos.Rpc.RouteCreationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteCreationProto {

            enum Status {
                UNSET = 0,
                IN_PROGRESS = 1,
                SUBMITTED = 2,
                REJECTED = 3,
                SUBMITTED_PENDING_REVIEW = 4
            }

            interface IRejectionReason {
                reason_code?: (string|null);
            }

            class RejectionReason implements IRejectionReason {
                constructor(properties?: POGOProtos.Rpc.RouteCreationProto.IRejectionReason);
                public reason_code: string;
                public static encode(message: POGOProtos.Rpc.RouteCreationProto.IRejectionReason, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteCreationProto.RejectionReason;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteCreationProto.RejectionReason;
                public static toObject(message: POGOProtos.Rpc.RouteCreationProto.RejectionReason, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IRouteCreationsProto {
            route?: (POGOProtos.Rpc.IRouteCreationProto[]|null);
            is_official_creator?: (boolean|null);
            recently_submitted_route?: (POGOProtos.Rpc.IRouteCreationProto[]|null);
            not_eligible?: (boolean|null);
            recently_submitted_routes_last_refresh_timestamp_ms?: (number|Long|null);
            moderation_retry_timestamp_ms?: (number|Long|null);
            can_use_sponsored_poi?: (boolean|null);
        }

        class RouteCreationsProto implements IRouteCreationsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteCreationsProto);
            public route: POGOProtos.Rpc.IRouteCreationProto[];
            public is_official_creator: boolean;
            public recently_submitted_route: POGOProtos.Rpc.IRouteCreationProto[];
            public not_eligible: boolean;
            public recently_submitted_routes_last_refresh_timestamp_ms: (number|Long);
            public moderation_retry_timestamp_ms: (number|Long);
            public can_use_sponsored_poi: boolean;
            public static encode(message: POGOProtos.Rpc.IRouteCreationsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteCreationsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteCreationsProto;
            public static toObject(message: POGOProtos.Rpc.RouteCreationsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteDecaySettingsProto {
            one_star_rating_points?: (number|null);
            two_star_rating_points?: (number|null);
            three_star_rating_points?: (number|null);
            four_star_rating_points?: (number|null);
            five_star_rating_points?: (number|null);
            start_points?: (number|null);
            finish_points?: (number|null);
            km_points?: (number|null);
            report_points?: (number|null);
            initial_points?: (number|null);
            npc_interaction_points?: (number|null);
            min_route_score?: (number|null);
            max_route_score?: (number|null);
            nearby_routes_factor_polynomial_square?: (number|null);
            nearby_routes_factor_polynomial_linear?: (number|null);
            nearby_routes_factor_polynomial_constant?: (number|null);
            time_factor_polynomial_square?: (number|null);
            time_factor_polynomial_linear?: (number|null);
            time_factor_polynomial_constant?: (number|null);
            enabled?: (boolean|null);
            random_scaling_factor?: (number|null);
            max_routes_per_cell?: (number|null);
        }

        class RouteDecaySettingsProto implements IRouteDecaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteDecaySettingsProto);
            public one_star_rating_points: number;
            public two_star_rating_points: number;
            public three_star_rating_points: number;
            public four_star_rating_points: number;
            public five_star_rating_points: number;
            public start_points: number;
            public finish_points: number;
            public km_points: number;
            public report_points: number;
            public initial_points: number;
            public npc_interaction_points: number;
            public min_route_score: number;
            public max_route_score: number;
            public nearby_routes_factor_polynomial_square: number;
            public nearby_routes_factor_polynomial_linear: number;
            public nearby_routes_factor_polynomial_constant: number;
            public time_factor_polynomial_square: number;
            public time_factor_polynomial_linear: number;
            public time_factor_polynomial_constant: number;
            public enabled: boolean;
            public random_scaling_factor: number;
            public max_routes_per_cell: number;
            public static encode(message: POGOProtos.Rpc.IRouteDecaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteDecaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteDecaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.RouteDecaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteDiscoverySettingsProto {
            nearby_visible_radius_meters?: (number|null);
            min_player_level?: (number|null);
            popular_routes_fraction?: (number|null);
            new_route_threshold?: (number|null);
            max_routes_viewable?: (number|null);
            max_client_map_panning_distance_meters?: (number|null);
            route_discovery_filtering_max_poi_distance?: (number|null);
            route_discovery_filtering_min_poi_distance?: (number|null);
            route_discovery_filtering_max_player_distance?: (number|null);
            enable_badge_routes_discovery?: (boolean|null);
            max_badge_routes_discovery_spanner_txns?: (number|null);
            max_favorite_routes?: (number|null);
        }

        class RouteDiscoverySettingsProto implements IRouteDiscoverySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteDiscoverySettingsProto);
            public nearby_visible_radius_meters: number;
            public min_player_level: number;
            public popular_routes_fraction: number;
            public new_route_threshold: number;
            public max_routes_viewable: number;
            public max_client_map_panning_distance_meters: number;
            public route_discovery_filtering_max_poi_distance: number;
            public route_discovery_filtering_min_poi_distance: number;
            public route_discovery_filtering_max_player_distance: number;
            public enable_badge_routes_discovery: boolean;
            public max_badge_routes_discovery_spanner_txns: number;
            public max_favorite_routes: number;
            public static encode(message: POGOProtos.Rpc.IRouteDiscoverySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteDiscoverySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteDiscoverySettingsProto;
            public static toObject(message: POGOProtos.Rpc.RouteDiscoverySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteDiscoveryTelemetry {
            route_discovery_telemetry_id?: (POGOProtos.Rpc.RouteDiscoveryTelemetryIds|null);
            percent?: (number|null);
            route_id?: (string|null);
        }

        class RouteDiscoveryTelemetry implements IRouteDiscoveryTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRouteDiscoveryTelemetry);
            public route_discovery_telemetry_id: POGOProtos.Rpc.RouteDiscoveryTelemetryIds;
            public percent: number;
            public route_id: string;
            public static encode(message: POGOProtos.Rpc.IRouteDiscoveryTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteDiscoveryTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteDiscoveryTelemetry;
            public static toObject(message: POGOProtos.Rpc.RouteDiscoveryTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteErrorTelemetry {
            route_error_telemetry_id?: (POGOProtos.Rpc.RouteErrorTelemetryIds|null);
            error_description?: (string|null);
            timestamp?: (number|Long|null);
        }

        class RouteErrorTelemetry implements IRouteErrorTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRouteErrorTelemetry);
            public route_error_telemetry_id: POGOProtos.Rpc.RouteErrorTelemetryIds;
            public error_description: string;
            public timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRouteErrorTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteErrorTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteErrorTelemetry;
            public static toObject(message: POGOProtos.Rpc.RouteErrorTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteGlobalSettingsProto {
            enable_routes?: (boolean|null);
            enable_poi_detail_caching?: (boolean|null);
            enable_route_play?: (boolean|null);
            enable_route_tappables?: (boolean|null);
            max_client_nearby_map_panning_distance_meters?: (number|null);
            distance_to_resume_route_meters?: (number|null);
            minimum_client_version?: (string|null);
            minimum_client_version_to_play?: (string|null);
            minimum_client_version_to_create?: (string|null);
            appeal_message_length?: (number|null);
        }

        class RouteGlobalSettingsProto implements IRouteGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteGlobalSettingsProto);
            public enable_routes: boolean;
            public enable_poi_detail_caching: boolean;
            public enable_route_play: boolean;
            public enable_route_tappables: boolean;
            public max_client_nearby_map_panning_distance_meters: number;
            public distance_to_resume_route_meters: number;
            public minimum_client_version: string;
            public minimum_client_version_to_play: string;
            public minimum_client_version_to_create: string;
            public appeal_message_length: number;
            public static encode(message: POGOProtos.Rpc.IRouteGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RouteGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteImageProto {
            image_url?: (string|null);
            border_color_hex?: (string|null);
        }

        class RouteImageProto implements IRouteImageProto {
            constructor(properties?: POGOProtos.Rpc.IRouteImageProto);
            public image_url: string;
            public border_color_hex: string;
            public static encode(message: POGOProtos.Rpc.IRouteImageProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteImageProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteImageProto;
            public static toObject(message: POGOProtos.Rpc.RouteImageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteNearbyNotifShownOutProto {
            result?: (POGOProtos.Rpc.RouteNearbyNotifShownOutProto.Result|null);
        }

        class RouteNearbyNotifShownOutProto implements IRouteNearbyNotifShownOutProto {
            constructor(properties?: POGOProtos.Rpc.IRouteNearbyNotifShownOutProto);
            public result: POGOProtos.Rpc.RouteNearbyNotifShownOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IRouteNearbyNotifShownOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteNearbyNotifShownOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteNearbyNotifShownOutProto;
            public static toObject(message: POGOProtos.Rpc.RouteNearbyNotifShownOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteNearbyNotifShownOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IRouteNearbyNotifShownProto {
        }

        class RouteNearbyNotifShownProto implements IRouteNearbyNotifShownProto {
            constructor(properties?: POGOProtos.Rpc.IRouteNearbyNotifShownProto);
            public static encode(message: POGOProtos.Rpc.IRouteNearbyNotifShownProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteNearbyNotifShownProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteNearbyNotifShownProto;
            public static toObject(message: POGOProtos.Rpc.RouteNearbyNotifShownProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteNpcGiftSettingsProto {
            max_nearby_poi_count?: (number|null);
            max_s2_cell_query_count?: (number|null);
            max_nearby_poi_distance_meters?: (number|null);
        }

        class RouteNpcGiftSettingsProto implements IRouteNpcGiftSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteNpcGiftSettingsProto);
            public max_nearby_poi_count: number;
            public max_s2_cell_query_count: number;
            public max_nearby_poi_distance_meters: number;
            public static encode(message: POGOProtos.Rpc.IRouteNpcGiftSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteNpcGiftSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteNpcGiftSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RouteNpcGiftSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePathEditParamsProto {
            enabled?: (boolean|null);
            use_auto_editing?: (boolean|null);
        }

        class RoutePathEditParamsProto implements IRoutePathEditParamsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutePathEditParamsProto);
            public enabled: boolean;
            public use_auto_editing: boolean;
            public static encode(message: POGOProtos.Rpc.IRoutePathEditParamsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePathEditParamsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePathEditParamsProto;
            public static toObject(message: POGOProtos.Rpc.RoutePathEditParamsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePin {
            pin_id?: (string|null);
            lat_degrees?: (number|null);
            lng_degrees?: (number|null);
            creator_info?: (POGOProtos.Rpc.ICreatorInfo|null);
            last_updated_timestamp_ms?: (number|Long|null);
            like_vote_total?: (number|Long|null);
            message?: (string|null);
            sticker_ids?: (string[]|null);
            sticker_total?: (number|null);
            created_timestamp_ms?: (number|Long|null);
            route_creator?: (boolean|null);
            score?: (number|Long|null);
        }

        class RoutePin implements IRoutePin {
            constructor(properties?: POGOProtos.Rpc.IRoutePin);
            public pin_id: string;
            public lat_degrees: number;
            public lng_degrees: number;
            public creator_info?: (POGOProtos.Rpc.ICreatorInfo|null);
            public last_updated_timestamp_ms: (number|Long);
            public like_vote_total: (number|Long);
            public message: string;
            public sticker_ids: string[];
            public sticker_total: number;
            public created_timestamp_ms: (number|Long);
            public route_creator: boolean;
            public score: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRoutePin, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePin;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePin;
            public static toObject(message: POGOProtos.Rpc.RoutePin, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePinSettingsProto {
            max_pins_per_route?: (number|null);
            max_distance_from_route_m?: (number|null);
            min_distance_between_pins_m?: (number|null);
            pin_tag?: (string[]|null);
            frame_id?: (string[]|null);
            pin_report_reason?: (string[]|null);
            pin_categorys?: (POGOProtos.Rpc.IPinMessage[]|null);
            recent_saved?: (number|null);
            creator_custom?: (boolean|null);
            creator_max?: (number|null);
            initial_points?: (number|null);
            like_points?: (number|null);
            sticker_points?: (number|null);
            view_points?: (number|null);
            creator_points?: (number|null);
            daily_percentage_score_reduction?: (number|null);
            max_map_clutter_delta?: (number|null);
            pins_visible_for_u13?: (boolean|null);
            create_pin_min_player_level?: (number|null);
            max_named_stickers_per_pin?: (number|null);
            max_pins_for_client_display?: (number|null);
            player_max?: (number|null);
            pin_display_auto_dismiss_seconds?: (number|null);
        }

        class RoutePinSettingsProto implements IRoutePinSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutePinSettingsProto);
            public max_pins_per_route: number;
            public max_distance_from_route_m: number;
            public min_distance_between_pins_m: number;
            public pin_tag: string[];
            public frame_id: string[];
            public pin_report_reason: string[];
            public pin_categorys: POGOProtos.Rpc.IPinMessage[];
            public recent_saved: number;
            public creator_custom: boolean;
            public creator_max: number;
            public initial_points: number;
            public like_points: number;
            public sticker_points: number;
            public view_points: number;
            public creator_points: number;
            public daily_percentage_score_reduction: number;
            public max_map_clutter_delta: number;
            public pins_visible_for_u13: boolean;
            public create_pin_min_player_level: number;
            public max_named_stickers_per_pin: number;
            public max_pins_for_client_display: number;
            public player_max: number;
            public pin_display_auto_dismiss_seconds: number;
            public static encode(message: POGOProtos.Rpc.IRoutePinSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePinSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePinSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RoutePinSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePlayProto {
            play_version?: (number|null);
            expiration_time_ms?: (number|Long|null);
            start_time_ms?: (number|Long|null);
            uniquely_acquired_stamp_count?: (number|null);
            completed_walk?: (boolean|null);
            paused?: (boolean|null);
            acquired_reward?: (boolean|null);
            has_rated?: (boolean|null);
            route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            player_breadcrumbs?: (POGOProtos.Rpc.IRouteWaypointProto[]|null);
            last_progress_time_ms?: (number|Long|null);
            is_first_time?: (boolean|null);
            active_bonuses?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            total_distance_travelled_meters?: (number|null);
            bonus_distance_travelled_meters?: (number|null);
            spawned_tappables?: (POGOProtos.Rpc.ITappable[]|null);
            travel_in_reverse?: (boolean|null);
            is_first_travel_today?: (boolean|null);
            npc_encounter?: (POGOProtos.Rpc.INpcEncounterProto|null);
        }

        class RoutePlayProto implements IRoutePlayProto {
            constructor(properties?: POGOProtos.Rpc.IRoutePlayProto);
            public play_version: number;
            public expiration_time_ms: (number|Long);
            public start_time_ms: (number|Long);
            public uniquely_acquired_stamp_count: number;
            public completed_walk: boolean;
            public paused: boolean;
            public acquired_reward: boolean;
            public has_rated: boolean;
            public route?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public player_breadcrumbs: POGOProtos.Rpc.IRouteWaypointProto[];
            public last_progress_time_ms: (number|Long);
            public is_first_time: boolean;
            public active_bonuses: POGOProtos.Rpc.IBonusBoxProto[];
            public total_distance_travelled_meters: number;
            public bonus_distance_travelled_meters: number;
            public spawned_tappables: POGOProtos.Rpc.ITappable[];
            public travel_in_reverse: boolean;
            public is_first_travel_today: boolean;
            public npc_encounter?: (POGOProtos.Rpc.INpcEncounterProto|null);
            public static encode(message: POGOProtos.Rpc.IRoutePlayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePlayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePlayProto;
            public static toObject(message: POGOProtos.Rpc.RoutePlayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePlaySettingsProto {
            min_player_level?: (number|null);
            route_cooldown_minutes?: (number|null);
            route_expiration_minutes?: (number|null);
            route_puase_distance_m?: (number|null);
            pause_distance_meters?: (number|null);
            pause_duration_s?: (number|null);
            incense_time_between_encounter_multiplier?: (number|null);
            buddy_total_candy_distance_multiplier?: (number|null);
            buddy_gift_cooldown_duration_multiplier?: (number|null);
            all_route_bonuses?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            new_route_bonuses?: (POGOProtos.Rpc.IBonusBoxProto[]|null);
            badge_xp_bonus?: (number[]|null);
            badge_item_bonus?: (number[]|null);
            bonus_active_distance_threshold_meters?: (number|null);
            player_breadcrumb_trail_max_count?: (number|null);
            margin_percentage?: (number|null);
            margin_minimum_meters?: (number|null);
            resume_range_meters?: (number|null);
            route_engagement_stats_shard_count?: (number|null);
            npc_visual_spawn_range_meters?: (number|null);
            pin_creation_enabled_for_route_play?: (boolean|null);
            pins_visible_for_play?: (boolean|null);
            enable_route_rating_details?: (boolean|null);
            ob_int32?: (number|null);
            item_reward_partial_completion_threshold?: (number|null);
            ob_float_2?: (number|null);
            ob_float_3?: (number|null);
            ob_bool_4?: (boolean|null);
        }

        class RoutePlaySettingsProto implements IRoutePlaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutePlaySettingsProto);
            public min_player_level: number;
            public route_cooldown_minutes: number;
            public route_expiration_minutes: number;
            public route_puase_distance_m: number;
            public pause_distance_meters: number;
            public pause_duration_s: number;
            public incense_time_between_encounter_multiplier: number;
            public buddy_total_candy_distance_multiplier: number;
            public buddy_gift_cooldown_duration_multiplier: number;
            public all_route_bonuses: POGOProtos.Rpc.IBonusBoxProto[];
            public new_route_bonuses: POGOProtos.Rpc.IBonusBoxProto[];
            public badge_xp_bonus: number[];
            public badge_item_bonus: number[];
            public bonus_active_distance_threshold_meters: number;
            public player_breadcrumb_trail_max_count: number;
            public margin_percentage: number;
            public margin_minimum_meters: number;
            public resume_range_meters: number;
            public route_engagement_stats_shard_count: number;
            public npc_visual_spawn_range_meters: number;
            public pin_creation_enabled_for_route_play: boolean;
            public pins_visible_for_play: boolean;
            public enable_route_rating_details: boolean;
            public ob_int32: number;
            public item_reward_partial_completion_threshold: number;
            public ob_float_2: number;
            public ob_float_3: number;
            public ob_bool_4: boolean;
            public static encode(message: POGOProtos.Rpc.IRoutePlaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePlaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePlaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.RoutePlaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePlaySpawnSettingsProto {
            min_distance_between_route_encounters_m?: (number|null);
            route_spawn_table?: (POGOProtos.Rpc.ISpawnTablePokemonProto[]|null);
            route_spawn_table_probability?: (number|null);
        }

        class RoutePlaySpawnSettingsProto implements IRoutePlaySpawnSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutePlaySpawnSettingsProto);
            public min_distance_between_route_encounters_m: number;
            public route_spawn_table: POGOProtos.Rpc.ISpawnTablePokemonProto[];
            public route_spawn_table_probability: number;
            public static encode(message: POGOProtos.Rpc.IRoutePlaySpawnSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePlaySpawnSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePlaySpawnSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RoutePlaySpawnSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePlayStatus {
        }

        class RoutePlayStatus implements IRoutePlayStatus {
            constructor(properties?: POGOProtos.Rpc.IRoutePlayStatus);
            public static encode(message: POGOProtos.Rpc.IRoutePlayStatus, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePlayStatus;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePlayStatus;
            public static toObject(message: POGOProtos.Rpc.RoutePlayStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RoutePlayStatus {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ROUTE_NOT_FOUND = 3,
                ERROR_FORT_NOT_FOUND = 4,
                ERROR_INVALID_START_FORT = 5,
                ERROR_WRONG_WAYPOINT = 6,
                ERROR_ROUTE_PLAY_EXPIRED = 7,
                ERROR_ROUTE_IN_COOLDOWN = 8,
                ERROR_ROUTE_PLAY_NOT_FOUND = 9,
                ERROR_PLAYER_LEVEL_TOO_LOW = 10,
                ERROR_U13_NO_PERMISSION = 11,
                ERROR_ROUTE_CLOSED = 12
            }
        }

        interface IRoutePlayTappableSpawnedTelemetry {
            type?: (POGOProtos.Rpc.Tappable.TappableType|null);
            tappable_id?: (number|Long|null);
            route_id?: (string|null);
        }

        class RoutePlayTappableSpawnedTelemetry implements IRoutePlayTappableSpawnedTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRoutePlayTappableSpawnedTelemetry);
            public type: POGOProtos.Rpc.Tappable.TappableType;
            public tappable_id: (number|Long);
            public route_id: string;
            public static encode(message: POGOProtos.Rpc.IRoutePlayTappableSpawnedTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePlayTappableSpawnedTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePlayTappableSpawnedTelemetry;
            public static toObject(message: POGOProtos.Rpc.RoutePlayTappableSpawnedTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutePoiAnchor {
            anchor?: (POGOProtos.Rpc.IRouteWaypointProto|null);
            image_url?: (string|null);
        }

        class RoutePoiAnchor implements IRoutePoiAnchor {
            constructor(properties?: POGOProtos.Rpc.IRoutePoiAnchor);
            public anchor?: (POGOProtos.Rpc.IRouteWaypointProto|null);
            public image_url: string;
            public static encode(message: POGOProtos.Rpc.IRoutePoiAnchor, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutePoiAnchor;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutePoiAnchor;
            public static toObject(message: POGOProtos.Rpc.RoutePoiAnchor, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteSimplificationAlgorithm {
        }

        class RouteSimplificationAlgorithm implements IRouteSimplificationAlgorithm {
            constructor(properties?: POGOProtos.Rpc.IRouteSimplificationAlgorithm);
            public static encode(message: POGOProtos.Rpc.IRouteSimplificationAlgorithm, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteSimplificationAlgorithm;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteSimplificationAlgorithm;
            public static toObject(message: POGOProtos.Rpc.RouteSimplificationAlgorithm, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteSimplificationAlgorithm {

            enum SimplificationAlgorithm {
                UNSET = 0,
                DOUGLAS_PEUCKER = 1,
                VISVALINGAM_WHYATT = 2
            }
        }

        interface IRouteSmoothingParamsProto {
            enabled?: (boolean|null);
            num_breadcrumbs_to_compute_mean?: (number|null);
            max_distance_threshold_from_extrapolated_point?: (number|null);
            mean_vector_blend_ratio?: (number|null);
        }

        class RouteSmoothingParamsProto implements IRouteSmoothingParamsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteSmoothingParamsProto);
            public enabled: boolean;
            public num_breadcrumbs_to_compute_mean: number;
            public max_distance_threshold_from_extrapolated_point: number;
            public mean_vector_blend_ratio: number;
            public static encode(message: POGOProtos.Rpc.IRouteSmoothingParamsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteSmoothingParamsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteSmoothingParamsProto;
            public static toObject(message: POGOProtos.Rpc.RouteSmoothingParamsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteStamp {
            type?: (POGOProtos.Rpc.RouteStamp.Type|null);
            color?: (POGOProtos.Rpc.RouteStamp.Color|null);
            stamp_id?: (string|null);
            asset_id?: (string|null);
            category?: (string|null);
            stamp_index?: (number|null);
        }

        class RouteStamp implements IRouteStamp {
            constructor(properties?: POGOProtos.Rpc.IRouteStamp);
            public type: POGOProtos.Rpc.RouteStamp.Type;
            public color: POGOProtos.Rpc.RouteStamp.Color;
            public stamp_id: string;
            public asset_id: string;
            public category: string;
            public stamp_index: number;
            public static encode(message: POGOProtos.Rpc.IRouteStamp, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteStamp;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteStamp;
            public static toObject(message: POGOProtos.Rpc.RouteStamp, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteStamp {

            enum Color {
                COLOR_UNSET = 0,
                COLOR_179D62 = 1,
                COLOR_E10012 = 2,
                COLOR_1365AE = 3,
                COLOR_E89A05 = 4
            }

            enum Type {
                TYPE_UNSET = 0
            }
        }

        interface IRouteStampCategorySettingsProto {
            asset_id?: (string|null);
            category?: (string|null);
            collection_size?: (number|null);
            sort_order?: (number|null);
            active?: (boolean|null);
        }

        class RouteStampCategorySettingsProto implements IRouteStampCategorySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRouteStampCategorySettingsProto);
            public asset_id: string;
            public category: string;
            public collection_size: number;
            public sort_order: number;
            public active: boolean;
            public static encode(message: POGOProtos.Rpc.IRouteStampCategorySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteStampCategorySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteStampCategorySettingsProto;
            public static toObject(message: POGOProtos.Rpc.RouteStampCategorySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteStats {
            num_completions?: (number|Long|null);
            route_level?: (number|Long|null);
            num_five_stars?: (number|Long|null);
            num_four_stars?: (number|Long|null);
            num_three_stars?: (number|Long|null);
            num_two_stars?: (number|Long|null);
            num_one_stars?: (number|Long|null);
            num_ratings?: (number|Long|null);
            first_played_time_ms?: (number|Long|null);
            last_played_time_ms?: (number|Long|null);
            weekly_num_completions?: (number|Long|null);
            total_distance_travelled_meters?: (number|null);
            weekly_distance_travelled_meters?: (number|null);
            last_synced_time_ms?: (number|Long|null);
            num_name_or_description_issues?: (number|Long|null);
            num_shape_issues?: (number|Long|null);
            num_connectivity_issues?: (number|Long|null);
            score?: (number|Long|null);
        }

        class RouteStats implements IRouteStats {
            constructor(properties?: POGOProtos.Rpc.IRouteStats);
            public num_completions: (number|Long);
            public route_level: (number|Long);
            public num_five_stars: (number|Long);
            public num_four_stars: (number|Long);
            public num_three_stars: (number|Long);
            public num_two_stars: (number|Long);
            public num_one_stars: (number|Long);
            public num_ratings: (number|Long);
            public first_played_time_ms: (number|Long);
            public last_played_time_ms: (number|Long);
            public weekly_num_completions: (number|Long);
            public total_distance_travelled_meters: number;
            public weekly_distance_travelled_meters: number;
            public last_synced_time_ms: (number|Long);
            public num_name_or_description_issues: (number|Long);
            public num_shape_issues: (number|Long);
            public num_connectivity_issues: (number|Long);
            public score: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRouteStats, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteStats;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteStats;
            public static toObject(message: POGOProtos.Rpc.RouteStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteSubmissionStatus {
            status?: (POGOProtos.Rpc.RouteSubmissionStatus.Status|null);
            submission_status_update_time_ms?: (number|Long|null);
            rejection_reason?: (POGOProtos.Rpc.RouteSubmissionStatus.IRejectionReason[]|null);
        }

        class RouteSubmissionStatus implements IRouteSubmissionStatus {
            constructor(properties?: POGOProtos.Rpc.IRouteSubmissionStatus);
            public status: POGOProtos.Rpc.RouteSubmissionStatus.Status;
            public submission_status_update_time_ms: (number|Long);
            public rejection_reason: POGOProtos.Rpc.RouteSubmissionStatus.IRejectionReason[];
            public static encode(message: POGOProtos.Rpc.IRouteSubmissionStatus, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteSubmissionStatus;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteSubmissionStatus;
            public static toObject(message: POGOProtos.Rpc.RouteSubmissionStatus, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteSubmissionStatus {

            enum Status {
                UNSET = 0,
                UNDER_REVIEW = 1,
                PUBLISHED = 2,
                DECAYED = 3,
                REJECTED = 4,
                REMOVED = 5,
                UNDER_APPEAL = 6,
                DELETED = 7,
                ARCHIVED = 8
            }

            interface IRejectionReason {
                reason_code?: (string|null);
            }

            class RejectionReason implements IRejectionReason {
                constructor(properties?: POGOProtos.Rpc.RouteSubmissionStatus.IRejectionReason);
                public reason_code: string;
                public static encode(message: POGOProtos.Rpc.RouteSubmissionStatus.IRejectionReason, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteSubmissionStatus.RejectionReason;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteSubmissionStatus.RejectionReason;
                public static toObject(message: POGOProtos.Rpc.RouteSubmissionStatus.RejectionReason, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IRouteUpdateSeenOutProto {
        }

        class RouteUpdateSeenOutProto implements IRouteUpdateSeenOutProto {
            constructor(properties?: POGOProtos.Rpc.IRouteUpdateSeenOutProto);
            public static encode(message: POGOProtos.Rpc.IRouteUpdateSeenOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteUpdateSeenOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteUpdateSeenOutProto;
            public static toObject(message: POGOProtos.Rpc.RouteUpdateSeenOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteUpdateSeenProto {
            route_id?: (string|null);
        }

        class RouteUpdateSeenProto implements IRouteUpdateSeenProto {
            constructor(properties?: POGOProtos.Rpc.IRouteUpdateSeenProto);
            public route_id: string;
            public static encode(message: POGOProtos.Rpc.IRouteUpdateSeenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteUpdateSeenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteUpdateSeenProto;
            public static toObject(message: POGOProtos.Rpc.RouteUpdateSeenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRouteValidation {
            error?: (POGOProtos.Rpc.RouteValidation.Error[]|null);
        }

        class RouteValidation implements IRouteValidation {
            constructor(properties?: POGOProtos.Rpc.IRouteValidation);
            public error: POGOProtos.Rpc.RouteValidation.Error[];
            public static encode(message: POGOProtos.Rpc.IRouteValidation, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteValidation;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteValidation;
            public static toObject(message: POGOProtos.Rpc.RouteValidation, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RouteValidation {

            enum Error {
                UNSET = 0,
                INVALID_NUM_FORTS = 1,
                INVALID_NUM_CHECKPOINTS = 2,
                INVALID_TOTAL_DISTANCE = 3,
                INVALID_DISTANCE_BETWEEN_FORTS = 4,
                INVALID_DISTANCE_BETWEEN_CHECKPOINTS = 5,
                INVALID_FORT = 6,
                DUPLICATE_FORTS = 7,
                INVALID_START_OR_END = 8,
                INVALID_NAME_LENGTH = 9,
                INVALID_DESCRIPTION_LENGTH = 10,
                TOO_MANY_CHECKPOINTS_BETWEEN_FORTS = 11,
                INVALID_MAIN_IMAGE = 12,
                BAD_NAME = 13,
                BAD_DESCRIPTION = 14,
                END_ANCHOR_TOO_FAR = 15
            }
        }

        interface IRouteWaypointProto {
            fort_id?: (string|null);
            lat_degrees?: (number|null);
            lng_degrees?: (number|null);
            elevation_in_meters?: (number|null);
            timestamp_ms?: (number|Long|null);
        }

        class RouteWaypointProto implements IRouteWaypointProto {
            constructor(properties?: POGOProtos.Rpc.IRouteWaypointProto);
            public fort_id: string;
            public lat_degrees: number;
            public lng_degrees: number;
            public elevation_in_meters: number;
            public timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRouteWaypointProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RouteWaypointProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RouteWaypointProto;
            public static toObject(message: POGOProtos.Rpc.RouteWaypointProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutesCreationSettingsProto {
            max_open_routes?: (number|null);
            min_stops_amount?: (number|null);
            max_stops_amount?: (number|null);
            min_total_distance_m?: (number|null);
            max_total_distance_m?: (number|null);
            min_distance_between_stops_m?: (number|null);
            max_distance_between_stops_m?: (number|null);
            max_total_checkpoint_amount?: (number|null);
            max_checkpoint_amount_between_two_poi?: (number|null);
            min_distance_between_checkpoints_m?: (number|null);
            max_distance_between_checkpoints_m?: (number|null);
            allow_checkpoint_per_route_distance?: (number|null);
            checkpoint_recommendation_distance_between_pois?: (number|null);
            max_name_length?: (number|null);
            max_description_length?: (number|null);
            min_player_level?: (number|null);
            enabled?: (boolean|null);
            enable_immediate_route_ingestion?: (boolean|null);
            min_breadcrumb_distance_delta_meters?: (number|null);
            creation_limit_window_days?: (number|null);
            creation_limit_per_window?: (number|null);
            creation_limit_window_offset_ms?: (number|Long|null);
            max_distance_from_anchor_pois_m?: (number|null);
            algorithm?: (POGOProtos.Rpc.RouteSimplificationAlgorithm.SimplificationAlgorithm|null);
            simplification_tolerance?: (number|null);
            max_distance_warning_distance_meters?: (number|null);
            max_recording_speed_meters_per_second?: (number|null);
            moderation_enabled?: (boolean|null);
            client_breadcrumb_settings?: (POGOProtos.Rpc.IClientBreadcrumbSessionSettings|null);
            disabled_tags?: (string[]|null);
            duration_distance_to_speed_multiplier?: (number|null);
            duration_buffer_s?: (number|null);
            minimum_distance_between_pins_m?: (number|null);
            max_pin_distance_from_route_m?: (number|null);
            interaction_range_meters?: (number|null);
            max_client_map_panning_distance_meters?: (number|null);
            resume_range_meters?: (number|null);
            route_smoothing_params?: (POGOProtos.Rpc.IRouteSmoothingParamsProto|null);
            no_moderation_route_retry_threshold_ms?: (number|Long|null);
            no_moderation_route_reporting_threshold_ms?: (number|Long|null);
            route_path_edit_params?: (POGOProtos.Rpc.IRoutePathEditParamsProto|null);
            max_breadcrumb_distance_delta_meters?: (number|null);
            max_recall_count_threshold?: (number|null);
            allowable_gps_drift_meters?: (number|null);
            max_post_punishment_ban_time_ms?: (number|Long|null);
            max_submission_count_threshold?: (number|null);
            pin_creation_enabled_for_route_creation?: (boolean|null);
            show_submission_status_history?: (boolean|null);
            elevation_tags?: (string[]|null);
            route_elevation_settings?: (POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteElevationSettingsProto|null);
            allow_appeals?: (boolean|null);
            allow_deleting_appealed_routes?: (boolean|null);
            permitted_tags?: (POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteTagSettingsProto[]|null);
        }

        class RoutesCreationSettingsProto implements IRoutesCreationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutesCreationSettingsProto);
            public max_open_routes: number;
            public min_stops_amount: number;
            public max_stops_amount: number;
            public min_total_distance_m: number;
            public max_total_distance_m: number;
            public min_distance_between_stops_m: number;
            public max_distance_between_stops_m: number;
            public max_total_checkpoint_amount: number;
            public max_checkpoint_amount_between_two_poi: number;
            public min_distance_between_checkpoints_m: number;
            public max_distance_between_checkpoints_m: number;
            public allow_checkpoint_per_route_distance: number;
            public checkpoint_recommendation_distance_between_pois: number;
            public max_name_length: number;
            public max_description_length: number;
            public min_player_level: number;
            public enabled: boolean;
            public enable_immediate_route_ingestion: boolean;
            public min_breadcrumb_distance_delta_meters: number;
            public creation_limit_window_days: number;
            public creation_limit_per_window: number;
            public creation_limit_window_offset_ms: (number|Long);
            public max_distance_from_anchor_pois_m: number;
            public algorithm: POGOProtos.Rpc.RouteSimplificationAlgorithm.SimplificationAlgorithm;
            public simplification_tolerance: number;
            public max_distance_warning_distance_meters: number;
            public max_recording_speed_meters_per_second: number;
            public moderation_enabled: boolean;
            public client_breadcrumb_settings?: (POGOProtos.Rpc.IClientBreadcrumbSessionSettings|null);
            public disabled_tags: string[];
            public duration_distance_to_speed_multiplier: number;
            public duration_buffer_s: number;
            public minimum_distance_between_pins_m: number;
            public max_pin_distance_from_route_m: number;
            public interaction_range_meters: number;
            public max_client_map_panning_distance_meters: number;
            public resume_range_meters: number;
            public route_smoothing_params?: (POGOProtos.Rpc.IRouteSmoothingParamsProto|null);
            public no_moderation_route_retry_threshold_ms: (number|Long);
            public no_moderation_route_reporting_threshold_ms: (number|Long);
            public route_path_edit_params?: (POGOProtos.Rpc.IRoutePathEditParamsProto|null);
            public max_breadcrumb_distance_delta_meters: number;
            public max_recall_count_threshold: number;
            public allowable_gps_drift_meters: number;
            public max_post_punishment_ban_time_ms: (number|Long);
            public max_submission_count_threshold: number;
            public pin_creation_enabled_for_route_creation: boolean;
            public show_submission_status_history: boolean;
            public elevation_tags: string[];
            public route_elevation_settings?: (POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteElevationSettingsProto|null);
            public allow_appeals: boolean;
            public allow_deleting_appealed_routes: boolean;
            public permitted_tags: POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteTagSettingsProto[];
            public static encode(message: POGOProtos.Rpc.IRoutesCreationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutesCreationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutesCreationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RoutesCreationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RoutesCreationSettingsProto {

            interface IRouteElevationSettingsProto {
                flat_elevation_diff_max_m?: (number|null);
                mostly_flat_elevation_diff_max_m?: (number|null);
                slightly_hilly_elevation_diff_max_m?: (number|null);
                steep_opposing_elevation_diff_max_m?: (number|null);
                steep_directed_elevation_diff_min_m?: (number|null);
                length_multiplier?: (number|null);
            }

            class RouteElevationSettingsProto implements IRouteElevationSettingsProto {
                constructor(properties?: POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteElevationSettingsProto);
                public flat_elevation_diff_max_m: number;
                public mostly_flat_elevation_diff_max_m: number;
                public slightly_hilly_elevation_diff_max_m: number;
                public steep_opposing_elevation_diff_max_m: number;
                public steep_directed_elevation_diff_min_m: number;
                public length_multiplier: number;
                public static encode(message: POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteElevationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutesCreationSettingsProto.RouteElevationSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutesCreationSettingsProto.RouteElevationSettingsProto;
                public static toObject(message: POGOProtos.Rpc.RoutesCreationSettingsProto.RouteElevationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRouteTagSettingsProto {
                category_tag?: (string|null);
                tags?: (POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.IRouteTagProto[]|null);
            }

            class RouteTagSettingsProto implements IRouteTagSettingsProto {
                constructor(properties?: POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteTagSettingsProto);
                public category_tag: string;
                public tags: POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.IRouteTagProto[];
                public static encode(message: POGOProtos.Rpc.RoutesCreationSettingsProto.IRouteTagSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto;
                public static toObject(message: POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace RouteTagSettingsProto {

                interface IRouteTagProto {
                    tag?: (string|null);
                    mutex_number?: (number|null);
                }

                class RouteTagProto implements IRouteTagProto {
                    constructor(properties?: POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.IRouteTagProto);
                    public tag: string;
                    public mutex_number: number;
                    public static encode(message: POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.IRouteTagProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.RouteTagProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.RouteTagProto;
                    public static toObject(message: POGOProtos.Rpc.RoutesCreationSettingsProto.RouteTagSettingsProto.RouteTagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IRoutesNearbyNotifSettingsProto {
            max_notifs?: (number|null);
            time_between_notifs_ms?: (number|Long|null);
        }

        class RoutesNearbyNotifSettingsProto implements IRoutesNearbyNotifSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutesNearbyNotifSettingsProto);
            public max_notifs: number;
            public time_between_notifs_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRoutesNearbyNotifSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutesNearbyNotifSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutesNearbyNotifSettingsProto;
            public static toObject(message: POGOProtos.Rpc.RoutesNearbyNotifSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRoutesPartyPlayInteroperabilitySettingsProto {
            consumption_interoperable?: (boolean|null);
            creation_interoperable?: (boolean|null);
        }

        class RoutesPartyPlayInteroperabilitySettingsProto implements IRoutesPartyPlayInteroperabilitySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IRoutesPartyPlayInteroperabilitySettingsProto);
            public consumption_interoperable: boolean;
            public creation_interoperable: boolean;
            public static encode(message: POGOProtos.Rpc.IRoutesPartyPlayInteroperabilitySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RoutesPartyPlayInteroperabilitySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RoutesPartyPlayInteroperabilitySettingsProto;
            public static toObject(message: POGOProtos.Rpc.RoutesPartyPlayInteroperabilitySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRpcErrorData {
            action?: (POGOProtos.Rpc.Method|null);
            status?: (POGOProtos.Rpc.RpcErrorData.RpcStatus|null);
        }

        class RpcErrorData implements IRpcErrorData {
            constructor(properties?: POGOProtos.Rpc.IRpcErrorData);
            public action: POGOProtos.Rpc.Method;
            public status: POGOProtos.Rpc.RpcErrorData.RpcStatus;
            public static encode(message: POGOProtos.Rpc.IRpcErrorData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RpcErrorData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RpcErrorData;
            public static toObject(message: POGOProtos.Rpc.RpcErrorData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RpcErrorData {

            enum RpcStatus {
                UNDEFINED = 0,
                SUCCESS = 1,
                BAD_RESPONSE = 3,
                ACTION_ERROR = 4,
                DISPATCH_ERROR = 5,
                SERVER_ERROR = 6,
                ASSIGNMENT_ERROR = 7,
                PROTOCOL_ERROR = 8,
                AUTHENTICATION_ERROR = 9,
                CANCELLED_REQUEST = 10,
                UNKNOWN_ERROR = 11,
                NORETRIES_ERROR = 12,
                UNAUTHORIZED_ERROR = 13,
                PARSING_ERROR = 14,
                ACCESS_DENIED = 15,
                ACCESS_SUSPENDED = 16
            }
        }

        interface IRpcLatencyEvent {
            round_trip_latency_ms?: (number|Long|null);
            routed_via_socket?: (boolean|null);
            payload_size_bytes?: (number|Long|null);
            request_id?: (number|Long|null);
        }

        class RpcLatencyEvent implements IRpcLatencyEvent {
            constructor(properties?: POGOProtos.Rpc.IRpcLatencyEvent);
            public round_trip_latency_ms: (number|Long);
            public routed_via_socket: boolean;
            public payload_size_bytes: (number|Long);
            public request_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IRpcLatencyEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RpcLatencyEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RpcLatencyEvent;
            public static toObject(message: POGOProtos.Rpc.RpcLatencyEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRpcResponseTelemetry {
            window_duration?: (number|null);
            response_timings?: (POGOProtos.Rpc.IRpcResponseTime[]|null);
            connection_type?: (POGOProtos.Rpc.RpcResponseTelemetry.ConnectionType|null);
        }

        class RpcResponseTelemetry implements IRpcResponseTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRpcResponseTelemetry);
            public window_duration: number;
            public response_timings: POGOProtos.Rpc.IRpcResponseTime[];
            public connection_type: POGOProtos.Rpc.RpcResponseTelemetry.ConnectionType;
            public static encode(message: POGOProtos.Rpc.IRpcResponseTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RpcResponseTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RpcResponseTelemetry;
            public static toObject(message: POGOProtos.Rpc.RpcResponseTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace RpcResponseTelemetry {

            enum ConnectionType {
                UNKNOWN = 0,
                WIFI = 1,
                CELL_DEFAULT = 2,
                CELL_1G = 3,
                CELL_2G = 4,
                CELL_3G = 5,
                CELL_4G = 6,
                CELL_5G = 7,
                CELL_6G = 8,
                CELL_7G = 9
            }
        }

        interface IRpcResponseTime {
            rpc_id?: (POGOProtos.Rpc.Method|null);
            count_call?: (number|null);
            average_response_time?: (number|null);
            timeout_count?: (number|null);
        }

        class RpcResponseTime implements IRpcResponseTime {
            constructor(properties?: POGOProtos.Rpc.IRpcResponseTime);
            public rpc_id: POGOProtos.Rpc.Method;
            public count_call: number;
            public average_response_time: number;
            public timeout_count: number;
            public static encode(message: POGOProtos.Rpc.IRpcResponseTime, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RpcResponseTime;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RpcResponseTime;
            public static toObject(message: POGOProtos.Rpc.RpcResponseTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRpcSocketResponseTelemetry {
            window_duration?: (number|null);
            response_timings?: (POGOProtos.Rpc.IRpcSocketResponseTime[]|null);
        }

        class RpcSocketResponseTelemetry implements IRpcSocketResponseTelemetry {
            constructor(properties?: POGOProtos.Rpc.IRpcSocketResponseTelemetry);
            public window_duration: number;
            public response_timings: POGOProtos.Rpc.IRpcSocketResponseTime[];
            public static encode(message: POGOProtos.Rpc.IRpcSocketResponseTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RpcSocketResponseTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RpcSocketResponseTelemetry;
            public static toObject(message: POGOProtos.Rpc.RpcSocketResponseTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRpcSocketResponseTime {
            request_id?: (number|Long|null);
            probe_id?: (string|null);
            response_time?: (number|null);
            side_channel?: (boolean|null);
            ad_hoc?: (boolean|null);
            ad_hoc_delay?: (number|null);
        }

        class RpcSocketResponseTime implements IRpcSocketResponseTime {
            constructor(properties?: POGOProtos.Rpc.IRpcSocketResponseTime);
            public request_id: (number|Long);
            public probe_id: string;
            public response_time: number;
            public side_channel: boolean;
            public ad_hoc: boolean;
            public ad_hoc_delay: number;
            public static encode(message: POGOProtos.Rpc.IRpcSocketResponseTime, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RpcSocketResponseTime;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RpcSocketResponseTime;
            public static toObject(message: POGOProtos.Rpc.RpcSocketResponseTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRsvpCountDetails {
            location_id?: (string|null);
            going_count?: (number|null);
            maybe_count?: (number|null);
        }

        class RsvpCountDetails implements IRsvpCountDetails {
            constructor(properties?: POGOProtos.Rpc.IRsvpCountDetails);
            public location_id: string;
            public going_count: number;
            public maybe_count: number;
            public static encode(message: POGOProtos.Rpc.IRsvpCountDetails, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RsvpCountDetails;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RsvpCountDetails;
            public static toObject(message: POGOProtos.Rpc.RsvpCountDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRvnConnectionProto {
            base_uri?: (string|null);
            token?: (string|null);
        }

        class RvnConnectionProto implements IRvnConnectionProto {
            constructor(properties?: POGOProtos.Rpc.IRvnConnectionProto);
            public base_uri: string;
            public token: string;
            public static encode(message: POGOProtos.Rpc.IRvnConnectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.RvnConnectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.RvnConnectionProto;
            public static toObject(message: POGOProtos.Rpc.RvnConnectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayBleCompleteRequestProto {
            transaction_id?: (number|Long|null);
            nonce?: (string|null);
        }

        class SaturdayBleCompleteRequestProto implements ISaturdayBleCompleteRequestProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayBleCompleteRequestProto);
            public transaction_id: (number|Long);
            public nonce: string;
            public static encode(message: POGOProtos.Rpc.ISaturdayBleCompleteRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayBleCompleteRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayBleCompleteRequestProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayBleCompleteRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayBleFinalizeProto {
            saturday_send_complete?: (POGOProtos.Rpc.ISaturdayBleSendCompleteProto|null);
            server_signature?: (Uint8Array|null);
        }

        class SaturdayBleFinalizeProto implements ISaturdayBleFinalizeProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayBleFinalizeProto);
            public saturday_send_complete?: (POGOProtos.Rpc.ISaturdayBleSendCompleteProto|null);
            public server_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISaturdayBleFinalizeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayBleFinalizeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayBleFinalizeProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayBleFinalizeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayBleSendCompleteProto {
            nonce?: (string|null);
            application_id?: (string|null);
        }

        class SaturdayBleSendCompleteProto implements ISaturdayBleSendCompleteProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayBleSendCompleteProto);
            public nonce: string;
            public application_id: string;
            public static encode(message: POGOProtos.Rpc.ISaturdayBleSendCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayBleSendCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayBleSendCompleteProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayBleSendCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayBleSendPrepProto {
            data?: (POGOProtos.Rpc.SaturdayCompositionData|null);
            transaction_id?: (number|Long|null);
            application_id?: (string|null);
            nonce?: (string|null);
        }

        class SaturdayBleSendPrepProto implements ISaturdayBleSendPrepProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayBleSendPrepProto);
            public data: POGOProtos.Rpc.SaturdayCompositionData;
            public transaction_id: (number|Long);
            public application_id: string;
            public nonce: string;
            public static encode(message: POGOProtos.Rpc.ISaturdayBleSendPrepProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayBleSendPrepProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayBleSendPrepProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayBleSendPrepProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayBleSendProto {
            server_response?: (POGOProtos.Rpc.ISaturdayBleSendPrepProto|null);
            server_signature?: (Uint8Array|null);
        }

        class SaturdayBleSendProto implements ISaturdayBleSendProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayBleSendProto);
            public server_response?: (POGOProtos.Rpc.ISaturdayBleSendPrepProto|null);
            public server_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISaturdayBleSendProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayBleSendProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayBleSendProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayBleSendProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayCompleteOutProto {
            status?: (POGOProtos.Rpc.SaturdayCompleteOutProto.Status|null);
            loot_awarded?: (POGOProtos.Rpc.ILootProto|null);
            saturday_finalize_response?: (POGOProtos.Rpc.ISaturdayBleFinalizeProto|null);
        }

        class SaturdayCompleteOutProto implements ISaturdayCompleteOutProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayCompleteOutProto);
            public status: POGOProtos.Rpc.SaturdayCompleteOutProto.Status;
            public loot_awarded?: (POGOProtos.Rpc.ILootProto|null);
            public saturday_finalize_response?: (POGOProtos.Rpc.ISaturdayBleFinalizeProto|null);
            public static encode(message: POGOProtos.Rpc.ISaturdayCompleteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayCompleteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayCompleteOutProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayCompleteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SaturdayCompleteOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILED = 2,
                ERROR_INVALID_ID = 3,
                ERROR_ALREADY_SENT = 4,
                ERROR_INVALID_TRANSACTION_ID = 5,
                ERROR_MISSING_TRANSACTION_ID = 6,
                ERROR_DAILY_LIMIT = 7
            }
        }

        interface ISaturdayCompleteProto {
            saturday_share?: (POGOProtos.Rpc.ISaturdayBleCompleteRequestProto|null);
            app_signature?: (Uint8Array|null);
            firmware_signature?: (Uint8Array|null);
        }

        class SaturdayCompleteProto implements ISaturdayCompleteProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayCompleteProto);
            public saturday_share?: (POGOProtos.Rpc.ISaturdayBleCompleteRequestProto|null);
            public app_signature: Uint8Array;
            public firmware_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISaturdayCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayCompleteProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdaySettingsProto {
            enabled?: (boolean|null);
            max_shares_per_day?: (number|null);
            daily_streak_goal?: (number|null);
        }

        class SaturdaySettingsProto implements ISaturdaySettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdaySettingsProto);
            public enabled: boolean;
            public max_shares_per_day: number;
            public daily_streak_goal: number;
            public static encode(message: POGOProtos.Rpc.ISaturdaySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdaySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdaySettingsProto;
            public static toObject(message: POGOProtos.Rpc.SaturdaySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaturdayStartOutProto {
            status?: (POGOProtos.Rpc.SaturdayStartOutProto.Status|null);
            send_prep?: (POGOProtos.Rpc.ISaturdayBleSendPrepProto|null);
            server_signature?: (Uint8Array|null);
        }

        class SaturdayStartOutProto implements ISaturdayStartOutProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayStartOutProto);
            public status: POGOProtos.Rpc.SaturdayStartOutProto.Status;
            public send_prep?: (POGOProtos.Rpc.ISaturdayBleSendPrepProto|null);
            public server_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISaturdayStartOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayStartOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayStartOutProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayStartOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SaturdayStartOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILED = 2,
                ERROR_INVALID_ID = 3,
                ERROR_ALREADY_SENT = 4,
                ERROR_NONE_SPECIFIED = 5,
                ERROR_DAILY_LIMIT = 6
            }
        }

        interface ISaturdayStartProto {
            send_id?: (string|null);
            nonce?: (string|null);
            application_id?: (string|null);
        }

        class SaturdayStartProto implements ISaturdayStartProto {
            constructor(properties?: POGOProtos.Rpc.ISaturdayStartProto);
            public send_id: string;
            public nonce: string;
            public application_id: string;
            public static encode(message: POGOProtos.Rpc.ISaturdayStartProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaturdayStartProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaturdayStartProto;
            public static toObject(message: POGOProtos.Rpc.SaturdayStartProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaveCombatPlayerPreferencesOutProto {
            result?: (POGOProtos.Rpc.SaveCombatPlayerPreferencesOutProto.Result|null);
        }

        class SaveCombatPlayerPreferencesOutProto implements ISaveCombatPlayerPreferencesOutProto {
            constructor(properties?: POGOProtos.Rpc.ISaveCombatPlayerPreferencesOutProto);
            public result: POGOProtos.Rpc.SaveCombatPlayerPreferencesOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISaveCombatPlayerPreferencesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveCombatPlayerPreferencesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveCombatPlayerPreferencesOutProto;
            public static toObject(message: POGOProtos.Rpc.SaveCombatPlayerPreferencesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SaveCombatPlayerPreferencesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface ISaveCombatPlayerPreferencesProto {
            preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
        }

        class SaveCombatPlayerPreferencesProto implements ISaveCombatPlayerPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.ISaveCombatPlayerPreferencesProto);
            public preferences?: (POGOProtos.Rpc.ICombatPlayerPreferencesProto|null);
            public static encode(message: POGOProtos.Rpc.ISaveCombatPlayerPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveCombatPlayerPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveCombatPlayerPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.SaveCombatPlayerPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaveForLaterBreadPokemonProto {
            save_for_later_seed?: (number|Long|null);
            station_id?: (string|null);
            save_for_later_expire_ms?: (number|Long|null);
            bread_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            num_attempts_left?: (number|null);
        }

        class SaveForLaterBreadPokemonProto implements ISaveForLaterBreadPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ISaveForLaterBreadPokemonProto);
            public save_for_later_seed: (number|Long);
            public station_id: string;
            public save_for_later_expire_ms: (number|Long);
            public bread_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public reward_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public num_attempts_left: number;
            public static encode(message: POGOProtos.Rpc.ISaveForLaterBreadPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveForLaterBreadPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveForLaterBreadPokemonProto;
            public static toObject(message: POGOProtos.Rpc.SaveForLaterBreadPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaveForLaterSettingsProto {
            max_save_for_later_entries_allowed?: (number|null);
            max_num_attempt_allowed?: (number|null);
            save_for_later_buffer_time_ms?: (number|Long|null);
        }

        class SaveForLaterSettingsProto implements ISaveForLaterSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISaveForLaterSettingsProto);
            public max_save_for_later_entries_allowed: number;
            public max_num_attempt_allowed: number;
            public save_for_later_buffer_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISaveForLaterSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveForLaterSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveForLaterSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SaveForLaterSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISavePlayerPreferencesOutProto {
            result?: (POGOProtos.Rpc.SavePlayerPreferencesOutProto.Result|null);
        }

        class SavePlayerPreferencesOutProto implements ISavePlayerPreferencesOutProto {
            constructor(properties?: POGOProtos.Rpc.ISavePlayerPreferencesOutProto);
            public result: POGOProtos.Rpc.SavePlayerPreferencesOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISavePlayerPreferencesOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SavePlayerPreferencesOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SavePlayerPreferencesOutProto;
            public static toObject(message: POGOProtos.Rpc.SavePlayerPreferencesOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SavePlayerPreferencesOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ISavePlayerPreferencesProto {
            player_preferences_proto?: (POGOProtos.Rpc.IPlayerPreferencesProto|null);
        }

        class SavePlayerPreferencesProto implements ISavePlayerPreferencesProto {
            constructor(properties?: POGOProtos.Rpc.ISavePlayerPreferencesProto);
            public player_preferences_proto?: (POGOProtos.Rpc.IPlayerPreferencesProto|null);
            public static encode(message: POGOProtos.Rpc.ISavePlayerPreferencesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SavePlayerPreferencesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SavePlayerPreferencesProto;
            public static toObject(message: POGOProtos.Rpc.SavePlayerPreferencesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISavePlayerSnapshotOutProto {
            result?: (POGOProtos.Rpc.SavePlayerSnapshotOutProto.Result|null);
        }

        class SavePlayerSnapshotOutProto implements ISavePlayerSnapshotOutProto {
            constructor(properties?: POGOProtos.Rpc.ISavePlayerSnapshotOutProto);
            public result: POGOProtos.Rpc.SavePlayerSnapshotOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISavePlayerSnapshotOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SavePlayerSnapshotOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SavePlayerSnapshotOutProto;
            public static toObject(message: POGOProtos.Rpc.SavePlayerSnapshotOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SavePlayerSnapshotOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                TOO_SOON_TO_UPDATE = 2,
                ERROR_FAILED_TO_UPDATE = 3,
                ERROR_REQUEST_TIMED_OUT = 4
            }
        }

        interface ISavePlayerSnapshotProto {
        }

        class SavePlayerSnapshotProto implements ISavePlayerSnapshotProto {
            constructor(properties?: POGOProtos.Rpc.ISavePlayerSnapshotProto);
            public static encode(message: POGOProtos.Rpc.ISavePlayerSnapshotProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SavePlayerSnapshotProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SavePlayerSnapshotProto;
            public static toObject(message: POGOProtos.Rpc.SavePlayerSnapshotProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaveSocialPlayerSettingsOutProto {
            result?: (POGOProtos.Rpc.SaveSocialPlayerSettingsOutProto.Result|null);
        }

        class SaveSocialPlayerSettingsOutProto implements ISaveSocialPlayerSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.ISaveSocialPlayerSettingsOutProto);
            public result: POGOProtos.Rpc.SaveSocialPlayerSettingsOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISaveSocialPlayerSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveSocialPlayerSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveSocialPlayerSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.SaveSocialPlayerSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SaveSocialPlayerSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface ISaveSocialPlayerSettingsProto {
            settings?: (POGOProtos.Rpc.ISocialPlayerSettingsProto|null);
        }

        class SaveSocialPlayerSettingsProto implements ISaveSocialPlayerSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISaveSocialPlayerSettingsProto);
            public settings?: (POGOProtos.Rpc.ISocialPlayerSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.ISaveSocialPlayerSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveSocialPlayerSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveSocialPlayerSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SaveSocialPlayerSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISaveStampOutProto {
            result?: (POGOProtos.Rpc.SaveStampOutProto.Result|null);
            new_collection_state?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto|null);
        }

        class SaveStampOutProto implements ISaveStampOutProto {
            constructor(properties?: POGOProtos.Rpc.ISaveStampOutProto);
            public result: POGOProtos.Rpc.SaveStampOutProto.Result;
            public new_collection_state?: (POGOProtos.Rpc.IPlayerRpcStampCollectionProto|null);
            public static encode(message: POGOProtos.Rpc.ISaveStampOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveStampOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveStampOutProto;
            public static toObject(message: POGOProtos.Rpc.SaveStampOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SaveStampOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE_ALREADY_STAMPED = 2,
                FAILURE_NO_SUCH_COLLECTION = 3,
                FAILURE_NO_SUCH_FORT = 4,
                FAILURE_FORT_NOT_IN_COLLECTION = 5,
                FAILURE_COLLECTION_EXPIRED = 6,
                FAILURE_NO_SUCH_GIFT = 7,
                FAILURE_PLAYER_PREFERENCES = 8,
                FAILURE_FRIENDSHIP_LEVEL = 9
            }
        }

        interface ISaveStampProto {
            angle?: (number|null);
            pressure?: (number|null);
            self_stamp_data?: (POGOProtos.Rpc.SaveStampProto.IStampedProto|null);
            gifted_stamp_data?: (POGOProtos.Rpc.SaveStampProto.IGiftedStampProto|null);
        }

        class SaveStampProto implements ISaveStampProto {
            constructor(properties?: POGOProtos.Rpc.ISaveStampProto);
            public angle: number;
            public pressure: number;
            public self_stamp_data?: (POGOProtos.Rpc.SaveStampProto.IStampedProto|null);
            public gifted_stamp_data?: (POGOProtos.Rpc.SaveStampProto.IGiftedStampProto|null);
            public StampedData?: ("self_stamp_data"|"gifted_stamp_data");
            public static encode(message: POGOProtos.Rpc.ISaveStampProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveStampProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveStampProto;
            public static toObject(message: POGOProtos.Rpc.SaveStampProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SaveStampProto {

            interface IGiftedStampProto {
                friend_id?: (string|null);
                giftbox_id?: (number|Long|null);
            }

            class GiftedStampProto implements IGiftedStampProto {
                constructor(properties?: POGOProtos.Rpc.SaveStampProto.IGiftedStampProto);
                public friend_id: string;
                public giftbox_id: (number|Long);
                public static encode(message: POGOProtos.Rpc.SaveStampProto.IGiftedStampProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveStampProto.GiftedStampProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveStampProto.GiftedStampProto;
                public static toObject(message: POGOProtos.Rpc.SaveStampProto.GiftedStampProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IStampedProto {
                fort_id?: (string|null);
                collection_id?: (string|null);
            }

            class StampedProto implements IStampedProto {
                constructor(properties?: POGOProtos.Rpc.SaveStampProto.IStampedProto);
                public fort_id: string;
                public collection_id: string;
                public static encode(message: POGOProtos.Rpc.SaveStampProto.IStampedProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SaveStampProto.StampedProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SaveStampProto.StampedProto;
                public static toObject(message: POGOProtos.Rpc.SaveStampProto.StampedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IScanArchiveBuilderCancelEvent {
            scan_id?: (string|null);
            chunk_id?: (number|null);
            time_elapse_ms?: (number|null);
        }

        class ScanArchiveBuilderCancelEvent implements IScanArchiveBuilderCancelEvent {
            constructor(properties?: POGOProtos.Rpc.IScanArchiveBuilderCancelEvent);
            public scan_id: string;
            public chunk_id: number;
            public time_elapse_ms: number;
            public static encode(message: POGOProtos.Rpc.IScanArchiveBuilderCancelEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanArchiveBuilderCancelEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanArchiveBuilderCancelEvent;
            public static toObject(message: POGOProtos.Rpc.ScanArchiveBuilderCancelEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IScanArchiveBuilderGetNextChunkEvent {
            scan_id?: (string|null);
            chunk_file_size_in_bytes?: (number|Long|null);
            chunk_id?: (number|null);
            time_elapse_ms?: (number|null);
        }

        class ScanArchiveBuilderGetNextChunkEvent implements IScanArchiveBuilderGetNextChunkEvent {
            constructor(properties?: POGOProtos.Rpc.IScanArchiveBuilderGetNextChunkEvent);
            public scan_id: string;
            public chunk_file_size_in_bytes: (number|Long);
            public chunk_id: number;
            public time_elapse_ms: number;
            public static encode(message: POGOProtos.Rpc.IScanArchiveBuilderGetNextChunkEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanArchiveBuilderGetNextChunkEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanArchiveBuilderGetNextChunkEvent;
            public static toObject(message: POGOProtos.Rpc.ScanArchiveBuilderGetNextChunkEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IScanConfigurationProto {
            small_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            large_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            depth_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            grid_size?: (number|null);
            max_update_fps?: (number|null);
            anchor_interval?: (number|null);
            large_image_interval?: (number|null);
            min_weight?: (number|null);
            depth_source?: (number|null);
            min_depth_confidence?: (number|null);
            capture_mode?: (number|null);
            video_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            scan_mode?: (number|null);
        }

        class ScanConfigurationProto implements IScanConfigurationProto {
            constructor(properties?: POGOProtos.Rpc.IScanConfigurationProto);
            public small_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public large_image_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public depth_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public grid_size: number;
            public max_update_fps: number;
            public anchor_interval: number;
            public large_image_interval: number;
            public min_weight: number;
            public depth_source: number;
            public min_depth_confidence: number;
            public capture_mode: number;
            public video_size?: (POGOProtos.Rpc.IARDKRasterSizeProto|null);
            public scan_mode: number;
            public static encode(message: POGOProtos.Rpc.IScanConfigurationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanConfigurationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanConfigurationProto;
            public static toObject(message: POGOProtos.Rpc.ScanConfigurationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IScanErrorEvent {
            scan_id?: (string|null);
            error_code?: (POGOProtos.Rpc.ScanErrorEvent.Error|null);
            error_message?: (string|null);
        }

        class ScanErrorEvent implements IScanErrorEvent {
            constructor(properties?: POGOProtos.Rpc.IScanErrorEvent);
            public scan_id: string;
            public error_code: POGOProtos.Rpc.ScanErrorEvent.Error;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.IScanErrorEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanErrorEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanErrorEvent;
            public static toObject(message: POGOProtos.Rpc.ScanErrorEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ScanErrorEvent {

            enum Error {
                unknown = 0,
                sqc_not_ready = 1,
                sqc_bad_input = 2,
                sqc_bad_model = 3,
                sqc_model_read_fail = 4,
                sqc_decrypt_fail = 5,
                sqc_unpack_fail = 6,
                sqc_no_input_frames = 7,
                sqc_interrupted = 8
            }
        }

        interface IScanProto {
            id?: (string|null);
            created_at?: (number|null);
            modified_at?: (number|null);
            tz_offset_seconds?: (number|null);
            name?: (string|null);
            num_frames?: (number|null);
            num_anchors?: (number|null);
            point_count?: (number|null);
            total_size_bytes?: (number|Long|null);
            raw_data_size_bytes?: (number|Long|null);
            deprecated_quality?: (number|null);
            process_build?: (number|null);
            process_mode?: (number|null);
            geometry_resolution?: (number|null);
            simplification?: (number|null);
            capture_build?: (number|Long|null);
            capture_device?: (string|null);
            configuration?: (POGOProtos.Rpc.IScanConfigurationProto|null);
            adjustments?: (POGOProtos.Rpc.IAdjustmentParamsProto|null);
            capture_origin?: (number[]|null);
            location?: (POGOProtos.Rpc.IARDKLocationProto|null);
            place?: (POGOProtos.Rpc.IPlaceProto|null);
            last_save_build?: (number|null);
            score?: (number|null);
            post_id?: (string|null);
            dev_post_id?: (string|null);
            legacy_info?: (POGOProtos.Rpc.IDeprecatedCaptureInfoProto|null);
        }

        class ScanProto implements IScanProto {
            constructor(properties?: POGOProtos.Rpc.IScanProto);
            public id: string;
            public created_at: number;
            public modified_at: number;
            public tz_offset_seconds: number;
            public name: string;
            public num_frames: number;
            public num_anchors: number;
            public point_count: number;
            public total_size_bytes: (number|Long);
            public raw_data_size_bytes: (number|Long);
            public deprecated_quality: number;
            public process_build: number;
            public process_mode: number;
            public geometry_resolution: number;
            public simplification: number;
            public capture_build: (number|Long);
            public capture_device: string;
            public configuration?: (POGOProtos.Rpc.IScanConfigurationProto|null);
            public adjustments?: (POGOProtos.Rpc.IAdjustmentParamsProto|null);
            public capture_origin: number[];
            public location?: (POGOProtos.Rpc.IARDKLocationProto|null);
            public place?: (POGOProtos.Rpc.IPlaceProto|null);
            public last_save_build: number;
            public score: number;
            public post_id: string;
            public dev_post_id: string;
            public legacy_info?: (POGOProtos.Rpc.IDeprecatedCaptureInfoProto|null);
            public static encode(message: POGOProtos.Rpc.IScanProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanProto;
            public static toObject(message: POGOProtos.Rpc.ScanProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IScanRecorderStartEvent {
            scan_id?: (string|null);
            depth_source?: (POGOProtos.Rpc.ScanRecorderStartEvent.DepthSource|null);
            framerate?: (number|null);
            is_voxel_enabled?: (boolean|null);
            is_raycast_enabled?: (boolean|null);
        }

        class ScanRecorderStartEvent implements IScanRecorderStartEvent {
            constructor(properties?: POGOProtos.Rpc.IScanRecorderStartEvent);
            public scan_id: string;
            public depth_source: POGOProtos.Rpc.ScanRecorderStartEvent.DepthSource;
            public framerate: number;
            public is_voxel_enabled: boolean;
            public is_raycast_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IScanRecorderStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanRecorderStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanRecorderStartEvent;
            public static toObject(message: POGOProtos.Rpc.ScanRecorderStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ScanRecorderStartEvent {

            enum DepthSource {
                unknown = 0,
                lidar = 1,
                multidepth = 2,
                no_depth = 3
            }
        }

        interface IScanRecorderStopEvent {
            scan_id?: (string|null);
            operation?: (POGOProtos.Rpc.ScanRecorderStopEvent.Operation|null);
            scan_duration_ms?: (number|null);
            numer_of_frames_in_scan?: (number|null);
        }

        class ScanRecorderStopEvent implements IScanRecorderStopEvent {
            constructor(properties?: POGOProtos.Rpc.IScanRecorderStopEvent);
            public scan_id: string;
            public operation: POGOProtos.Rpc.ScanRecorderStopEvent.Operation;
            public scan_duration_ms: number;
            public numer_of_frames_in_scan: number;
            public static encode(message: POGOProtos.Rpc.IScanRecorderStopEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanRecorderStopEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanRecorderStopEvent;
            public static toObject(message: POGOProtos.Rpc.ScanRecorderStopEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ScanRecorderStopEvent {

            enum Operation {
                save = 0,
                discard = 1
            }
        }

        interface IScanSQCDoneEvent {
            scan_id?: (string|null);
            overall_score?: (number|null);
            time_elapse_ms?: (number|null);
            failed_reasons?: (POGOProtos.Rpc.ScanSQCDoneEvent.IScanSQCFailedReason[]|null);
        }

        class ScanSQCDoneEvent implements IScanSQCDoneEvent {
            constructor(properties?: POGOProtos.Rpc.IScanSQCDoneEvent);
            public scan_id: string;
            public overall_score: number;
            public time_elapse_ms: number;
            public failed_reasons: POGOProtos.Rpc.ScanSQCDoneEvent.IScanSQCFailedReason[];
            public static encode(message: POGOProtos.Rpc.IScanSQCDoneEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanSQCDoneEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanSQCDoneEvent;
            public static toObject(message: POGOProtos.Rpc.ScanSQCDoneEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ScanSQCDoneEvent {

            interface IScanSQCFailedReason {
                failed_reason?: (POGOProtos.Rpc.ScanSQCDoneEvent.ScanSQCFailedReason.FailedReason|null);
                score?: (number|null);
            }

            class ScanSQCFailedReason implements IScanSQCFailedReason {
                constructor(properties?: POGOProtos.Rpc.ScanSQCDoneEvent.IScanSQCFailedReason);
                public failed_reason: POGOProtos.Rpc.ScanSQCDoneEvent.ScanSQCFailedReason.FailedReason;
                public score: number;
                public static encode(message: POGOProtos.Rpc.ScanSQCDoneEvent.IScanSQCFailedReason, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanSQCDoneEvent.ScanSQCFailedReason;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanSQCDoneEvent.ScanSQCFailedReason;
                public static toObject(message: POGOProtos.Rpc.ScanSQCDoneEvent.ScanSQCFailedReason, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ScanSQCFailedReason {

                enum FailedReason {
                    blurry = 0,
                    dardk = 1,
                    bad_quality = 2,
                    ground_or_feet = 3,
                    indoor_unclear = 4,
                    from_car = 5,
                    obstructed = 6,
                    target_not_visible = 7
                }
            }
        }

        interface IScanSQCRunEvent {
            scan_id?: (string|null);
        }

        class ScanSQCRunEvent implements IScanSQCRunEvent {
            constructor(properties?: POGOProtos.Rpc.IScanSQCRunEvent);
            public scan_id: string;
            public static encode(message: POGOProtos.Rpc.IScanSQCRunEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScanSQCRunEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScanSQCRunEvent;
            public static toObject(message: POGOProtos.Rpc.ScanSQCRunEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IScreenResolutionTelemetry {
            device_width?: (number|null);
            device_height?: (number|null);
        }

        class ScreenResolutionTelemetry implements IScreenResolutionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IScreenResolutionTelemetry);
            public device_width: number;
            public device_height: number;
            public static encode(message: POGOProtos.Rpc.IScreenResolutionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ScreenResolutionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ScreenResolutionTelemetry;
            public static toObject(message: POGOProtos.Rpc.ScreenResolutionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISearchFilterPreferenceProto {
            recent_searches?: (POGOProtos.Rpc.SearchFilterPreferenceProto.ISearchFilterQueryProto[]|null);
            favorite_searches?: (POGOProtos.Rpc.SearchFilterPreferenceProto.ISearchFilterQueryProto[]|null);
        }

        class SearchFilterPreferenceProto implements ISearchFilterPreferenceProto {
            constructor(properties?: POGOProtos.Rpc.ISearchFilterPreferenceProto);
            public recent_searches: POGOProtos.Rpc.SearchFilterPreferenceProto.ISearchFilterQueryProto[];
            public favorite_searches: POGOProtos.Rpc.SearchFilterPreferenceProto.ISearchFilterQueryProto[];
            public static encode(message: POGOProtos.Rpc.ISearchFilterPreferenceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SearchFilterPreferenceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SearchFilterPreferenceProto;
            public static toObject(message: POGOProtos.Rpc.SearchFilterPreferenceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SearchFilterPreferenceProto {

            interface ISearchFilterQueryProto {
                title?: (string|null);
                query?: (string|null);
            }

            class SearchFilterQueryProto implements ISearchFilterQueryProto {
                constructor(properties?: POGOProtos.Rpc.SearchFilterPreferenceProto.ISearchFilterQueryProto);
                public title: string;
                public query: string;
                public static encode(message: POGOProtos.Rpc.SearchFilterPreferenceProto.ISearchFilterQueryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SearchFilterPreferenceProto.SearchFilterQueryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SearchFilterPreferenceProto.SearchFilterQueryProto;
                public static toObject(message: POGOProtos.Rpc.SearchFilterPreferenceProto.SearchFilterQueryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ISeasonContestsDefinitionSettingsProto {
            season_start_time_ms?: (number|Long|null);
            season_end_time_ms?: (number|Long|null);
            cycle?: (POGOProtos.Rpc.IContestCycleProto[]|null);
        }

        class SeasonContestsDefinitionSettingsProto implements ISeasonContestsDefinitionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISeasonContestsDefinitionSettingsProto);
            public season_start_time_ms: (number|Long);
            public season_end_time_ms: (number|Long);
            public cycle: POGOProtos.Rpc.IContestCycleProto[];
            public static encode(message: POGOProtos.Rpc.ISeasonContestsDefinitionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SeasonContestsDefinitionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SeasonContestsDefinitionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SeasonContestsDefinitionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISemanticsStartEvent {
            empty_field?: (boolean|null);
        }

        class SemanticsStartEvent implements ISemanticsStartEvent {
            constructor(properties?: POGOProtos.Rpc.ISemanticsStartEvent);
            public empty_field: boolean;
            public static encode(message: POGOProtos.Rpc.ISemanticsStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SemanticsStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SemanticsStartEvent;
            public static toObject(message: POGOProtos.Rpc.SemanticsStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISemanticsStopEvent {
            time_elapsed_ms?: (number|null);
        }

        class SemanticsStopEvent implements ISemanticsStopEvent {
            constructor(properties?: POGOProtos.Rpc.ISemanticsStopEvent);
            public time_elapsed_ms: number;
            public static encode(message: POGOProtos.Rpc.ISemanticsStopEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SemanticsStopEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SemanticsStopEvent;
            public static toObject(message: POGOProtos.Rpc.SemanticsStopEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendBattleEventOutProto {
            result?: (POGOProtos.Rpc.SendBattleEventOutProto.Result|null);
            error?: (string|null);
            sequence_id?: (number|Long|null);
        }

        class SendBattleEventOutProto implements ISendBattleEventOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendBattleEventOutProto);
            public result: POGOProtos.Rpc.SendBattleEventOutProto.Result;
            public error: string;
            public sequence_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISendBattleEventOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendBattleEventOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendBattleEventOutProto;
            public static toObject(message: POGOProtos.Rpc.SendBattleEventOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendBattleEventOutProto {

            enum Result {
                UNSET = 0,
                ACCEPTED = 1,
                REJECTED = 2,
                PENDING = 3,
                UNKNOWN = 4,
                ERROR_SERVER_FAILURE = 5,
                ERROR_BAD_REQUEST = 6,
                ERROR_IO_EXCEPTION = 7
            }
        }

        interface ISendBattleEventProto {
            battle_id?: (string|null);
            player_id?: (string|null);
            sequence_id?: (number|Long|null);
            get_full_state?: (boolean|null);
            battle_event?: (POGOProtos.Rpc.IBattleEventProto|null);
        }

        class SendBattleEventProto implements ISendBattleEventProto {
            constructor(properties?: POGOProtos.Rpc.ISendBattleEventProto);
            public battle_id: string;
            public player_id: string;
            public sequence_id: (number|Long);
            public get_full_state: boolean;
            public battle_event?: (POGOProtos.Rpc.IBattleEventProto|null);
            public static encode(message: POGOProtos.Rpc.ISendBattleEventProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendBattleEventProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendBattleEventProto;
            public static toObject(message: POGOProtos.Rpc.SendBattleEventProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendBreadBattleInvitationOutProto {
            result?: (POGOProtos.Rpc.SendBreadBattleInvitationOutProto.Result|null);
            num_friend_invites_remaining?: (number|null);
            failed_invitee_ids?: (string[]|null);
        }

        class SendBreadBattleInvitationOutProto implements ISendBreadBattleInvitationOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendBreadBattleInvitationOutProto);
            public result: POGOProtos.Rpc.SendBreadBattleInvitationOutProto.Result;
            public num_friend_invites_remaining: number;
            public failed_invitee_ids: string[];
            public static encode(message: POGOProtos.Rpc.ISendBreadBattleInvitationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendBreadBattleInvitationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendBreadBattleInvitationOutProto;
            public static toObject(message: POGOProtos.Rpc.SendBreadBattleInvitationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendBreadBattleInvitationOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NO_PERMISSION = 2,
                ERROR_STATION_NOT_FOUND = 3,
                ERROR_LOBBY_NOT_FOUND = 4,
                ERROR_PAST_CUT_OFF_TIME = 5,
                ERROR_NO_INVITES_REMAINING = 6,
                ERROR_LOBBY_FULL = 7,
                ERROR_INVITER_NOT_FOUND = 8,
                ERROR_NO_REMOTE_SLOTS_REMAINING = 9,
                ERROR_MAX_BATTLE_LEVEL_UNSUPPORTED = 10,
                ERROR_CANNOT_INVITE = 11,
                ERROR_REMOTE_MAX_BATTLE_DISABLED = 12
            }
        }

        interface ISendBreadBattleInvitationProto {
            invitee_ids?: (string[]|null);
            station_id?: (string|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
        }

        class SendBreadBattleInvitationProto implements ISendBreadBattleInvitationProto {
            constructor(properties?: POGOProtos.Rpc.ISendBreadBattleInvitationProto);
            public invitee_ids: string[];
            public station_id: string;
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.ISendBreadBattleInvitationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendBreadBattleInvitationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendBreadBattleInvitationProto;
            public static toObject(message: POGOProtos.Rpc.SendBreadBattleInvitationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendEventRsvpInvitationOutProto {
            result?: (POGOProtos.Rpc.SendEventRsvpInvitationOutProto.Result|null);
        }

        class SendEventRsvpInvitationOutProto implements ISendEventRsvpInvitationOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendEventRsvpInvitationOutProto);
            public result: POGOProtos.Rpc.SendEventRsvpInvitationOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISendEventRsvpInvitationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendEventRsvpInvitationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendEventRsvpInvitationOutProto;
            public static toObject(message: POGOProtos.Rpc.SendEventRsvpInvitationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendEventRsvpInvitationOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                MAX_INVITES_REACHED = 3
            }
        }

        interface ISendEventRsvpInvitationProto {
            invitee_ids?: (string[]|null);
            location_id?: (string|null);
            timeslot?: (number|Long|null);
            location_lat_degrees?: (number|null);
            location_lng_degrees?: (number|null);
        }

        class SendEventRsvpInvitationProto implements ISendEventRsvpInvitationProto {
            constructor(properties?: POGOProtos.Rpc.ISendEventRsvpInvitationProto);
            public invitee_ids: string[];
            public location_id: string;
            public timeslot: (number|Long);
            public location_lat_degrees: number;
            public location_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.ISendEventRsvpInvitationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendEventRsvpInvitationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendEventRsvpInvitationProto;
            public static toObject(message: POGOProtos.Rpc.SendEventRsvpInvitationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendFriendInviteViaReferralCodeOutProto {
            status?: (POGOProtos.Rpc.SendFriendInviteViaReferralCodeOutProto.Status|null);
            message?: (string|null);
        }

        class SendFriendInviteViaReferralCodeOutProto implements ISendFriendInviteViaReferralCodeOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendFriendInviteViaReferralCodeOutProto);
            public status: POGOProtos.Rpc.SendFriendInviteViaReferralCodeOutProto.Status;
            public message: string;
            public static encode(message: POGOProtos.Rpc.ISendFriendInviteViaReferralCodeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendFriendInviteViaReferralCodeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendFriendInviteViaReferralCodeOutProto;
            public static toObject(message: POGOProtos.Rpc.SendFriendInviteViaReferralCodeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendFriendInviteViaReferralCodeOutProto {

            enum Status {
                UNSET = 0,
                SENT = 1,
                ERROR_UNKNOWN = 2,
                ERROR_DISABLED = 3,
                ERROR_INVALID_REFERRAL_CODE = 4
            }
        }

        interface ISendFriendInviteViaReferralCodeProto {
            referral_code?: (string|null);
            read_only?: (boolean|null);
        }

        class SendFriendInviteViaReferralCodeProto implements ISendFriendInviteViaReferralCodeProto {
            constructor(properties?: POGOProtos.Rpc.ISendFriendInviteViaReferralCodeProto);
            public referral_code: string;
            public read_only: boolean;
            public static encode(message: POGOProtos.Rpc.ISendFriendInviteViaReferralCodeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendFriendInviteViaReferralCodeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendFriendInviteViaReferralCodeProto;
            public static toObject(message: POGOProtos.Rpc.SendFriendInviteViaReferralCodeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendFriendRequestViaPlayerIdOutProto {
            result?: (POGOProtos.Rpc.SendFriendRequestViaPlayerIdOutProto.Result|null);
        }

        class SendFriendRequestViaPlayerIdOutProto implements ISendFriendRequestViaPlayerIdOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendFriendRequestViaPlayerIdOutProto);
            public result: POGOProtos.Rpc.SendFriendRequestViaPlayerIdOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISendFriendRequestViaPlayerIdOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendFriendRequestViaPlayerIdOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendFriendRequestViaPlayerIdOutProto;
            public static toObject(message: POGOProtos.Rpc.SendFriendRequestViaPlayerIdOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendFriendRequestViaPlayerIdOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_PLAYER_ID = 3,
                ERROR_FRIEND_REQUESTS_DISABLED = 4,
                ERROR_ALREADY_A_FRIEND = 5,
                ERROR_PLAYER_DOES_NOT_EXIST_DELETED = 6,
                ERROR_PLAYER_INBOX_FULL = 7,
                ERROR_PLAYER_OUTBOX_FULL = 8,
                ERROR_SENDER_HAS_MAX_FRIENDS = 9,
                ERROR_INVITE_ALREADY_SENT = 10,
                ERROR_CANNOT_SEND_INVITES_TO_YOURSELF = 11,
                ERROR_INVITE_ALREADY_RECEIVED = 12,
                ERROR_RECEIVER_HAS_MAX_FRIENDS = 13,
                ERROR_SEND_TO_BLOCKED_USER = 14,
                ERROR_NOT_IN_PARTY = 15,
                ERROR_PLAYER_NOT_PARTY_MEMBER = 16
            }
        }

        interface ISendFriendRequestViaPlayerIdProto {
            player_id?: (string|null);
            context?: (POGOProtos.Rpc.SendFriendRequestViaPlayerIdProto.Context|null);
        }

        class SendFriendRequestViaPlayerIdProto implements ISendFriendRequestViaPlayerIdProto {
            constructor(properties?: POGOProtos.Rpc.ISendFriendRequestViaPlayerIdProto);
            public player_id: string;
            public context: POGOProtos.Rpc.SendFriendRequestViaPlayerIdProto.Context;
            public static encode(message: POGOProtos.Rpc.ISendFriendRequestViaPlayerIdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendFriendRequestViaPlayerIdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendFriendRequestViaPlayerIdProto;
            public static toObject(message: POGOProtos.Rpc.SendFriendRequestViaPlayerIdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendFriendRequestViaPlayerIdProto {

            enum Context {
                RAID = 0,
                PARTY = 1
            }
        }

        interface ISendGiftLogEntry {
            result?: (POGOProtos.Rpc.SendGiftLogEntry.Result|null);
            friend_codename?: (string|null);
        }

        class SendGiftLogEntry implements ISendGiftLogEntry {
            constructor(properties?: POGOProtos.Rpc.ISendGiftLogEntry);
            public result: POGOProtos.Rpc.SendGiftLogEntry.Result;
            public friend_codename: string;
            public static encode(message: POGOProtos.Rpc.ISendGiftLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendGiftLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendGiftLogEntry;
            public static toObject(message: POGOProtos.Rpc.SendGiftLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendGiftLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ISendGiftOutProto {
            result?: (POGOProtos.Rpc.SendGiftOutProto.Result|null);
            awarded_xp?: (number|null);
            awarded_items?: (POGOProtos.Rpc.ILootProto[]|null);
        }

        class SendGiftOutProto implements ISendGiftOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendGiftOutProto);
            public result: POGOProtos.Rpc.SendGiftOutProto.Result;
            public awarded_xp: number;
            public awarded_items: POGOProtos.Rpc.ILootProto[];
            public static encode(message: POGOProtos.Rpc.ISendGiftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendGiftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendGiftOutProto;
            public static toObject(message: POGOProtos.Rpc.SendGiftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendGiftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_DOES_NOT_EXIST = 3,
                ERROR_GIFT_DOES_NOT_EXIST = 4,
                ERROR_GIFT_ALREADY_SENT_TODAY = 5,
                ERROR_PLAYER_HAS_UNOPENED_GIFT = 6,
                ERROR_FRIEND_UPDATE = 7,
                ERROR_PLAYER_HAS_NO_STICKERS = 8,
                ERROR_PLAYER_CANNOT_RECEIVE_STAMP_FROM_COLLECTION = 9,
                ERROR_PLAYER_ALREADY_HAS_STAMP = 10,
                ERROR_PLAYER_OPTED_OUT_OF_STAMP = 11,
                ERROR_FRIENDSHIP_LEVEL_TOO_LOW_STAMP = 12
            }
        }

        interface ISendGiftProto {
            giftbox_id?: (number|Long|null);
            player_id?: (string|null);
            stickers_sent?: (POGOProtos.Rpc.IStickerSentProto[]|null);
            override_friend_stamp_collection_error?: (boolean|null);
        }

        class SendGiftProto implements ISendGiftProto {
            constructor(properties?: POGOProtos.Rpc.ISendGiftProto);
            public giftbox_id: (number|Long);
            public player_id: string;
            public stickers_sent: POGOProtos.Rpc.IStickerSentProto[];
            public override_friend_stamp_collection_error: boolean;
            public static encode(message: POGOProtos.Rpc.ISendGiftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendGiftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendGiftProto;
            public static toObject(message: POGOProtos.Rpc.SendGiftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendPartyInvitationOutProto {
            result?: (POGOProtos.Rpc.SendPartyInvitationOutProto.Result|null);
            player_result?: (POGOProtos.Rpc.SendPartyInvitationOutProto.PlayerResult[]|null);
        }

        class SendPartyInvitationOutProto implements ISendPartyInvitationOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendPartyInvitationOutProto);
            public result: POGOProtos.Rpc.SendPartyInvitationOutProto.Result;
            public player_result: POGOProtos.Rpc.SendPartyInvitationOutProto.PlayerResult[];
            public static encode(message: POGOProtos.Rpc.ISendPartyInvitationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendPartyInvitationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendPartyInvitationOutProto;
            public static toObject(message: POGOProtos.Rpc.SendPartyInvitationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendPartyInvitationOutProto {

            enum PlayerResult {
                PLAYER_RESULT_UNSET = 0,
                PLAYER_RESULT_SUCCESS = 1,
                PLAYER_RESULT_ERROR_UNKNOWN = 2,
                PLAYER_RESULT_ERROR_RECIEVER_LIMIT = 3,
                PLAYER_RESULT_ERORR_U13 = 4,
                PLAYER_RESULT_ERROR_ALREADY_INVITED = 5
            }

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_INVITE_LIMIT_FOR_GROUP = 3,
                ERROR_NO_SUCH_PARTY = 4
            }
        }

        interface ISendPartyInvitationProto {
            invitee_ids?: (string[]|null);
            party_id?: (number[]|null);
            id?: (number|Long|null);
            type?: (POGOProtos.Rpc.PartyType|null);
        }

        class SendPartyInvitationProto implements ISendPartyInvitationProto {
            constructor(properties?: POGOProtos.Rpc.ISendPartyInvitationProto);
            public invitee_ids: string[];
            public party_id: number[];
            public id: (number|Long);
            public type: POGOProtos.Rpc.PartyType;
            public static encode(message: POGOProtos.Rpc.ISendPartyInvitationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendPartyInvitationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendPartyInvitationProto;
            public static toObject(message: POGOProtos.Rpc.SendPartyInvitationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendProbeOutProto {
            result?: (POGOProtos.Rpc.SendProbeOutProto.Result|null);
            id?: (string|null);
            server_timestamp_ms?: (number|Long|null);
        }

        class SendProbeOutProto implements ISendProbeOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendProbeOutProto);
            public result: POGOProtos.Rpc.SendProbeOutProto.Result;
            public id: string;
            public server_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISendProbeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendProbeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendProbeOutProto;
            public static toObject(message: POGOProtos.Rpc.SendProbeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendProbeOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ISendProbeProto {
        }

        class SendProbeProto implements ISendProbeProto {
            constructor(properties?: POGOProtos.Rpc.ISendProbeProto);
            public static encode(message: POGOProtos.Rpc.ISendProbeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendProbeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendProbeProto;
            public static toObject(message: POGOProtos.Rpc.SendProbeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendRaidInvitationData {
            rpc_id?: (number|null);
        }

        class SendRaidInvitationData implements ISendRaidInvitationData {
            constructor(properties?: POGOProtos.Rpc.ISendRaidInvitationData);
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.ISendRaidInvitationData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendRaidInvitationData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendRaidInvitationData;
            public static toObject(message: POGOProtos.Rpc.SendRaidInvitationData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendRaidInvitationOutProto {
            result?: (POGOProtos.Rpc.SendRaidInvitationOutProto.Result|null);
            num_friend_invites_remaining?: (number|null);
            failed_invitee_ids?: (string[]|null);
        }

        class SendRaidInvitationOutProto implements ISendRaidInvitationOutProto {
            constructor(properties?: POGOProtos.Rpc.ISendRaidInvitationOutProto);
            public result: POGOProtos.Rpc.SendRaidInvitationOutProto.Result;
            public num_friend_invites_remaining: number;
            public failed_invitee_ids: string[];
            public static encode(message: POGOProtos.Rpc.ISendRaidInvitationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendRaidInvitationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendRaidInvitationOutProto;
            public static toObject(message: POGOProtos.Rpc.SendRaidInvitationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SendRaidInvitationOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NO_PERMISSION = 2,
                ERROR_GYM_NOT_FOUND = 3,
                ERROR_LOBBY_NOT_FOUND = 4,
                ERROR_PAST_CUT_OFF_TIME = 5,
                ERROR_NO_INVITES_REMAINING = 6,
                ERROR_LOBBY_FULL = 7,
                ERROR_INVITER_NOT_FOUND = 8,
                ERROR_NO_REMOTE_SLOTS_REMAINING = 9
            }
        }

        interface ISendRaidInvitationProto {
            invitee_ids?: (string[]|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
        }

        class SendRaidInvitationProto implements ISendRaidInvitationProto {
            constructor(properties?: POGOProtos.Rpc.ISendRaidInvitationProto);
            public invitee_ids: string[];
            public gym_id: string;
            public lobby_id: number[];
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.ISendRaidInvitationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendRaidInvitationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendRaidInvitationProto;
            public static toObject(message: POGOProtos.Rpc.SendRaidInvitationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISendRaidInvitationResponseData {
            result?: (POGOProtos.Rpc.SendRaidInvitationOutProto.Result|null);
            num_friend_invites_remaining?: (number|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
        }

        class SendRaidInvitationResponseData implements ISendRaidInvitationResponseData {
            constructor(properties?: POGOProtos.Rpc.ISendRaidInvitationResponseData);
            public result: POGOProtos.Rpc.SendRaidInvitationOutProto.Result;
            public num_friend_invites_remaining: number;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public static encode(message: POGOProtos.Rpc.ISendRaidInvitationResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SendRaidInvitationResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SendRaidInvitationResponseData;
            public static toObject(message: POGOProtos.Rpc.SendRaidInvitationResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IServerRecordMetadata {
            user_id?: (string|null);
            telemetry_name?: (string|null);
            session_id?: (string|null);
            request_id?: (string|null);
            server_timestamp_ms?: (number|Long|null);
            client_request_id?: (string|null);
        }

        class ServerRecordMetadata implements IServerRecordMetadata {
            constructor(properties?: POGOProtos.Rpc.IServerRecordMetadata);
            public user_id: string;
            public telemetry_name: string;
            public session_id: string;
            public request_id: string;
            public server_timestamp_ms: (number|Long);
            public client_request_id: string;
            public static encode(message: POGOProtos.Rpc.IServerRecordMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ServerRecordMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ServerRecordMetadata;
            public static toObject(message: POGOProtos.Rpc.ServerRecordMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IServiceDescriptorProto {
            name?: (string|null);
            method?: (POGOProtos.Rpc.IMethodDescriptorProto[]|null);
            options?: (POGOProtos.Rpc.IServiceOptions|null);
        }

        class ServiceDescriptorProto implements IServiceDescriptorProto {
            constructor(properties?: POGOProtos.Rpc.IServiceDescriptorProto);
            public name: string;
            public method: POGOProtos.Rpc.IMethodDescriptorProto[];
            public options?: (POGOProtos.Rpc.IServiceOptions|null);
            public static encode(message: POGOProtos.Rpc.IServiceDescriptorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ServiceDescriptorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ServiceDescriptorProto;
            public static toObject(message: POGOProtos.Rpc.ServiceDescriptorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IServiceOptions {
            deprecated?: (boolean|null);
        }

        class ServiceOptions implements IServiceOptions {
            constructor(properties?: POGOProtos.Rpc.IServiceOptions);
            public deprecated: boolean;
            public static encode(message: POGOProtos.Rpc.IServiceOptions, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ServiceOptions;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ServiceOptions;
            public static toObject(message: POGOProtos.Rpc.ServiceOptions, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetAvatarItemAsViewedOutProto {
            result?: (POGOProtos.Rpc.SetAvatarItemAsViewedOutProto.Result|null);
        }

        class SetAvatarItemAsViewedOutProto implements ISetAvatarItemAsViewedOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetAvatarItemAsViewedOutProto);
            public result: POGOProtos.Rpc.SetAvatarItemAsViewedOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISetAvatarItemAsViewedOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetAvatarItemAsViewedOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetAvatarItemAsViewedOutProto;
            public static toObject(message: POGOProtos.Rpc.SetAvatarItemAsViewedOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetAvatarItemAsViewedOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface ISetAvatarItemAsViewedProto {
            avatar_template_id?: (string[]|null);
        }

        class SetAvatarItemAsViewedProto implements ISetAvatarItemAsViewedProto {
            constructor(properties?: POGOProtos.Rpc.ISetAvatarItemAsViewedProto);
            public avatar_template_id: string[];
            public static encode(message: POGOProtos.Rpc.ISetAvatarItemAsViewedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetAvatarItemAsViewedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetAvatarItemAsViewedProto;
            public static toObject(message: POGOProtos.Rpc.SetAvatarItemAsViewedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetAvatarOutProto {
            status?: (POGOProtos.Rpc.SetAvatarOutProto.Status|null);
            player?: (POGOProtos.Rpc.IClientPlayerProto|null);
        }

        class SetAvatarOutProto implements ISetAvatarOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetAvatarOutProto);
            public status: POGOProtos.Rpc.SetAvatarOutProto.Status;
            public player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public static encode(message: POGOProtos.Rpc.ISetAvatarOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetAvatarOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetAvatarOutProto;
            public static toObject(message: POGOProtos.Rpc.SetAvatarOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetAvatarOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                AVATAR_ALREADY_SET = 2,
                FAILURE = 3,
                SLOT_NOT_ALLOWED = 4,
                ITEM_NOT_OWNED = 5,
                INVALID_AVATAR_TYPE = 6,
                AVATAR_RESET = 7
            }
        }

        interface ISetAvatarProto {
            player_avatar_proto?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
        }

        class SetAvatarProto implements ISetAvatarProto {
            constructor(properties?: POGOProtos.Rpc.ISetAvatarProto);
            public player_avatar_proto?: (POGOProtos.Rpc.IPlayerAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.ISetAvatarProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetAvatarProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetAvatarProto;
            public static toObject(message: POGOProtos.Rpc.SetAvatarProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetBirthdayRequestProto {
            birthday?: (string|null);
        }

        class SetBirthdayRequestProto implements ISetBirthdayRequestProto {
            constructor(properties?: POGOProtos.Rpc.ISetBirthdayRequestProto);
            public birthday: string;
            public static encode(message: POGOProtos.Rpc.ISetBirthdayRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetBirthdayRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetBirthdayRequestProto;
            public static toObject(message: POGOProtos.Rpc.SetBirthdayRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetBirthdayResponseProto {
            status?: (POGOProtos.Rpc.SetBirthdayResponseProto.Status|null);
        }

        class SetBirthdayResponseProto implements ISetBirthdayResponseProto {
            constructor(properties?: POGOProtos.Rpc.ISetBirthdayResponseProto);
            public status: POGOProtos.Rpc.SetBirthdayResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.ISetBirthdayResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetBirthdayResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetBirthdayResponseProto;
            public static toObject(message: POGOProtos.Rpc.SetBirthdayResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetBirthdayResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                INVALID_BIRTHDAY = 3
            }
        }

        interface ISetBuddyPokemonOutProto {
            result?: (POGOProtos.Rpc.SetBuddyPokemonOutProto.Result|null);
            updated_buddy?: (POGOProtos.Rpc.IBuddyPokemonProto|null);
            observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            km_remaining?: (number|null);
        }

        class SetBuddyPokemonOutProto implements ISetBuddyPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetBuddyPokemonOutProto);
            public result: POGOProtos.Rpc.SetBuddyPokemonOutProto.Result;
            public updated_buddy?: (POGOProtos.Rpc.IBuddyPokemonProto|null);
            public observed_data?: (POGOProtos.Rpc.IBuddyObservedData|null);
            public km_remaining: number;
            public static encode(message: POGOProtos.Rpc.ISetBuddyPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetBuddyPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetBuddyPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.SetBuddyPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetBuddyPokemonOutProto {

            enum Result {
                UNEST = 0,
                SUCCESS = 1,
                ERROR_POKEMON_DEPLOYED = 2,
                ERROR_POKEMON_NOT_OWNED = 3,
                ERROR_POKEMON_IS_EGG = 4,
                ERROR_INVALID_POKEMON = 5,
                ERROR_BUDDY_SWAP_LIMIT_EXCEEDED = 6
            }
        }

        interface ISetBuddyPokemonProto {
            pokemon_id?: (number|Long|null);
        }

        class SetBuddyPokemonProto implements ISetBuddyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ISetBuddyPokemonProto);
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISetBuddyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetBuddyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetBuddyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.SetBuddyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetContactSettingsOutProto {
            status?: (POGOProtos.Rpc.SetContactSettingsOutProto.Status|null);
            player?: (POGOProtos.Rpc.IClientPlayerProto|null);
        }

        class SetContactSettingsOutProto implements ISetContactSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetContactSettingsOutProto);
            public status: POGOProtos.Rpc.SetContactSettingsOutProto.Status;
            public player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public static encode(message: POGOProtos.Rpc.ISetContactSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetContactSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetContactSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.SetContactSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetContactSettingsOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface ISetContactSettingsProto {
            contact_settings_proto?: (POGOProtos.Rpc.IContactSettingsProto|null);
        }

        class SetContactSettingsProto implements ISetContactSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISetContactSettingsProto);
            public contact_settings_proto?: (POGOProtos.Rpc.IContactSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.ISetContactSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetContactSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetContactSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SetContactSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetFavoritePokemonOutProto {
            result?: (POGOProtos.Rpc.SetFavoritePokemonOutProto.Result|null);
        }

        class SetFavoritePokemonOutProto implements ISetFavoritePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetFavoritePokemonOutProto);
            public result: POGOProtos.Rpc.SetFavoritePokemonOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISetFavoritePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetFavoritePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetFavoritePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.SetFavoritePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetFavoritePokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_NOT_FOUND = 2,
                ERROR_POKEMON_IS_EGG = 3
            }
        }

        interface ISetFavoritePokemonProto {
            pokemon_id?: (number|Long|null);
            is_favorite?: (boolean|null);
        }

        class SetFavoritePokemonProto implements ISetFavoritePokemonProto {
            constructor(properties?: POGOProtos.Rpc.ISetFavoritePokemonProto);
            public pokemon_id: (number|Long);
            public is_favorite: boolean;
            public static encode(message: POGOProtos.Rpc.ISetFavoritePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetFavoritePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetFavoritePokemonProto;
            public static toObject(message: POGOProtos.Rpc.SetFavoritePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetFriendNicknameOutProto {
            result?: (POGOProtos.Rpc.SetFriendNicknameOutProto.Result|null);
        }

        class SetFriendNicknameOutProto implements ISetFriendNicknameOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetFriendNicknameOutProto);
            public result: POGOProtos.Rpc.SetFriendNicknameOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISetFriendNicknameOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetFriendNicknameOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetFriendNicknameOutProto;
            public static toObject(message: POGOProtos.Rpc.SetFriendNicknameOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetFriendNicknameOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FRIENDS = 3,
                ERROR_EXCEEDED_NICKNAME_LENGTH = 4,
                ERROR_SOCIAL_UPDATE = 5,
                ERROR_FILTERED_NICKNAME = 6,
                ERROR_EXCEEDED_CHANGE_LIMIT = 7
            }
        }

        interface ISetFriendNicknameProto {
            friend_id?: (string|null);
            friend_nickname?: (string|null);
        }

        class SetFriendNicknameProto implements ISetFriendNicknameProto {
            constructor(properties?: POGOProtos.Rpc.ISetFriendNicknameProto);
            public friend_id: string;
            public friend_nickname: string;
            public static encode(message: POGOProtos.Rpc.ISetFriendNicknameProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetFriendNicknameProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetFriendNicknameProto;
            public static toObject(message: POGOProtos.Rpc.SetFriendNicknameProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetLobbyPokemonOutProto {
            result?: (POGOProtos.Rpc.SetLobbyPokemonOutProto.Result|null);
            lobby?: (POGOProtos.Rpc.ILobbyProto|null);
        }

        class SetLobbyPokemonOutProto implements ISetLobbyPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetLobbyPokemonOutProto);
            public result: POGOProtos.Rpc.SetLobbyPokemonOutProto.Result;
            public lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            public static encode(message: POGOProtos.Rpc.ISetLobbyPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetLobbyPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetLobbyPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.SetLobbyPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetLobbyPokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_LOBBY_NOT_FOUND = 2,
                ERROR_RAID_UNAVAILABLE = 3,
                ERROR_INVALID_POKEMON = 4
            }
        }

        interface ISetLobbyPokemonProto {
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
            pokemon_id?: ((number|Long)[]|null);
        }

        class SetLobbyPokemonProto implements ISetLobbyPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ISetLobbyPokemonProto);
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public pokemon_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.ISetLobbyPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetLobbyPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetLobbyPokemonProto;
            public static toObject(message: POGOProtos.Rpc.SetLobbyPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetLobbyVisibilityOutProto {
            result?: (POGOProtos.Rpc.SetLobbyVisibilityOutProto.Result|null);
            lobby?: (POGOProtos.Rpc.ILobbyProto|null);
        }

        class SetLobbyVisibilityOutProto implements ISetLobbyVisibilityOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetLobbyVisibilityOutProto);
            public result: POGOProtos.Rpc.SetLobbyVisibilityOutProto.Result;
            public lobby?: (POGOProtos.Rpc.ILobbyProto|null);
            public static encode(message: POGOProtos.Rpc.ISetLobbyVisibilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetLobbyVisibilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetLobbyVisibilityOutProto;
            public static toObject(message: POGOProtos.Rpc.SetLobbyVisibilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetLobbyVisibilityOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_LOBBY_CREATOR = 2,
                ERROR_LOBBY_NOT_FOUND = 3,
                ERROR_RAID_UNAVAILABLE = 4
            }
        }

        interface ISetLobbyVisibilityProto {
            raid_seed?: (number|Long|null);
            gym_id?: (string|null);
            lobby_id?: (number[]|null);
        }

        class SetLobbyVisibilityProto implements ISetLobbyVisibilityProto {
            constructor(properties?: POGOProtos.Rpc.ISetLobbyVisibilityProto);
            public raid_seed: (number|Long);
            public gym_id: string;
            public lobby_id: number[];
            public static encode(message: POGOProtos.Rpc.ISetLobbyVisibilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetLobbyVisibilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetLobbyVisibilityProto;
            public static toObject(message: POGOProtos.Rpc.SetLobbyVisibilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetNeutralAvatarOutProto {
            status?: (POGOProtos.Rpc.SetNeutralAvatarOutProto.Status|null);
            player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class SetNeutralAvatarOutProto implements ISetNeutralAvatarOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetNeutralAvatarOutProto);
            public status: POGOProtos.Rpc.SetNeutralAvatarOutProto.Status;
            public player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public neutral_avatar?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.ISetNeutralAvatarOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetNeutralAvatarOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetNeutralAvatarOutProto;
            public static toObject(message: POGOProtos.Rpc.SetNeutralAvatarOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetNeutralAvatarOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                AVATAR_ALREADY_SET = 2,
                FAILURE = 3,
                SLOT_NOT_ALLOWED = 4,
                ITEM_NOT_OWNED = 5,
                AVATAR_RESET = 6
            }
        }

        interface ISetNeutralAvatarProto {
            player_neutral_avatar_proto?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
        }

        class SetNeutralAvatarProto implements ISetNeutralAvatarProto {
            constructor(properties?: POGOProtos.Rpc.ISetNeutralAvatarProto);
            public player_neutral_avatar_proto?: (POGOProtos.Rpc.IPlayerNeutralAvatarProto|null);
            public static encode(message: POGOProtos.Rpc.ISetNeutralAvatarProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetNeutralAvatarProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetNeutralAvatarProto;
            public static toObject(message: POGOProtos.Rpc.SetNeutralAvatarProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetPlayerStatusOutProto {
            result?: (POGOProtos.Rpc.SetPlayerStatusOutProto.Result|null);
        }

        class SetPlayerStatusOutProto implements ISetPlayerStatusOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetPlayerStatusOutProto);
            public result: POGOProtos.Rpc.SetPlayerStatusOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISetPlayerStatusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPlayerStatusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPlayerStatusOutProto;
            public static toObject(message: POGOProtos.Rpc.SetPlayerStatusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetPlayerStatusOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ISetPlayerStatusProto {
            platform?: (POGOProtos.Rpc.Platform|null);
            user_date_of_birth?: (string|null);
            sentry_id?: (string|null);
        }

        class SetPlayerStatusProto implements ISetPlayerStatusProto {
            constructor(properties?: POGOProtos.Rpc.ISetPlayerStatusProto);
            public platform: POGOProtos.Rpc.Platform;
            public user_date_of_birth: string;
            public sentry_id: string;
            public static encode(message: POGOProtos.Rpc.ISetPlayerStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPlayerStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPlayerStatusProto;
            public static toObject(message: POGOProtos.Rpc.SetPlayerStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetPlayerTeamOutProto {
            status?: (POGOProtos.Rpc.SetPlayerTeamOutProto.Status|null);
            player?: (POGOProtos.Rpc.IClientPlayerProto|null);
        }

        class SetPlayerTeamOutProto implements ISetPlayerTeamOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetPlayerTeamOutProto);
            public status: POGOProtos.Rpc.SetPlayerTeamOutProto.Status;
            public player?: (POGOProtos.Rpc.IClientPlayerProto|null);
            public static encode(message: POGOProtos.Rpc.ISetPlayerTeamOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPlayerTeamOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPlayerTeamOutProto;
            public static toObject(message: POGOProtos.Rpc.SetPlayerTeamOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetPlayerTeamOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                TEAM_ALREADY_SET = 2,
                FAILURE = 3
            }
        }

        interface ISetPlayerTeamProto {
            team?: (POGOProtos.Rpc.Team|null);
        }

        class SetPlayerTeamProto implements ISetPlayerTeamProto {
            constructor(properties?: POGOProtos.Rpc.ISetPlayerTeamProto);
            public team: POGOProtos.Rpc.Team;
            public static encode(message: POGOProtos.Rpc.ISetPlayerTeamProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPlayerTeamProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPlayerTeamProto;
            public static toObject(message: POGOProtos.Rpc.SetPlayerTeamProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetPokemonTagsForPokemonOutProto {
            status?: (POGOProtos.Rpc.SetPokemonTagsForPokemonOutProto.Status|null);
        }

        class SetPokemonTagsForPokemonOutProto implements ISetPokemonTagsForPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.ISetPokemonTagsForPokemonOutProto);
            public status: POGOProtos.Rpc.SetPokemonTagsForPokemonOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ISetPokemonTagsForPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPokemonTagsForPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPokemonTagsForPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.SetPokemonTagsForPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetPokemonTagsForPokemonOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                ERROR_POKEMON_NOT_FOUND = 3,
                ERROR_TAG_INVALID = 4
            }
        }

        interface ISetPokemonTagsForPokemonProto {
            tag_changes?: (POGOProtos.Rpc.SetPokemonTagsForPokemonProto.IPokemonTagChangeProto[]|null);
        }

        class SetPokemonTagsForPokemonProto implements ISetPokemonTagsForPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ISetPokemonTagsForPokemonProto);
            public tag_changes: POGOProtos.Rpc.SetPokemonTagsForPokemonProto.IPokemonTagChangeProto[];
            public static encode(message: POGOProtos.Rpc.ISetPokemonTagsForPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPokemonTagsForPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPokemonTagsForPokemonProto;
            public static toObject(message: POGOProtos.Rpc.SetPokemonTagsForPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SetPokemonTagsForPokemonProto {

            interface IPokemonTagChangeProto {
                pokemon_id?: (number|Long|null);
                tags_to_add?: ((number|Long)[]|null);
                tags_to_remove?: ((number|Long)[]|null);
            }

            class PokemonTagChangeProto implements IPokemonTagChangeProto {
                constructor(properties?: POGOProtos.Rpc.SetPokemonTagsForPokemonProto.IPokemonTagChangeProto);
                public pokemon_id: (number|Long);
                public tags_to_add: (number|Long)[];
                public tags_to_remove: (number|Long)[];
                public static encode(message: POGOProtos.Rpc.SetPokemonTagsForPokemonProto.IPokemonTagChangeProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetPokemonTagsForPokemonProto.PokemonTagChangeProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetPokemonTagsForPokemonProto.PokemonTagChangeProto;
                public static toObject(message: POGOProtos.Rpc.SetPokemonTagsForPokemonProto.PokemonTagChangeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ISetValueRequest {
            key?: (POGOProtos.Rpc.IKey|null);
            value?: (Uint8Array|null);
        }

        class SetValueRequest implements ISetValueRequest {
            constructor(properties?: POGOProtos.Rpc.ISetValueRequest);
            public key?: (POGOProtos.Rpc.IKey|null);
            public value: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISetValueRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetValueRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetValueRequest;
            public static toObject(message: POGOProtos.Rpc.SetValueRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISetValueResponse {
            version?: (number|null);
        }

        class SetValueResponse implements ISetValueResponse {
            constructor(properties?: POGOProtos.Rpc.ISetValueResponse);
            public version: number;
            public static encode(message: POGOProtos.Rpc.ISetValueResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SetValueResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SetValueResponse;
            public static toObject(message: POGOProtos.Rpc.SetValueResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISettingsOverrideRuleProto {
            rule_type?: (POGOProtos.Rpc.SettingsOverrideRuleProto.RuleType|null);
            sort_order?: (number|null);
            rule_value?: (string|null);
            meshing_enabled?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
            occlusion_enabled?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
            occlusion_default_on?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
            semantics_enabled?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
            fused_depth_enabled?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
            meshing_max_distance_m?: (number|null);
            meshing_voxel_size_m?: (number|null);
            occlusion_frame_rate?: (number|null);
            meshing_frame_rate?: (number|null);
            semantics_frame_rate?: (number|null);
            force_disable_last_pokemon_caught?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
            vps_enabled?: (POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus|null);
        }

        class SettingsOverrideRuleProto implements ISettingsOverrideRuleProto {
            constructor(properties?: POGOProtos.Rpc.ISettingsOverrideRuleProto);
            public rule_type: POGOProtos.Rpc.SettingsOverrideRuleProto.RuleType;
            public sort_order: number;
            public rule_value: string;
            public meshing_enabled: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public occlusion_enabled: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public occlusion_default_on: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public semantics_enabled: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public fused_depth_enabled: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public meshing_max_distance_m: number;
            public meshing_voxel_size_m: number;
            public occlusion_frame_rate: number;
            public meshing_frame_rate: number;
            public semantics_frame_rate: number;
            public force_disable_last_pokemon_caught: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public vps_enabled: POGOProtos.Rpc.SettingsOverrideRuleProto.OcclusionStatus;
            public static encode(message: POGOProtos.Rpc.ISettingsOverrideRuleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SettingsOverrideRuleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SettingsOverrideRuleProto;
            public static toObject(message: POGOProtos.Rpc.SettingsOverrideRuleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SettingsOverrideRuleProto {

            enum OcclusionStatus {
                NULL = 0,
                TRUE = 1,
                FALSE = 2
            }

            enum RuleType {
                UNSET = 0,
                ALL = 1,
                UNITY_VERSION_GREATER = 2,
                UNITY_VERSION_LESS = 3,
                APP_VERSION_GREATER = 4,
                APP_VERSION_LESS = 5,
                PLATFORM = 6,
                IOS_VERSION_GREATER = 7,
                IOS_VERSION_LESS = 8,
                IOS_VERSION = 9,
                ANDROID_VERSION_GREATER = 10,
                ANDROID_VERSION_LESS = 11,
                ANDROID_VERSION = 12,
                MEMORY_GREATER = 13,
                MEMORY_LESS = 14,
                HAS_IOS_LIDAR = 15,
                GPU_DEVICE_NAME = 16,
                DEVICE_MODEL_CONTAINS = 17,
                DEVICE_MODEL = 18
            }
        }

        interface ISettingsVersionControllerProto {
            v2_enabled?: (boolean|null);
        }

        class SettingsVersionControllerProto implements ISettingsVersionControllerProto {
            constructor(properties?: POGOProtos.Rpc.ISettingsVersionControllerProto);
            public v2_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ISettingsVersionControllerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SettingsVersionControllerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SettingsVersionControllerProto;
            public static toObject(message: POGOProtos.Rpc.SettingsVersionControllerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaAssociateRequest {
            bt_address?: (Uint8Array|null);
            pairing_code?: (number|null);
            bt_signature?: (Uint8Array|null);
        }

        class SfidaAssociateRequest implements ISfidaAssociateRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaAssociateRequest);
            public bt_address: Uint8Array;
            public pairing_code: number;
            public bt_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISfidaAssociateRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaAssociateRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaAssociateRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaAssociateRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaAssociateResponse {
            status?: (POGOProtos.Rpc.SfidaAssociateResponse.Status|null);
        }

        class SfidaAssociateResponse implements ISfidaAssociateResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaAssociateResponse);
            public status: POGOProtos.Rpc.SfidaAssociateResponse.Status;
            public static encode(message: POGOProtos.Rpc.ISfidaAssociateResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaAssociateResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaAssociateResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaAssociateResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaAssociateResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ISfidaAuthToken {
            response_token?: (Uint8Array|null);
            sfida_id?: (string|null);
        }

        class SfidaAuthToken implements ISfidaAuthToken {
            constructor(properties?: POGOProtos.Rpc.ISfidaAuthToken);
            public response_token: Uint8Array;
            public sfida_id: string;
            public static encode(message: POGOProtos.Rpc.ISfidaAuthToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaAuthToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaAuthToken;
            public static toObject(message: POGOProtos.Rpc.SfidaAuthToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaCaptureRequest {
            spawnpoint_id?: (string|null);
            encounter_id?: (number|Long|null);
            player_lat?: (number|null);
            player_lng?: (number|null);
            encounter_type?: (POGOProtos.Rpc.EncounterType|null);
            gym_lat?: (number|null);
            gym_lng?: (number|null);
        }

        class SfidaCaptureRequest implements ISfidaCaptureRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaCaptureRequest);
            public spawnpoint_id: string;
            public encounter_id: (number|Long);
            public player_lat: number;
            public player_lng: number;
            public encounter_type: POGOProtos.Rpc.EncounterType;
            public gym_lat: number;
            public gym_lng: number;
            public static encode(message: POGOProtos.Rpc.ISfidaCaptureRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaCaptureRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaCaptureRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaCaptureRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaCaptureResponse {
            result?: (POGOProtos.Rpc.SfidaCaptureResponse.Result|null);
            xp_gain?: (number|null);
        }

        class SfidaCaptureResponse implements ISfidaCaptureResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaCaptureResponse);
            public result: POGOProtos.Rpc.SfidaCaptureResponse.Result;
            public xp_gain: number;
            public static encode(message: POGOProtos.Rpc.ISfidaCaptureResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaCaptureResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaCaptureResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaCaptureResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaCaptureResponse {

            enum Result {
                UNSET = 0,
                POKEMON_CAPTURED = 1,
                POKEMON_FLED = 2,
                NOT_FOUND = 3,
                NO_MORE_POKEBALLS = 4,
                POKEMON_INVENTORY_FULL = 5,
                NOT_IN_RANGE = 6,
                ENCOUNTER_ALREADY_FINISHED = 7
            }
        }

        interface ISfidaCertificationRequest {
            stage?: (POGOProtos.Rpc.SfidaCertificationRequest.SfidaCertificationStage|null);
            payload?: (Uint8Array|null);
        }

        class SfidaCertificationRequest implements ISfidaCertificationRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaCertificationRequest);
            public stage: POGOProtos.Rpc.SfidaCertificationRequest.SfidaCertificationStage;
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISfidaCertificationRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaCertificationRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaCertificationRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaCertificationRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaCertificationRequest {

            enum SfidaCertificationStage {
                UNSET = 0,
                STAGE1 = 1,
                STAGE2 = 2,
                STAGE3 = 3
            }
        }

        interface ISfidaCertificationResponse {
            payload?: (Uint8Array|null);
        }

        class SfidaCertificationResponse implements ISfidaCertificationResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaCertificationResponse);
            public payload: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISfidaCertificationResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaCertificationResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaCertificationResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaCertificationResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaCheckPairingRequest {
            bt_address?: (Uint8Array|null);
            pairing_code?: (number|null);
            bt_signature?: (Uint8Array|null);
        }

        class SfidaCheckPairingRequest implements ISfidaCheckPairingRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaCheckPairingRequest);
            public bt_address: Uint8Array;
            public pairing_code: number;
            public bt_signature: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ISfidaCheckPairingRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaCheckPairingRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaCheckPairingRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaCheckPairingRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaCheckPairingResponse {
            status?: (POGOProtos.Rpc.SfidaCheckPairingResponse.Status|null);
        }

        class SfidaCheckPairingResponse implements ISfidaCheckPairingResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaCheckPairingResponse);
            public status: POGOProtos.Rpc.SfidaCheckPairingResponse.Status;
            public static encode(message: POGOProtos.Rpc.ISfidaCheckPairingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaCheckPairingResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaCheckPairingResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaCheckPairingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaCheckPairingResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PAIRING = 2,
                ERROR_UNKNOWN = 3
            }
        }

        interface ISfidaClearSleepRecordsRequest {
        }

        class SfidaClearSleepRecordsRequest implements ISfidaClearSleepRecordsRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaClearSleepRecordsRequest);
            public static encode(message: POGOProtos.Rpc.ISfidaClearSleepRecordsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaClearSleepRecordsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaClearSleepRecordsRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaClearSleepRecordsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaClearSleepRecordsResponse {
            status?: (POGOProtos.Rpc.SfidaClearSleepRecordsResponse.Status|null);
        }

        class SfidaClearSleepRecordsResponse implements ISfidaClearSleepRecordsResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaClearSleepRecordsResponse);
            public status: POGOProtos.Rpc.SfidaClearSleepRecordsResponse.Status;
            public static encode(message: POGOProtos.Rpc.ISfidaClearSleepRecordsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaClearSleepRecordsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaClearSleepRecordsResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaClearSleepRecordsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaClearSleepRecordsResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ISfidaDisassociateRequest {
            bt_address?: (string|null);
        }

        class SfidaDisassociateRequest implements ISfidaDisassociateRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaDisassociateRequest);
            public bt_address: string;
            public static encode(message: POGOProtos.Rpc.ISfidaDisassociateRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaDisassociateRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaDisassociateRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaDisassociateRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaDisassociateResponse {
            status?: (POGOProtos.Rpc.SfidaDisassociateResponse.Status|null);
        }

        class SfidaDisassociateResponse implements ISfidaDisassociateResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaDisassociateResponse);
            public status: POGOProtos.Rpc.SfidaDisassociateResponse.Status;
            public static encode(message: POGOProtos.Rpc.ISfidaDisassociateResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaDisassociateResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaDisassociateResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaDisassociateResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaDisassociateResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ISfidaDowserRequest {
            encounter_id?: (number|Long|null);
        }

        class SfidaDowserRequest implements ISfidaDowserRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaDowserRequest);
            public encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISfidaDowserRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaDowserRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaDowserRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaDowserRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaDowserResponse {
            result?: (POGOProtos.Rpc.SfidaDowserResponse.Result|null);
            proximity?: (number|null);
            spawnpoint_id?: (string|null);
        }

        class SfidaDowserResponse implements ISfidaDowserResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaDowserResponse);
            public result: POGOProtos.Rpc.SfidaDowserResponse.Result;
            public proximity: number;
            public spawnpoint_id: string;
            public static encode(message: POGOProtos.Rpc.ISfidaDowserResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaDowserResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaDowserResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaDowserResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaDowserResponse {

            enum Result {
                UNSET = 0,
                FOUND = 1,
                NEARBY = 2,
                OUT_OF_RANGE = 3,
                ALREADY_CAUGHT = 4,
                NOT_AVAILABLE = 5
            }
        }

        interface ISfidaGlobalSettingsProto {
            low_battery_threshold?: (number|null);
            waina_enabled?: (boolean|null);
            connect_version?: (number|null);
        }

        class SfidaGlobalSettingsProto implements ISfidaGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISfidaGlobalSettingsProto);
            public low_battery_threshold: number;
            public waina_enabled: boolean;
            public connect_version: number;
            public static encode(message: POGOProtos.Rpc.ISfidaGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SfidaGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaMetrics {
            distance_walked_km?: (number|null);
            step_count?: (number|null);
            calories_burned?: (number|null);
            exercise_time_ms?: (number|Long|null);
        }

        class SfidaMetrics implements ISfidaMetrics {
            constructor(properties?: POGOProtos.Rpc.ISfidaMetrics);
            public distance_walked_km: number;
            public step_count: number;
            public calories_burned: number;
            public exercise_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISfidaMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaMetrics;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaMetrics;
            public static toObject(message: POGOProtos.Rpc.SfidaMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaMetricsUpdate {
            update_type?: (POGOProtos.Rpc.SfidaMetricsUpdate.UpdateType|null);
            timestamp_ms?: (number|Long|null);
            metrics?: (POGOProtos.Rpc.ISfidaMetrics|null);
        }

        class SfidaMetricsUpdate implements ISfidaMetricsUpdate {
            constructor(properties?: POGOProtos.Rpc.ISfidaMetricsUpdate);
            public update_type: POGOProtos.Rpc.SfidaMetricsUpdate.UpdateType;
            public timestamp_ms: (number|Long);
            public metrics?: (POGOProtos.Rpc.ISfidaMetrics|null);
            public static encode(message: POGOProtos.Rpc.ISfidaMetricsUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaMetricsUpdate;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaMetricsUpdate;
            public static toObject(message: POGOProtos.Rpc.SfidaMetricsUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaMetricsUpdate {

            enum UpdateType {
                UNSET = 0,
                INITIALIZATION = 1,
                ACCUMULATION = 2
            }
        }

        interface ISfidaUpdateRequest {
            player_lat?: (number|null);
            player_lng?: (number|null);
        }

        class SfidaUpdateRequest implements ISfidaUpdateRequest {
            constructor(properties?: POGOProtos.Rpc.ISfidaUpdateRequest);
            public player_lat: number;
            public player_lng: number;
            public static encode(message: POGOProtos.Rpc.ISfidaUpdateRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaUpdateRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaUpdateRequest;
            public static toObject(message: POGOProtos.Rpc.SfidaUpdateRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISfidaUpdateResponse {
            status?: (POGOProtos.Rpc.SfidaUpdateResponse.Status|null);
            nearby_pokemon?: (boolean|null);
            uncaught_pokemon?: (boolean|null);
            legendary_pokemon?: (boolean|null);
            spawnpoint_id?: (string|null);
            encounter_id?: (number|Long|null);
            nearby_pokestop?: (boolean|null);
            pokestop_id?: (string|null);
            encounter_type?: (POGOProtos.Rpc.EncounterType|null);
            pokedex_number?: (number|null);
            autospin?: (boolean|null);
            autocatch?: (boolean|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
        }

        class SfidaUpdateResponse implements ISfidaUpdateResponse {
            constructor(properties?: POGOProtos.Rpc.ISfidaUpdateResponse);
            public status: POGOProtos.Rpc.SfidaUpdateResponse.Status;
            public nearby_pokemon: boolean;
            public uncaught_pokemon: boolean;
            public legendary_pokemon: boolean;
            public spawnpoint_id: string;
            public encounter_id: (number|Long);
            public nearby_pokestop: boolean;
            public pokestop_id: string;
            public encounter_type: POGOProtos.Rpc.EncounterType;
            public pokedex_number: number;
            public autospin: boolean;
            public autocatch: boolean;
            public fort_lat: number;
            public fort_lng: number;
            public static encode(message: POGOProtos.Rpc.ISfidaUpdateResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SfidaUpdateResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SfidaUpdateResponse;
            public static toObject(message: POGOProtos.Rpc.SfidaUpdateResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SfidaUpdateResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IShadowAttributesProto {
            purification_stardust_needed?: (number|null);
            purification_candy_needed?: (number|null);
            purified_charge_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
            shadow_charge_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class ShadowAttributesProto implements IShadowAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IShadowAttributesProto);
            public purification_stardust_needed: number;
            public purification_candy_needed: number;
            public purified_charge_move: POGOProtos.Rpc.HoloPokemonMove;
            public shadow_charge_move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IShadowAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShadowAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShadowAttributesProto;
            public static toObject(message: POGOProtos.Rpc.ShadowAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IShapeCollectionProto {
        }

        class ShapeCollectionProto implements IShapeCollectionProto {
            constructor(properties?: POGOProtos.Rpc.IShapeCollectionProto);
            public static encode(message: POGOProtos.Rpc.IShapeCollectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShapeCollectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShapeCollectionProto;
            public static toObject(message: POGOProtos.Rpc.ShapeCollectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IShapeProto {
            point?: (POGOProtos.Rpc.IPointProto|null);
            rect?: (POGOProtos.Rpc.IRectProto|null);
            cap?: (POGOProtos.Rpc.ICapProto|null);
            covering?: (POGOProtos.Rpc.ICoveringProto|null);
            line?: (POGOProtos.Rpc.ILineProto|null);
            polygon?: (POGOProtos.Rpc.IPolygonProto|null);
            collection?: (POGOProtos.Rpc.IShapeCollectionProto|null);
        }

        class ShapeProto implements IShapeProto {
            constructor(properties?: POGOProtos.Rpc.IShapeProto);
            public point?: (POGOProtos.Rpc.IPointProto|null);
            public rect?: (POGOProtos.Rpc.IRectProto|null);
            public cap?: (POGOProtos.Rpc.ICapProto|null);
            public covering?: (POGOProtos.Rpc.ICoveringProto|null);
            public line?: (POGOProtos.Rpc.ILineProto|null);
            public polygon?: (POGOProtos.Rpc.IPolygonProto|null);
            public collection?: (POGOProtos.Rpc.IShapeCollectionProto|null);
            public static encode(message: POGOProtos.Rpc.IShapeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShapeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShapeProto;
            public static toObject(message: POGOProtos.Rpc.ShapeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IShardManagerEchoOutProto {
            result?: (POGOProtos.Rpc.ShardManagerEchoOutProto.Result|null);
            response?: (string|null);
            debug_output?: (string|null);
            pod_name?: (string|null);
        }

        class ShardManagerEchoOutProto implements IShardManagerEchoOutProto {
            constructor(properties?: POGOProtos.Rpc.IShardManagerEchoOutProto);
            public result: POGOProtos.Rpc.ShardManagerEchoOutProto.Result;
            public response: string;
            public debug_output: string;
            public pod_name: string;
            public static encode(message: POGOProtos.Rpc.IShardManagerEchoOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShardManagerEchoOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShardManagerEchoOutProto;
            public static toObject(message: POGOProtos.Rpc.ShardManagerEchoOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ShardManagerEchoOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IShardManagerEchoProto {
            message?: (string|null);
            is_multi_player?: (boolean|null);
            session_id?: (string|null);
            session_start_timestamp?: (number|Long|null);
            enable_debug_output?: (boolean|null);
            create_session?: (boolean|null);
        }

        class ShardManagerEchoProto implements IShardManagerEchoProto {
            constructor(properties?: POGOProtos.Rpc.IShardManagerEchoProto);
            public message: string;
            public is_multi_player: boolean;
            public session_id: string;
            public session_start_timestamp: (number|Long);
            public enable_debug_output: boolean;
            public create_session: boolean;
            public static encode(message: POGOProtos.Rpc.IShardManagerEchoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShardManagerEchoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShardManagerEchoProto;
            public static toObject(message: POGOProtos.Rpc.ShardManagerEchoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISharedFusionSettingsProto {
            fusion_enabled?: (boolean|null);
        }

        class SharedFusionSettingsProto implements ISharedFusionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISharedFusionSettingsProto);
            public fusion_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ISharedFusionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SharedFusionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SharedFusionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SharedFusionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISharedMoveSettingsProto {
            shadow_third_move_unlock_stardust_multiplier?: (number|null);
            shadow_third_move_unlock_candy_multiplier?: (number|null);
            purified_third_move_unlock_stardust_multiplier?: (number|null);
            purified_third_move_unlock_candy_multiplier?: (number|null);
            reroll_move_update_fusion_details_enabled?: (boolean|null);
        }

        class SharedMoveSettingsProto implements ISharedMoveSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISharedMoveSettingsProto);
            public shadow_third_move_unlock_stardust_multiplier: number;
            public shadow_third_move_unlock_candy_multiplier: number;
            public purified_third_move_unlock_stardust_multiplier: number;
            public purified_third_move_unlock_candy_multiplier: number;
            public reroll_move_update_fusion_details_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ISharedMoveSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SharedMoveSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SharedMoveSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SharedMoveSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISharedRouteProto {
            id?: (string|null);
            waypoints?: (POGOProtos.Rpc.IRouteWaypointProto[]|null);
            type?: (POGOProtos.Rpc.RouteType|null);
            path_type?: (POGOProtos.Rpc.PathType|null);
            name?: (string|null);
            version?: (number|Long|null);
            description?: (string|null);
            creator_info?: (POGOProtos.Rpc.ICreatorInfo|null);
            reversible?: (boolean|null);
            submission_time?: (number|Long|null);
            route_distance_meters?: (number|Long|null);
            route_duration_seconds?: (number|Long|null);
            pins?: (POGOProtos.Rpc.IRoutePin[]|null);
            tags?: (string[]|null);
            sponsor_metadata?: (POGOProtos.Rpc.ISponsoredDetailsProto|null);
            incline_type?: (POGOProtos.Rpc.RouteInclineType|null);
            aggregated_stats?: (POGOProtos.Rpc.IRouteStats|null);
            player_stats?: (POGOProtos.Rpc.IPlayerRouteStats|null);
            image?: (POGOProtos.Rpc.IRouteImageProto|null);
            route_submission_status?: (POGOProtos.Rpc.IRouteSubmissionStatus[]|null);
            start_poi?: (POGOProtos.Rpc.IRoutePoiAnchor|null);
            end_poi?: (POGOProtos.Rpc.IRoutePoiAnchor|null);
            s2_ground_cells?: ((number|Long)[]|null);
            edit_count?: (number|Long|null);
            editable_post_rejection?: (boolean|null);
            last_edit_time_ms?: (number|Long|null);
            submission_count?: (number|Long|null);
            short_code?: (string|null);
        }

        class SharedRouteProto implements ISharedRouteProto {
            constructor(properties?: POGOProtos.Rpc.ISharedRouteProto);
            public id: string;
            public waypoints: POGOProtos.Rpc.IRouteWaypointProto[];
            public type: POGOProtos.Rpc.RouteType;
            public path_type: POGOProtos.Rpc.PathType;
            public name: string;
            public version: (number|Long);
            public description: string;
            public creator_info?: (POGOProtos.Rpc.ICreatorInfo|null);
            public reversible: boolean;
            public submission_time: (number|Long);
            public route_distance_meters: (number|Long);
            public route_duration_seconds: (number|Long);
            public pins: POGOProtos.Rpc.IRoutePin[];
            public tags: string[];
            public sponsor_metadata?: (POGOProtos.Rpc.ISponsoredDetailsProto|null);
            public incline_type: POGOProtos.Rpc.RouteInclineType;
            public aggregated_stats?: (POGOProtos.Rpc.IRouteStats|null);
            public player_stats?: (POGOProtos.Rpc.IPlayerRouteStats|null);
            public image?: (POGOProtos.Rpc.IRouteImageProto|null);
            public route_submission_status: POGOProtos.Rpc.IRouteSubmissionStatus[];
            public start_poi?: (POGOProtos.Rpc.IRoutePoiAnchor|null);
            public end_poi?: (POGOProtos.Rpc.IRoutePoiAnchor|null);
            public s2_ground_cells: (number|Long)[];
            public edit_count: (number|Long);
            public editable_post_rejection: boolean;
            public last_edit_time_ms: (number|Long);
            public submission_count: (number|Long);
            public short_code: string;
            public static encode(message: POGOProtos.Rpc.ISharedRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SharedRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SharedRouteProto;
            public static toObject(message: POGOProtos.Rpc.SharedRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IShoppingPageClickTelemetry {
            shopping_page_click_id?: (POGOProtos.Rpc.ShoppingPageTelemetryIds|null);
            shopping_page_click_source?: (POGOProtos.Rpc.ShoppingPageTelemetrySource|null);
            item_sku?: (string|null);
            has_item?: (boolean|null);
            ml_bundle_tracking_id?: (string|null);
            available_sku?: (POGOProtos.Rpc.ShoppingPageClickTelemetry.IVisibleSku[]|null);
            enabled_banners?: (POGOProtos.Rpc.ShoppingPageClickTelemetry.IStoreBannerTelemetry[]|null);
            has_banner?: (boolean|null);
            banner_template_id_clicked?: (string|null);
        }

        class ShoppingPageClickTelemetry implements IShoppingPageClickTelemetry {
            constructor(properties?: POGOProtos.Rpc.IShoppingPageClickTelemetry);
            public shopping_page_click_id: POGOProtos.Rpc.ShoppingPageTelemetryIds;
            public shopping_page_click_source: POGOProtos.Rpc.ShoppingPageTelemetrySource;
            public item_sku: string;
            public has_item: boolean;
            public ml_bundle_tracking_id: string;
            public available_sku: POGOProtos.Rpc.ShoppingPageClickTelemetry.IVisibleSku[];
            public enabled_banners: POGOProtos.Rpc.ShoppingPageClickTelemetry.IStoreBannerTelemetry[];
            public has_banner: boolean;
            public banner_template_id_clicked: string;
            public static encode(message: POGOProtos.Rpc.IShoppingPageClickTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShoppingPageClickTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShoppingPageClickTelemetry;
            public static toObject(message: POGOProtos.Rpc.ShoppingPageClickTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ShoppingPageClickTelemetry {

            interface IStoreBannerTelemetry {
                template_id?: (string|null);
                category?: (string|null);
                tag_string_key?: (string|null);
                title_string_key?: (string|null);
                banner_click_url?: (string|null);
                banner_image_address?: (string|null);
                position_in_category?: (string|null);
            }

            class StoreBannerTelemetry implements IStoreBannerTelemetry {
                constructor(properties?: POGOProtos.Rpc.ShoppingPageClickTelemetry.IStoreBannerTelemetry);
                public template_id: string;
                public category: string;
                public tag_string_key: string;
                public title_string_key: string;
                public banner_click_url: string;
                public banner_image_address: string;
                public position_in_category: string;
                public static encode(message: POGOProtos.Rpc.ShoppingPageClickTelemetry.IStoreBannerTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShoppingPageClickTelemetry.StoreBannerTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShoppingPageClickTelemetry.StoreBannerTelemetry;
                public static toObject(message: POGOProtos.Rpc.ShoppingPageClickTelemetry.StoreBannerTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IVisibleSku {
                sku_name?: (string|null);
                content?: (POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.INestedSkuContent[]|null);
            }

            class VisibleSku implements IVisibleSku {
                constructor(properties?: POGOProtos.Rpc.ShoppingPageClickTelemetry.IVisibleSku);
                public sku_name: string;
                public content: POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.INestedSkuContent[];
                public static encode(message: POGOProtos.Rpc.ShoppingPageClickTelemetry.IVisibleSku, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku;
                public static toObject(message: POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace VisibleSku {

                interface INestedSkuContent {
                    item_name?: (string|null);
                    item_count?: (number|null);
                }

                class NestedSkuContent implements INestedSkuContent {
                    constructor(properties?: POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.INestedSkuContent);
                    public item_name: string;
                    public item_count: number;
                    public static encode(message: POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.INestedSkuContent, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.NestedSkuContent;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.NestedSkuContent;
                    public static toObject(message: POGOProtos.Rpc.ShoppingPageClickTelemetry.VisibleSku.NestedSkuContent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IShoppingPageScrollTelemetry {
            scroll_type?: (POGOProtos.Rpc.ShoppingPageScrollIds|null);
            scroll_row?: (number|null);
            total_rows?: (number|null);
        }

        class ShoppingPageScrollTelemetry implements IShoppingPageScrollTelemetry {
            constructor(properties?: POGOProtos.Rpc.IShoppingPageScrollTelemetry);
            public scroll_type: POGOProtos.Rpc.ShoppingPageScrollIds;
            public scroll_row: number;
            public total_rows: number;
            public static encode(message: POGOProtos.Rpc.IShoppingPageScrollTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShoppingPageScrollTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShoppingPageScrollTelemetry;
            public static toObject(message: POGOProtos.Rpc.ShoppingPageScrollTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IShoppingPageTelemetry {
            shopping_page_click_id?: (POGOProtos.Rpc.ShoppingPageTelemetryIds|null);
        }

        class ShoppingPageTelemetry implements IShoppingPageTelemetry {
            constructor(properties?: POGOProtos.Rpc.IShoppingPageTelemetry);
            public shopping_page_click_id: POGOProtos.Rpc.ShoppingPageTelemetryIds;
            public static encode(message: POGOProtos.Rpc.IShoppingPageTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShoppingPageTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShoppingPageTelemetry;
            public static toObject(message: POGOProtos.Rpc.ShoppingPageTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IShowcaseDetailsTelemetry {
            player_action?: (POGOProtos.Rpc.ShowcaseDetailsTelemetry.ActionTaken|null);
            entry_point?: (POGOProtos.Rpc.ShowcaseDetailsTelemetry.EntryPoint|null);
            showcase_id?: (string|null);
            entry_barrier?: (POGOProtos.Rpc.ShowcaseDetailsTelemetry.EntryBarrier|null);
            was_already_entered?: (boolean|null);
        }

        class ShowcaseDetailsTelemetry implements IShowcaseDetailsTelemetry {
            constructor(properties?: POGOProtos.Rpc.IShowcaseDetailsTelemetry);
            public player_action: POGOProtos.Rpc.ShowcaseDetailsTelemetry.ActionTaken;
            public entry_point: POGOProtos.Rpc.ShowcaseDetailsTelemetry.EntryPoint;
            public showcase_id: string;
            public entry_barrier: POGOProtos.Rpc.ShowcaseDetailsTelemetry.EntryBarrier;
            public was_already_entered: boolean;
            public static encode(message: POGOProtos.Rpc.IShowcaseDetailsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShowcaseDetailsTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShowcaseDetailsTelemetry;
            public static toObject(message: POGOProtos.Rpc.ShowcaseDetailsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ShowcaseDetailsTelemetry {

            enum ActionTaken {
                UNSET = 0,
                VIEW_CONTEST_DETAILS = 1,
                VIEW_ALL_ENTRANTS = 2
            }

            enum EntryBarrier {
                UNSET_BARRIER = 0,
                ENTERED_MAX_CONTESTS = 1,
                CONTEST_FULL = 2,
                NO_ELIGIBLE_POKEMON = 3,
                OUT_OF_RANGE = 4,
                NONE = 5
            }

            enum EntryPoint {
                UNSET_ENTRY = 0,
                POKESTOP = 1,
                TODAY_VIEW_WIDGET = 2
            }
        }

        interface IShowcaseRewardTelemetry {
            player_shared_photo?: (boolean|null);
        }

        class ShowcaseRewardTelemetry implements IShowcaseRewardTelemetry {
            constructor(properties?: POGOProtos.Rpc.IShowcaseRewardTelemetry);
            public player_shared_photo: boolean;
            public static encode(message: POGOProtos.Rpc.IShowcaseRewardTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ShowcaseRewardTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ShowcaseRewardTelemetry;
            public static toObject(message: POGOProtos.Rpc.ShowcaseRewardTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISillouetteObfuscationGroup {
            group_number?: (number|null);
            override_display_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class SillouetteObfuscationGroup implements ISillouetteObfuscationGroup {
            constructor(properties?: POGOProtos.Rpc.ISillouetteObfuscationGroup);
            public group_number: number;
            public override_display_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.ISillouetteObfuscationGroup, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SillouetteObfuscationGroup;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SillouetteObfuscationGroup;
            public static toObject(message: POGOProtos.Rpc.SillouetteObfuscationGroup, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISizeRecordBreakTelemetry {
            record_break_type?: (POGOProtos.Rpc.SizeRecordBreakTelemetry.RecordBreakType|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            height_m?: (number|null);
            weight_kg?: (number|null);
            is_height_record?: (boolean|null);
            is_weight_record?: (boolean|null);
        }

        class SizeRecordBreakTelemetry implements ISizeRecordBreakTelemetry {
            constructor(properties?: POGOProtos.Rpc.ISizeRecordBreakTelemetry);
            public record_break_type: POGOProtos.Rpc.SizeRecordBreakTelemetry.RecordBreakType;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public height_m: number;
            public weight_kg: number;
            public is_height_record: boolean;
            public is_weight_record: boolean;
            public static encode(message: POGOProtos.Rpc.ISizeRecordBreakTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SizeRecordBreakTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SizeRecordBreakTelemetry;
            public static toObject(message: POGOProtos.Rpc.SizeRecordBreakTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SizeRecordBreakTelemetry {

            enum RecordBreakType {
                RECORD_BREAK_UNSET = 0,
                RECORD_BREAK_XXS = 1,
                RECORD_BREAK_XS = 2,
                RECORD_BREAK_M = 3,
                RECORD_BREAK_XL = 4,
                RECORD_BREAK_XXL = 5
            }
        }

        interface ISkipEnterReferralCodeOutProto {
            status?: (POGOProtos.Rpc.SkipEnterReferralCodeOutProto.Status|null);
        }

        class SkipEnterReferralCodeOutProto implements ISkipEnterReferralCodeOutProto {
            constructor(properties?: POGOProtos.Rpc.ISkipEnterReferralCodeOutProto);
            public status: POGOProtos.Rpc.SkipEnterReferralCodeOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ISkipEnterReferralCodeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SkipEnterReferralCodeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SkipEnterReferralCodeOutProto;
            public static toObject(message: POGOProtos.Rpc.SkipEnterReferralCodeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SkipEnterReferralCodeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_DISABLED = 2
            }
        }

        interface ISkipEnterReferralCodeProto {
        }

        class SkipEnterReferralCodeProto implements ISkipEnterReferralCodeProto {
            constructor(properties?: POGOProtos.Rpc.ISkipEnterReferralCodeProto);
            public static encode(message: POGOProtos.Rpc.ISkipEnterReferralCodeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SkipEnterReferralCodeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SkipEnterReferralCodeProto;
            public static toObject(message: POGOProtos.Rpc.SkipEnterReferralCodeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISleepDayRecordProto {
            sleep_day?: (number|null);
            sleep_duration_sec?: (number|null);
            rewarded?: (boolean|null);
            start_time_sec?: (number[]|null);
        }

        class SleepDayRecordProto implements ISleepDayRecordProto {
            constructor(properties?: POGOProtos.Rpc.ISleepDayRecordProto);
            public sleep_day: number;
            public sleep_duration_sec: number;
            public rewarded: boolean;
            public start_time_sec: number[];
            public static encode(message: POGOProtos.Rpc.ISleepDayRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SleepDayRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SleepDayRecordProto;
            public static toObject(message: POGOProtos.Rpc.SleepDayRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISleepRecordsProto {
            sleep_record?: (POGOProtos.Rpc.ISleepDayRecordProto[]|null);
            sleep_record_last_update_ms?: (number|Long|null);
        }

        class SleepRecordsProto implements ISleepRecordsProto {
            constructor(properties?: POGOProtos.Rpc.ISleepRecordsProto);
            public sleep_record: POGOProtos.Rpc.ISleepDayRecordProto[];
            public sleep_record_last_update_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISleepRecordsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SleepRecordsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SleepRecordsProto;
            public static toObject(message: POGOProtos.Rpc.SleepRecordsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISlowFreezePlayerBonusSettingsProto {
            catch_circle_time_scale_override?: (number|null);
            catch_rate_increase_multiplier?: (number|null);
            catch_circle_speed_change_threshold?: (number|null);
            catch_circle_outer_time_scale_override?: (number|null);
        }

        class SlowFreezePlayerBonusSettingsProto implements ISlowFreezePlayerBonusSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISlowFreezePlayerBonusSettingsProto);
            public catch_circle_time_scale_override: number;
            public catch_rate_increase_multiplier: number;
            public catch_circle_speed_change_threshold: number;
            public catch_circle_outer_time_scale_override: number;
            public static encode(message: POGOProtos.Rpc.ISlowFreezePlayerBonusSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SlowFreezePlayerBonusSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SlowFreezePlayerBonusSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SlowFreezePlayerBonusSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISmartGlassesFeatureFlagProto {
            version?: (number|null);
        }

        class SmartGlassesFeatureFlagProto implements ISmartGlassesFeatureFlagProto {
            constructor(properties?: POGOProtos.Rpc.ISmartGlassesFeatureFlagProto);
            public version: number;
            public static encode(message: POGOProtos.Rpc.ISmartGlassesFeatureFlagProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SmartGlassesFeatureFlagProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SmartGlassesFeatureFlagProto;
            public static toObject(message: POGOProtos.Rpc.SmartGlassesFeatureFlagProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISmartGlassesSyncSettingsRequestProto {
            manta_connected?: (boolean|null);
        }

        class SmartGlassesSyncSettingsRequestProto implements ISmartGlassesSyncSettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.ISmartGlassesSyncSettingsRequestProto);
            public manta_connected: boolean;
            public static encode(message: POGOProtos.Rpc.ISmartGlassesSyncSettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SmartGlassesSyncSettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SmartGlassesSyncSettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.SmartGlassesSyncSettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISmartGlassesSyncSettingsResponseProto {
            result?: (POGOProtos.Rpc.SmartGlassesSyncSettingsResponseProto.Result|null);
        }

        class SmartGlassesSyncSettingsResponseProto implements ISmartGlassesSyncSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.ISmartGlassesSyncSettingsResponseProto);
            public result: POGOProtos.Rpc.SmartGlassesSyncSettingsResponseProto.Result;
            public static encode(message: POGOProtos.Rpc.ISmartGlassesSyncSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SmartGlassesSyncSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SmartGlassesSyncSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.SmartGlassesSyncSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SmartGlassesSyncSettingsResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ISmeargleMovesSettingsProto {
            quick_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
            cinematic_moves?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
        }

        class SmeargleMovesSettingsProto implements ISmeargleMovesSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISmeargleMovesSettingsProto);
            public quick_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public cinematic_moves: POGOProtos.Rpc.HoloPokemonMove[];
            public static encode(message: POGOProtos.Rpc.ISmeargleMovesSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SmeargleMovesSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SmeargleMovesSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SmeargleMovesSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISocialClientSettingsProto {
            enable_social?: (boolean|null);
            max_friend_details?: (number|null);
            player_level_gate?: (number|null);
            max_friend_nickname_length?: (number|null);
            enable_facebook_friends?: (boolean|null);
            facebook_friend_limit_per_request?: (number|null);
            disable_facebook_friends_opening_prompt?: (boolean|null);
            enable_remote_gifting?: (boolean|null);
            cross_game_social_settings?: (POGOProtos.Rpc.ICrossGameSocialGlobalSettingsProto|null);
            migrate_lucky_data_to_shared?: (boolean|null);
        }

        class SocialClientSettingsProto implements ISocialClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISocialClientSettingsProto);
            public enable_social: boolean;
            public max_friend_details: number;
            public player_level_gate: number;
            public max_friend_nickname_length: number;
            public enable_facebook_friends: boolean;
            public facebook_friend_limit_per_request: number;
            public disable_facebook_friends_opening_prompt: boolean;
            public enable_remote_gifting: boolean;
            public cross_game_social_settings?: (POGOProtos.Rpc.ICrossGameSocialGlobalSettingsProto|null);
            public migrate_lucky_data_to_shared: boolean;
            public static encode(message: POGOProtos.Rpc.ISocialClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SocialClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SocialClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SocialClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISocialGiftCountTelemetry {
            unopened_gift_count?: (number|null);
            unsent_gift_count?: (number|null);
        }

        class SocialGiftCountTelemetry implements ISocialGiftCountTelemetry {
            constructor(properties?: POGOProtos.Rpc.ISocialGiftCountTelemetry);
            public unopened_gift_count: number;
            public unsent_gift_count: number;
            public static encode(message: POGOProtos.Rpc.ISocialGiftCountTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SocialGiftCountTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SocialGiftCountTelemetry;
            public static toObject(message: POGOProtos.Rpc.SocialGiftCountTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISocialInboxLatencyTelemetry {
            latency_ms?: (number|null);
            category?: (string|null);
        }

        class SocialInboxLatencyTelemetry implements ISocialInboxLatencyTelemetry {
            constructor(properties?: POGOProtos.Rpc.ISocialInboxLatencyTelemetry);
            public latency_ms: number;
            public category: string;
            public static encode(message: POGOProtos.Rpc.ISocialInboxLatencyTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SocialInboxLatencyTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SocialInboxLatencyTelemetry;
            public static toObject(message: POGOProtos.Rpc.SocialInboxLatencyTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISocialPlayerSettingsProto {
            disable_last_pokemon_caught?: (boolean|null);
            enable_raid_friend_requests?: (boolean|null);
            enable_party_friend_requests?: (boolean|null);
            disable_lucky_friend_applicator_requests?: (boolean|null);
        }

        class SocialPlayerSettingsProto implements ISocialPlayerSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISocialPlayerSettingsProto);
            public disable_last_pokemon_caught: boolean;
            public enable_raid_friend_requests: boolean;
            public enable_party_friend_requests: boolean;
            public disable_lucky_friend_applicator_requests: boolean;
            public static encode(message: POGOProtos.Rpc.ISocialPlayerSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SocialPlayerSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SocialPlayerSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SocialPlayerSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISocialTelemetry {
            social_click_id?: (POGOProtos.Rpc.SocialTelemetryIds|null);
            pages_scrolled_in_friends_list?: (number|null);
            friend_list_sort_type?: (POGOProtos.Rpc.FriendListSortType|null);
            friend_list_sort_direction?: (POGOProtos.Rpc.FriendListSortDirection|null);
        }

        class SocialTelemetry implements ISocialTelemetry {
            constructor(properties?: POGOProtos.Rpc.ISocialTelemetry);
            public social_click_id: POGOProtos.Rpc.SocialTelemetryIds;
            public pages_scrolled_in_friends_list: number;
            public friend_list_sort_type: POGOProtos.Rpc.FriendListSortType;
            public friend_list_sort_direction: POGOProtos.Rpc.FriendListSortDirection;
            public static encode(message: POGOProtos.Rpc.ISocialTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SocialTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SocialTelemetry;
            public static toObject(message: POGOProtos.Rpc.SocialTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISocketConnectionEvent {
            socket_connected?: (boolean|null);
            session_duration_ms?: (number|Long|null);
        }

        class SocketConnectionEvent implements ISocketConnectionEvent {
            constructor(properties?: POGOProtos.Rpc.ISocketConnectionEvent);
            public socket_connected: boolean;
            public session_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISocketConnectionEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SocketConnectionEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SocketConnectionEvent;
            public static toObject(message: POGOProtos.Rpc.SocketConnectionEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISourceCodeInfo {
        }

        class SourceCodeInfo implements ISourceCodeInfo {
            constructor(properties?: POGOProtos.Rpc.ISourceCodeInfo);
            public static encode(message: POGOProtos.Rpc.ISourceCodeInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SourceCodeInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SourceCodeInfo;
            public static toObject(message: POGOProtos.Rpc.SourceCodeInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SourceCodeInfo {

            interface ILocation {
                leading_comments?: (string|null);
                trailing_comments?: (string|null);
            }

            class Location implements ILocation {
                constructor(properties?: POGOProtos.Rpc.SourceCodeInfo.ILocation);
                public leading_comments: string;
                public trailing_comments: string;
                public static encode(message: POGOProtos.Rpc.SourceCodeInfo.ILocation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SourceCodeInfo.Location;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SourceCodeInfo.Location;
                public static toObject(message: POGOProtos.Rpc.SourceCodeInfo.Location, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ISourceContext {
            file_name?: (string|null);
        }

        class SourceContext implements ISourceContext {
            constructor(properties?: POGOProtos.Rpc.ISourceContext);
            public file_name: string;
            public static encode(message: POGOProtos.Rpc.ISourceContext, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SourceContext;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SourceContext;
            public static toObject(message: POGOProtos.Rpc.SourceContext, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISourdoughMoveMappingProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
            move?: (POGOProtos.Rpc.HoloPokemonMove|null);
            optional_bmove_override?: (POGOProtos.Rpc.IOptionalMoveOverrideProto|null);
            optional_cmove_override?: (POGOProtos.Rpc.IOptionalMoveOverrideProto|null);
        }

        class SourdoughMoveMappingProto implements ISourdoughMoveMappingProto {
            constructor(properties?: POGOProtos.Rpc.ISourdoughMoveMappingProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public move: POGOProtos.Rpc.HoloPokemonMove;
            public optional_bmove_override?: (POGOProtos.Rpc.IOptionalMoveOverrideProto|null);
            public optional_cmove_override?: (POGOProtos.Rpc.IOptionalMoveOverrideProto|null);
            public static encode(message: POGOProtos.Rpc.ISourdoughMoveMappingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SourdoughMoveMappingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SourdoughMoveMappingProto;
            public static toObject(message: POGOProtos.Rpc.SourdoughMoveMappingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISourdoughMoveMappingSettingsProto {
            mappings?: (POGOProtos.Rpc.ISourdoughMoveMappingProto[]|null);
        }

        class SourdoughMoveMappingSettingsProto implements ISourdoughMoveMappingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISourdoughMoveMappingSettingsProto);
            public mappings: POGOProtos.Rpc.ISourdoughMoveMappingProto[];
            public static encode(message: POGOProtos.Rpc.ISourdoughMoveMappingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SourdoughMoveMappingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SourdoughMoveMappingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SourdoughMoveMappingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISouvenirProto {
            souvenir_type_id?: (POGOProtos.Rpc.SouvenirTypeId|null);
            souvenirs_details?: (POGOProtos.Rpc.SouvenirProto.ISouvenirDetails[]|null);
        }

        class SouvenirProto implements ISouvenirProto {
            constructor(properties?: POGOProtos.Rpc.ISouvenirProto);
            public souvenir_type_id: POGOProtos.Rpc.SouvenirTypeId;
            public souvenirs_details: POGOProtos.Rpc.SouvenirProto.ISouvenirDetails[];
            public static encode(message: POGOProtos.Rpc.ISouvenirProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SouvenirProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SouvenirProto;
            public static toObject(message: POGOProtos.Rpc.SouvenirProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SouvenirProto {

            interface ISouvenirDetails {
                time_picked_up?: (number|Long|null);
                latitude?: (number|null);
                longitude?: (number|null);
            }

            class SouvenirDetails implements ISouvenirDetails {
                constructor(properties?: POGOProtos.Rpc.SouvenirProto.ISouvenirDetails);
                public time_picked_up: (number|Long);
                public latitude: number;
                public longitude: number;
                public static encode(message: POGOProtos.Rpc.SouvenirProto.ISouvenirDetails, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SouvenirProto.SouvenirDetails;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SouvenirProto.SouvenirDetails;
                public static toObject(message: POGOProtos.Rpc.SouvenirProto.SouvenirDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ISpaceBonusSettingsProto {
            pokemon_visible_range_meters?: (number|null);
            encounter_range_meters?: (number|null);
            server_allowable_encounter_range_meters?: (number|null);
        }

        class SpaceBonusSettingsProto implements ISpaceBonusSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISpaceBonusSettingsProto);
            public pokemon_visible_range_meters: number;
            public encounter_range_meters: number;
            public server_allowable_encounter_range_meters: number;
            public static encode(message: POGOProtos.Rpc.ISpaceBonusSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SpaceBonusSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SpaceBonusSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SpaceBonusSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISpawnTablePokemonProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            weight?: (number|null);
            form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class SpawnTablePokemonProto implements ISpawnTablePokemonProto {
            constructor(properties?: POGOProtos.Rpc.ISpawnTablePokemonProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public weight: number;
            public form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.ISpawnTablePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SpawnTablePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SpawnTablePokemonProto;
            public static toObject(message: POGOProtos.Rpc.SpawnTablePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISpawnTableTappableProto {
            tappable_type_id?: (string|null);
            weight?: (number|null);
        }

        class SpawnTableTappableProto implements ISpawnTableTappableProto {
            constructor(properties?: POGOProtos.Rpc.ISpawnTableTappableProto);
            public tappable_type_id: string;
            public weight: number;
            public static encode(message: POGOProtos.Rpc.ISpawnTableTappableProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SpawnTableTappableProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SpawnTableTappableProto;
            public static toObject(message: POGOProtos.Rpc.SpawnTableTappableProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISpawnablePokemon {
            status?: (POGOProtos.Rpc.SpawnablePokemon.Status|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            lat?: (number|null);
            lng?: (number|null);
            encounter_id?: (number|Long|null);
            encounter_location?: (string|null);
            disappear_time_ms?: (number|Long|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            type?: (POGOProtos.Rpc.SpawnablePokemon.SpawnableType|null);
            station_id?: (string|null);
        }

        class SpawnablePokemon implements ISpawnablePokemon {
            constructor(properties?: POGOProtos.Rpc.ISpawnablePokemon);
            public status: POGOProtos.Rpc.SpawnablePokemon.Status;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public lat: number;
            public lng: number;
            public encounter_id: (number|Long);
            public encounter_location: string;
            public disappear_time_ms: (number|Long);
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public type: POGOProtos.Rpc.SpawnablePokemon.SpawnableType;
            public station_id: string;
            public static encode(message: POGOProtos.Rpc.ISpawnablePokemon, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SpawnablePokemon;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SpawnablePokemon;
            public static toObject(message: POGOProtos.Rpc.SpawnablePokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SpawnablePokemon {

            enum SpawnableType {
                UNTYPED = 0,
                POKESTOP_ENCOUNTER = 1,
                STATION_SPAWN = 2,
                STAMP_COLLECTION_REWARD = 3
            }

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ENCOUNTER_NOT_AVAILABLE = 2,
                ENCOUNTER_ALREADY_COMPLETED = 3,
                ERROR_UNKNOWN = 4
            }
        }

        interface ISpinPokestopQuestProto {
            fort_ids?: (string[]|null);
        }

        class SpinPokestopQuestProto implements ISpinPokestopQuestProto {
            constructor(properties?: POGOProtos.Rpc.ISpinPokestopQuestProto);
            public fort_ids: string[];
            public static encode(message: POGOProtos.Rpc.ISpinPokestopQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SpinPokestopQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SpinPokestopQuestProto;
            public static toObject(message: POGOProtos.Rpc.SpinPokestopQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISpinPokestopTelemetry {
            result?: (string|null);
            fort_id?: (string|null);
            fort_type?: (number|null);
            pokestop_rewards?: (POGOProtos.Rpc.IPokestopReward[]|null);
            total_rewards?: (number|null);
        }

        class SpinPokestopTelemetry implements ISpinPokestopTelemetry {
            constructor(properties?: POGOProtos.Rpc.ISpinPokestopTelemetry);
            public result: string;
            public fort_id: string;
            public fort_type: number;
            public pokestop_rewards: POGOProtos.Rpc.IPokestopReward[];
            public total_rewards: number;
            public static encode(message: POGOProtos.Rpc.ISpinPokestopTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SpinPokestopTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SpinPokestopTelemetry;
            public static toObject(message: POGOProtos.Rpc.SpinPokestopTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISponsoredDetailsProto {
            promo_image_url?: (string[]|null);
            promo_description?: (string[]|null);
            call_to_action_link?: (string|null);
            promo_button_message_type?: (POGOProtos.Rpc.SponsoredDetailsProto.PromoButtonMessageType|null);
            campaign_id?: (string|null);
            promo_image_creative?: (POGOProtos.Rpc.IImageTextCreativeProto|null);
            impression_tracking_tag?: (POGOProtos.Rpc.IImpressionTrackingTag[]|null);
        }

        class SponsoredDetailsProto implements ISponsoredDetailsProto {
            constructor(properties?: POGOProtos.Rpc.ISponsoredDetailsProto);
            public promo_image_url: string[];
            public promo_description: string[];
            public call_to_action_link: string;
            public promo_button_message_type: POGOProtos.Rpc.SponsoredDetailsProto.PromoButtonMessageType;
            public campaign_id: string;
            public promo_image_creative?: (POGOProtos.Rpc.IImageTextCreativeProto|null);
            public impression_tracking_tag: POGOProtos.Rpc.IImpressionTrackingTag[];
            public static encode(message: POGOProtos.Rpc.ISponsoredDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredDetailsProto;
            public static toObject(message: POGOProtos.Rpc.SponsoredDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SponsoredDetailsProto {

            enum PromoButtonMessageType {
                UNSET = 0,
                LEARN_MORE = 1,
                OFFER = 2
            }
        }

        interface ISponsoredGeofenceGiftSettingsProto {
            gift_persistence_enabled?: (boolean|null);
            gift_persistence_time_ms?: (number|null);
            map_presentation_time_ms?: (number|null);
            enable_sponsored_geofence_gift?: (boolean|null);
            enable_dark_launch?: (boolean|null);
            enable_poi_gift?: (boolean|null);
            enable_raid_gift?: (boolean|null);
            enable_incident_gift?: (boolean|null);
            fullscreen_disable_exit_button_time_ms?: (number|null);
            balloon_gift_settings?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ISponsoredBalloonGiftSettingsProto|null);
            external_ad_service_ads_enabled?: (boolean|null);
            external_ad_service_settings?: (POGOProtos.Rpc.INativeAdUnitSettingsProto|null);
            external_ad_service_balloon_gift_keys?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IExternalAdServiceBalloonGiftKeysProto|null);
            web_view_disable_exit_button_time_ms?: (number|null);
            web_view_post_ar_disable_exit_button_time_ms?: (number|null);
            gam_video_ads_enabled?: (boolean|null);
            gam_video_ad_unit_settings?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IGamVideoAdUnitSettingsProto|null);
            force_ad_through_gam?: (boolean|null);
            report_ad_feedback_enabled?: (boolean|null);
        }

        class SponsoredGeofenceGiftSettingsProto implements ISponsoredGeofenceGiftSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISponsoredGeofenceGiftSettingsProto);
            public gift_persistence_enabled: boolean;
            public gift_persistence_time_ms: number;
            public map_presentation_time_ms: number;
            public enable_sponsored_geofence_gift: boolean;
            public enable_dark_launch: boolean;
            public enable_poi_gift: boolean;
            public enable_raid_gift: boolean;
            public enable_incident_gift: boolean;
            public fullscreen_disable_exit_button_time_ms: number;
            public balloon_gift_settings?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ISponsoredBalloonGiftSettingsProto|null);
            public external_ad_service_ads_enabled: boolean;
            public external_ad_service_settings?: (POGOProtos.Rpc.INativeAdUnitSettingsProto|null);
            public external_ad_service_balloon_gift_keys?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IExternalAdServiceBalloonGiftKeysProto|null);
            public web_view_disable_exit_button_time_ms: number;
            public web_view_post_ar_disable_exit_button_time_ms: number;
            public gam_video_ads_enabled: boolean;
            public gam_video_ad_unit_settings?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IGamVideoAdUnitSettingsProto|null);
            public force_ad_through_gam: boolean;
            public report_ad_feedback_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ISponsoredGeofenceGiftSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SponsoredGeofenceGiftSettingsProto {

            interface IExternalAdServiceBalloonGiftKeysProto {
                ads_logo?: (string|null);
                partner_name?: (string|null);
                fullscreen_image?: (string|null);
                title?: (string|null);
                description?: (string|null);
                cta_url?: (string|null);
                campaign_identifier?: (string|null);
            }

            class ExternalAdServiceBalloonGiftKeysProto implements IExternalAdServiceBalloonGiftKeysProto {
                constructor(properties?: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IExternalAdServiceBalloonGiftKeysProto);
                public ads_logo: string;
                public partner_name: string;
                public fullscreen_image: string;
                public title: string;
                public description: string;
                public cta_url: string;
                public campaign_identifier: string;
                public static encode(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IExternalAdServiceBalloonGiftKeysProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ExternalAdServiceBalloonGiftKeysProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ExternalAdServiceBalloonGiftKeysProto;
                public static toObject(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ExternalAdServiceBalloonGiftKeysProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGamVideoAdUnitSettingsProto {
                ios_ad_unit_id?: (string|null);
                android_ad_unit_id?: (string|null);
                other_ad_unit_id?: (string|null);
            }

            class GamVideoAdUnitSettingsProto implements IGamVideoAdUnitSettingsProto {
                constructor(properties?: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IGamVideoAdUnitSettingsProto);
                public ios_ad_unit_id: string;
                public android_ad_unit_id: string;
                public other_ad_unit_id: string;
                public static encode(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.IGamVideoAdUnitSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.GamVideoAdUnitSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.GamVideoAdUnitSettingsProto;
                public static toObject(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.GamVideoAdUnitSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISponsoredBalloonGiftSettingsProto {
                enable_balloon_gift?: (boolean|null);
                balloon_auto_dismiss_time_ms?: (number|null);
                incident_balloon_prevents_sponsored_balloon?: (boolean|null);
                incident_balloon_dismisses_sponsored_balloon?: (boolean|null);
                get_wasabi_ad_rpc_interval_ms?: (number|null);
                balloon_movement_settings?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.ISponsoredBalloonMovementSettingsProto|null);
                enable_balloon_web_view?: (boolean|null);
            }

            class SponsoredBalloonGiftSettingsProto implements ISponsoredBalloonGiftSettingsProto {
                constructor(properties?: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ISponsoredBalloonGiftSettingsProto);
                public enable_balloon_gift: boolean;
                public balloon_auto_dismiss_time_ms: number;
                public incident_balloon_prevents_sponsored_balloon: boolean;
                public incident_balloon_dismisses_sponsored_balloon: boolean;
                public get_wasabi_ad_rpc_interval_ms: number;
                public balloon_movement_settings?: (POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.ISponsoredBalloonMovementSettingsProto|null);
                public enable_balloon_web_view: boolean;
                public static encode(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.ISponsoredBalloonGiftSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto;
                public static toObject(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SponsoredBalloonGiftSettingsProto {

                interface ISponsoredBalloonMovementSettingsProto {
                    wander_min_distance?: (number|null);
                    wander_max_distance?: (number|null);
                    wander_interval_min?: (number|null);
                    wander_interval_max?: (number|null);
                    max_speed?: (number|null);
                    target_camera_distance?: (number|null);
                }

                class SponsoredBalloonMovementSettingsProto implements ISponsoredBalloonMovementSettingsProto {
                    constructor(properties?: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.ISponsoredBalloonMovementSettingsProto);
                    public wander_min_distance: number;
                    public wander_max_distance: number;
                    public wander_interval_min: number;
                    public wander_interval_max: number;
                    public max_speed: number;
                    public target_camera_distance: number;
                    public static encode(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.ISponsoredBalloonMovementSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.SponsoredBalloonMovementSettingsProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.SponsoredBalloonMovementSettingsProto;
                    public static toObject(message: POGOProtos.Rpc.SponsoredGeofenceGiftSettingsProto.SponsoredBalloonGiftSettingsProto.SponsoredBalloonMovementSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface ISponsoredPoiFeedbackSettingsProto {
            enabled?: (boolean|null);
            enable_report_ad?: (boolean|null);
            enable_not_interested?: (boolean|null);
            enable_see_more?: (boolean|null);
        }

        class SponsoredPoiFeedbackSettingsProto implements ISponsoredPoiFeedbackSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISponsoredPoiFeedbackSettingsProto);
            public enabled: boolean;
            public enable_report_ad: boolean;
            public enable_not_interested: boolean;
            public enable_see_more: boolean;
            public static encode(message: POGOProtos.Rpc.ISponsoredPoiFeedbackSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SponsoredPoiFeedbackSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SponsoredPoiFeedbackSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SponsoredPoiFeedbackSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISquashSettingsProto {
            enabled?: (boolean|null);
            daily_squash_limit?: (number|null);
        }

        class SquashSettingsProto implements ISquashSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISquashSettingsProto);
            public enabled: boolean;
            public daily_squash_limit: number;
            public static encode(message: POGOProtos.Rpc.ISquashSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SquashSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SquashSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SquashSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCardSectionProto {
        }

        class StampCardSectionProto implements IStampCardSectionProto {
            constructor(properties?: POGOProtos.Rpc.IStampCardSectionProto);
            public static encode(message: POGOProtos.Rpc.IStampCardSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCardSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCardSectionProto;
            public static toObject(message: POGOProtos.Rpc.StampCardSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCollectionDefinitionProto {
            poi_definitions?: (POGOProtos.Rpc.StampCollectionDefinitionProto.IStampCollectionPoiDefinitions|null);
            collection_id?: (string|null);
            type?: (POGOProtos.Rpc.StampCollectionType|null);
            collection_color_pool?: (string[]|null);
            collection_version?: (number|null);
            display?: (POGOProtos.Rpc.IStampCollectionDisplayProto|null);
            completion_count?: (number|null);
            reward_intervals?: (POGOProtos.Rpc.IStampCollectionRewardProto[]|null);
            collection_end_time?: (string|null);
            is_giftable?: (boolean|null);
            stamp_template_ids?: (string[]|null);
            reward_template_ids?: (string[]|null);
        }

        class StampCollectionDefinitionProto implements IStampCollectionDefinitionProto {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionDefinitionProto);
            public poi_definitions?: (POGOProtos.Rpc.StampCollectionDefinitionProto.IStampCollectionPoiDefinitions|null);
            public collection_id: string;
            public type: POGOProtos.Rpc.StampCollectionType;
            public collection_color_pool: string[];
            public collection_version: number;
            public display?: (POGOProtos.Rpc.IStampCollectionDisplayProto|null);
            public completion_count: number;
            public reward_intervals: POGOProtos.Rpc.IStampCollectionRewardProto[];
            public collection_end_time: string;
            public is_giftable: boolean;
            public stamp_template_ids: string[];
            public reward_template_ids: string[];
            public StampCollectionType?: "poi_definitions";
            public static encode(message: POGOProtos.Rpc.IStampCollectionDefinitionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionDefinitionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionDefinitionProto;
            public static toObject(message: POGOProtos.Rpc.StampCollectionDefinitionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StampCollectionDefinitionProto {

            interface IStampCollectionPoiDefinitions {
                stamp_metadata?: (POGOProtos.Rpc.IStampMetadataProto[]|null);
            }

            class StampCollectionPoiDefinitions implements IStampCollectionPoiDefinitions {
                constructor(properties?: POGOProtos.Rpc.StampCollectionDefinitionProto.IStampCollectionPoiDefinitions);
                public stamp_metadata: POGOProtos.Rpc.IStampMetadataProto[];
                public static encode(message: POGOProtos.Rpc.StampCollectionDefinitionProto.IStampCollectionPoiDefinitions, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionDefinitionProto.StampCollectionPoiDefinitions;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionDefinitionProto.StampCollectionPoiDefinitions;
                public static toObject(message: POGOProtos.Rpc.StampCollectionDefinitionProto.StampCollectionPoiDefinitions, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IStampCollectionDisplayProto {
            list_title_key?: (string|null);
            list_image_url?: (string|null);
            header_image_url?: (string|null);
            uses_header_images?: (boolean|null);
            background_image_url?: (string|null);
            category_displays?: (POGOProtos.Rpc.StampCollectionDisplayProto.IStampCategoryDisplayProto[]|null);
            stamp_info_subheader_description_key?: (string|null);
            stamp_info_where_description_key?: (string|null);
            stamp_info_rewards_description_key?: (string|null);
            stamp_info_details_description_key?: (string|null);
            collection_web_info_url_key?: (string|null);
            stamp_panel_header_key?: (string|null);
        }

        class StampCollectionDisplayProto implements IStampCollectionDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionDisplayProto);
            public list_title_key: string;
            public list_image_url: string;
            public header_image_url: string;
            public uses_header_images: boolean;
            public background_image_url: string;
            public category_displays: POGOProtos.Rpc.StampCollectionDisplayProto.IStampCategoryDisplayProto[];
            public stamp_info_subheader_description_key: string;
            public stamp_info_where_description_key: string;
            public stamp_info_rewards_description_key: string;
            public stamp_info_details_description_key: string;
            public collection_web_info_url_key: string;
            public stamp_panel_header_key: string;
            public static encode(message: POGOProtos.Rpc.IStampCollectionDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionDisplayProto;
            public static toObject(message: POGOProtos.Rpc.StampCollectionDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StampCollectionDisplayProto {

            interface IStampCategoryDisplayProto {
                category_key?: (string|null);
                subcategory_keys?: (string[]|null);
                category_image_url?: (string|null);
                subcategory_info?: (POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.IStampSubCategoryDisplayProto[]|null);
            }

            class StampCategoryDisplayProto implements IStampCategoryDisplayProto {
                constructor(properties?: POGOProtos.Rpc.StampCollectionDisplayProto.IStampCategoryDisplayProto);
                public category_key: string;
                public subcategory_keys: string[];
                public category_image_url: string;
                public subcategory_info: POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.IStampSubCategoryDisplayProto[];
                public static encode(message: POGOProtos.Rpc.StampCollectionDisplayProto.IStampCategoryDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto;
                public static toObject(message: POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace StampCategoryDisplayProto {

                interface IStampSubCategoryDisplayProto {
                    subcategory_key?: (string|null);
                    subcategory_web_info_url_key?: (string|null);
                }

                class StampSubCategoryDisplayProto implements IStampSubCategoryDisplayProto {
                    constructor(properties?: POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.IStampSubCategoryDisplayProto);
                    public subcategory_key: string;
                    public subcategory_web_info_url_key: string;
                    public static encode(message: POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.IStampSubCategoryDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.StampSubCategoryDisplayProto;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.StampSubCategoryDisplayProto;
                    public static toObject(message: POGOProtos.Rpc.StampCollectionDisplayProto.StampCategoryDisplayProto.StampSubCategoryDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IStampCollectionGiftboxDetailsProto {
            stamp_collection_id?: (string|null);
            stamp_image?: (string|null);
            list_title_key?: (string|null);
            list_image_url?: (string|null);
            header_image_url?: (string|null);
            uses_header_images?: (boolean|null);
        }

        class StampCollectionGiftboxDetailsProto implements IStampCollectionGiftboxDetailsProto {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionGiftboxDetailsProto);
            public stamp_collection_id: string;
            public stamp_image: string;
            public list_title_key: string;
            public list_image_url: string;
            public header_image_url: string;
            public uses_header_images: boolean;
            public static encode(message: POGOProtos.Rpc.IStampCollectionGiftboxDetailsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionGiftboxDetailsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionGiftboxDetailsProto;
            public static toObject(message: POGOProtos.Rpc.StampCollectionGiftboxDetailsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCollectionProgressLogEntry {
            collection_id?: (string|null);
            fort_id?: (string|null);
            fort_name?: (string|null);
            completes_collection?: (boolean|null);
        }

        class StampCollectionProgressLogEntry implements IStampCollectionProgressLogEntry {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionProgressLogEntry);
            public collection_id: string;
            public fort_id: string;
            public fort_name: string;
            public completes_collection: boolean;
            public static encode(message: POGOProtos.Rpc.IStampCollectionProgressLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionProgressLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionProgressLogEntry;
            public static toObject(message: POGOProtos.Rpc.StampCollectionProgressLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCollectionRewardProgressProto {
            reward?: (POGOProtos.Rpc.IStampCollectionRewardProto|null);
            claimed?: (boolean|null);
        }

        class StampCollectionRewardProgressProto implements IStampCollectionRewardProgressProto {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionRewardProgressProto);
            public reward?: (POGOProtos.Rpc.IStampCollectionRewardProto|null);
            public claimed: boolean;
            public static encode(message: POGOProtos.Rpc.IStampCollectionRewardProgressProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionRewardProgressProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionRewardProgressProto;
            public static toObject(message: POGOProtos.Rpc.StampCollectionRewardProgressProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCollectionRewardProto {
            required_progress?: (number|null);
            rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class StampCollectionRewardProto implements IStampCollectionRewardProto {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionRewardProto);
            public required_progress: number;
            public rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IStampCollectionRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionRewardProto;
            public static toObject(message: POGOProtos.Rpc.StampCollectionRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCollectionRewardsLogEntry {
            collection_id?: (string|null);
            rewards?: (POGOProtos.Rpc.IQuestRewardProto[]|null);
        }

        class StampCollectionRewardsLogEntry implements IStampCollectionRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionRewardsLogEntry);
            public collection_id: string;
            public rewards: POGOProtos.Rpc.IQuestRewardProto[];
            public static encode(message: POGOProtos.Rpc.IStampCollectionRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.StampCollectionRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampCollectionSettingsProto {
            version?: (number|null);
            default_color_pool?: (string[]|null);
            gifting_min_friendship_level?: (number|null);
            show_stamp_preview?: (boolean|null);
            min_player_level?: (number|null);
        }

        class StampCollectionSettingsProto implements IStampCollectionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IStampCollectionSettingsProto);
            public version: number;
            public default_color_pool: string[];
            public gifting_min_friendship_level: number;
            public show_stamp_preview: boolean;
            public min_player_level: number;
            public static encode(message: POGOProtos.Rpc.IStampCollectionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampCollectionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampCollectionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.StampCollectionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampMetadataProto {
            fort_id?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            fort_title_key?: (string|null);
            category_key?: (string|null);
            subcategory_key?: (string|null);
            fort_image_url?: (string|null);
            stamp_reward?: (POGOProtos.Rpc.IQuestRewardProto|null);
            visited_description_key?: (string|null);
            stamp_image?: (string|null);
        }

        class StampMetadataProto implements IStampMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IStampMetadataProto);
            public fort_id: string;
            public latitude: number;
            public longitude: number;
            public fort_title_key: string;
            public category_key: string;
            public subcategory_key: string;
            public fort_image_url: string;
            public stamp_reward?: (POGOProtos.Rpc.IQuestRewardProto|null);
            public visited_description_key: string;
            public stamp_image: string;
            public static encode(message: POGOProtos.Rpc.IStampMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampMetadataProto;
            public static toObject(message: POGOProtos.Rpc.StampMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStampRallyBadgeData {
            completed_stamp_rallies?: (POGOProtos.Rpc.StampRallyBadgeData.IStampRallyBadgeEvent[]|null);
            stamp_rallies?: (POGOProtos.Rpc.StampRallyBadgeData.IStampRallyBadgeEvent[]|null);
        }

        class StampRallyBadgeData implements IStampRallyBadgeData {
            constructor(properties?: POGOProtos.Rpc.IStampRallyBadgeData);
            public completed_stamp_rallies: POGOProtos.Rpc.StampRallyBadgeData.IStampRallyBadgeEvent[];
            public stamp_rallies: POGOProtos.Rpc.StampRallyBadgeData.IStampRallyBadgeEvent[];
            public static encode(message: POGOProtos.Rpc.IStampRallyBadgeData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampRallyBadgeData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampRallyBadgeData;
            public static toObject(message: POGOProtos.Rpc.StampRallyBadgeData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StampRallyBadgeData {

            interface IStampRallyBadgeEvent {
                collection_id?: (string|null);
                completed_timestamp?: (number|Long|null);
                version?: (number|null);
            }

            class StampRallyBadgeEvent implements IStampRallyBadgeEvent {
                constructor(properties?: POGOProtos.Rpc.StampRallyBadgeData.IStampRallyBadgeEvent);
                public collection_id: string;
                public completed_timestamp: (number|Long);
                public version: number;
                public static encode(message: POGOProtos.Rpc.StampRallyBadgeData.IStampRallyBadgeEvent, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StampRallyBadgeData.StampRallyBadgeEvent;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StampRallyBadgeData.StampRallyBadgeEvent;
                public static toObject(message: POGOProtos.Rpc.StampRallyBadgeData.StampRallyBadgeEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IStardustBoostAttributesProto {
            stardust_multiplier?: (number|null);
            boost_duration_ms?: (number|null);
        }

        class StardustBoostAttributesProto implements IStardustBoostAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IStardustBoostAttributesProto);
            public stardust_multiplier: number;
            public boost_duration_ms: number;
            public static encode(message: POGOProtos.Rpc.IStardustBoostAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StardustBoostAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StardustBoostAttributesProto;
            public static toObject(message: POGOProtos.Rpc.StardustBoostAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartBreadBattleOutProto {
            result?: (POGOProtos.Rpc.StartBreadBattleOutProto.Result|null);
            session_player_id?: (string|null);
            server_timestamp_ms?: (number|Long|null);
            lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            debug_error_description?: (string|null);
            rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
        }

        class StartBreadBattleOutProto implements IStartBreadBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartBreadBattleOutProto);
            public result: POGOProtos.Rpc.StartBreadBattleOutProto.Result;
            public session_player_id: string;
            public server_timestamp_ms: (number|Long);
            public lobby?: (POGOProtos.Rpc.IBreadLobbyProto|null);
            public debug_error_description: string;
            public rvn_connection?: (POGOProtos.Rpc.IRvnConnectionProto|null);
            public static encode(message: POGOProtos.Rpc.IStartBreadBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartBreadBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartBreadBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.StartBreadBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartBreadBattleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_STATION_NOT_FOUND = 2,
                ERROR_BREAD_BATTLE_UNAVAILABLE = 3,
                ERROR_BREAD_BATTLE_COMPLETED = 4,
                ERROR_INVALID_ATTACKERS = 5,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 6,
                ERROR_NOT_IN_RANGE = 7,
                ERROR_STATION_INACCESSIBLE = 8,
                ERROR_INVALID_SERVER = 9,
                ERROR_NEVER_JOINED_BREAD_BATTLE = 10,
                ERROR_NO_ACTIVE_BATTLE_AT_STATION = 11,
                ERROR_LOBBY_NOT_FOUND = 12,
                ERROR_NO_PLAYER_LOCATION = 13,
                ERROR_REQUEST_DOES_NOT_MATCH_EXISTING_BATTLE = 14,
                ERROR_NO_PLAYER_LOCATION2 = 15,
                ERROR_BATTLE_START_TIME_NOT_REACHED = 16,
                ERROR_BATTLE_END_TIME_REACHED = 17,
                ERROR_RVN_JOIN_FAILED = 18,
                ERROR_RVN_START_FAILED = 19,
                ERROR_DUPLICATE_PLAYER_NUMBER = 20
            }
        }

        interface IStartBreadBattleProto {
            station_id?: (string|null);
            bread_battle_seed?: (number|Long|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
            bread_battle_entry_point?: (POGOProtos.Rpc.BreadBattleEntryPoint|null);
        }

        class StartBreadBattleProto implements IStartBreadBattleProto {
            constructor(properties?: POGOProtos.Rpc.IStartBreadBattleProto);
            public station_id: string;
            public bread_battle_seed: (number|Long);
            public attacking_pokemon_id: (number|Long)[];
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public bread_battle_entry_point: POGOProtos.Rpc.BreadBattleEntryPoint;
            public static encode(message: POGOProtos.Rpc.IStartBreadBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartBreadBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartBreadBattleProto;
            public static toObject(message: POGOProtos.Rpc.StartBreadBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartGymBattleOutProto {
            result?: (POGOProtos.Rpc.StartGymBattleOutProto.Result|null);
            battle_start_ms?: (number|Long|null);
            battle_end_ms?: (number|Long|null);
            battle_id?: (string|null);
            defender?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            attacker?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            battle?: (POGOProtos.Rpc.IBattleProto|null);
        }

        class StartGymBattleOutProto implements IStartGymBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartGymBattleOutProto);
            public result: POGOProtos.Rpc.StartGymBattleOutProto.Result;
            public battle_start_ms: (number|Long);
            public battle_end_ms: (number|Long);
            public battle_id: string;
            public defender?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            public battle_log?: (POGOProtos.Rpc.IBattleLogProto|null);
            public attacker?: (POGOProtos.Rpc.IBattleParticipantProto|null);
            public battle?: (POGOProtos.Rpc.IBattleProto|null);
            public static encode(message: POGOProtos.Rpc.IStartGymBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartGymBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartGymBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.StartGymBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartGymBattleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_GYM_NOT_FOUND = 2,
                ERROR_GYM_NEUTRAL = 3,
                ERROR_GYM_WRONG_TEAM = 4,
                ERROR_GYM_EMPTY = 5,
                ERROR_INVALID_DEFENDER = 6,
                ERROR_TRAINING_INVALID_ATTACKER_COUNT = 7,
                ERROR_ALL_POKEMON_FAINTED = 8,
                ERROR_TOO_MANY_BATTLES = 9,
                ERROR_TOO_MANY_PLAYERS = 10,
                ERROR_GYM_BATTLE_LOCKOUT = 11,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 12,
                ERROR_NOT_IN_RANGE = 13,
                ERROR_POI_INACCESSIBLE = 14
            }
        }

        interface IStartGymBattleProto {
            gym_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            defending_pokemon_id?: (number|Long|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
        }

        class StartGymBattleProto implements IStartGymBattleProto {
            constructor(properties?: POGOProtos.Rpc.IStartGymBattleProto);
            public gym_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public defending_pokemon_id: (number|Long);
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IStartGymBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartGymBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartGymBattleProto;
            public static toObject(message: POGOProtos.Rpc.StartGymBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartIncidentOutProto {
            status?: (POGOProtos.Rpc.StartIncidentOutProto.Status|null);
            incident?: (POGOProtos.Rpc.IClientIncidentProto|null);
        }

        class StartIncidentOutProto implements IStartIncidentOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartIncidentOutProto);
            public status: POGOProtos.Rpc.StartIncidentOutProto.Status;
            public incident?: (POGOProtos.Rpc.IClientIncidentProto|null);
            public static encode(message: POGOProtos.Rpc.IStartIncidentOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartIncidentOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartIncidentOutProto;
            public static toObject(message: POGOProtos.Rpc.StartIncidentOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartIncidentOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_IN_RANGE = 2,
                ERROR_INCIDENT_COMPLETED = 3,
                ERROR_INCIDENT_NOT_FOUND = 4,
                ERROR_PLAYER_BELOW_MIN_LEVEL = 5,
                ERROR = 6
            }
        }

        interface IStartIncidentProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
        }

        class StartIncidentProto implements IStartIncidentProto {
            constructor(properties?: POGOProtos.Rpc.IStartIncidentProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public static encode(message: POGOProtos.Rpc.IStartIncidentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartIncidentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartIncidentProto;
            public static toObject(message: POGOProtos.Rpc.StartIncidentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartMpWalkQuestOutProto {
            status?: (POGOProtos.Rpc.StartMpWalkQuestOutProto.Status|null);
        }

        class StartMpWalkQuestOutProto implements IStartMpWalkQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartMpWalkQuestOutProto);
            public status: POGOProtos.Rpc.StartMpWalkQuestOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IStartMpWalkQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartMpWalkQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartMpWalkQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.StartMpWalkQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartMpWalkQuestOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ALREADY_STARTED = 2,
                MP_NOT_ENABLED = 3
            }
        }

        interface IStartMpWalkQuestProto {
        }

        class StartMpWalkQuestProto implements IStartMpWalkQuestProto {
            constructor(properties?: POGOProtos.Rpc.IStartMpWalkQuestProto);
            public static encode(message: POGOProtos.Rpc.IStartMpWalkQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartMpWalkQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartMpWalkQuestProto;
            public static toObject(message: POGOProtos.Rpc.StartMpWalkQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartPartyOutProto {
            party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            result?: (POGOProtos.Rpc.StartPartyOutProto.Result|null);
        }

        class StartPartyOutProto implements IStartPartyOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartPartyOutProto);
            public party?: (POGOProtos.Rpc.IPartyRpcProto|null);
            public result: POGOProtos.Rpc.StartPartyOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IStartPartyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartPartyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartPartyOutProto;
            public static toObject(message: POGOProtos.Rpc.StartPartyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartPartyOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_FEATURE_DISABLED = 3,
                ERROR_PLAYER_NOT_IN_PARTY = 4,
                ERROR_PARTY_NOT_READY_TO_START = 5,
                ERROR_PLAYER_IS_NOT_HOST = 6,
                ERROR_NOT_ENOUGH_PLAYERS = 7,
                ERROR_PARTY_TIMED_OUT = 8,
                ERROR_PLAYERS_NOT_IN_RANGE = 9,
                ERROR_REDIS_EXCEPTION = 10,
                ERROR_NO_LOCATION = 11,
                ERROR_PLFE_REDIRECT_NEEDED = 12,
                ERROR_UNEXPECTED_PARTY_TYPE = 13
            }
        }

        interface IStartPartyProto {
            party_id?: (number[]|null);
            party_type?: (POGOProtos.Rpc.PartyType|null);
            id?: (number|Long|null);
        }

        class StartPartyProto implements IStartPartyProto {
            constructor(properties?: POGOProtos.Rpc.IStartPartyProto);
            public party_id: number[];
            public party_type: POGOProtos.Rpc.PartyType;
            public id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IStartPartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartPartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartPartyProto;
            public static toObject(message: POGOProtos.Rpc.StartPartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartPartyQuestOutProto {
            result?: (POGOProtos.Rpc.StartPartyQuestOutProto.Result|null);
            quest?: (POGOProtos.Rpc.IClientQuestProto|null);
        }

        class StartPartyQuestOutProto implements IStartPartyQuestOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartPartyQuestOutProto);
            public result: POGOProtos.Rpc.StartPartyQuestOutProto.Result;
            public quest?: (POGOProtos.Rpc.IClientQuestProto|null);
            public static encode(message: POGOProtos.Rpc.IStartPartyQuestOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartPartyQuestOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartPartyQuestOutProto;
            public static toObject(message: POGOProtos.Rpc.StartPartyQuestOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartPartyQuestOutProto {

            enum Result {
                UNSET = 0,
                ERROR_UNKNOWN = 1,
                SUCCESS = 2,
                ERROR_FEATURE_DISABLED = 3,
                ERROR_PLAYER_NOT_IN_PARTY = 4,
                ERROR_PLAYER_IS_NOT_HOST = 5,
                ERROR_QUEST_NOT_FOUND = 6,
                ERROR_QUEST_STATUS_INVALID = 7,
                ERROR_PARTY_NOT_FOUND = 8,
                ERROR_PARTY_STATUS_INVALID = 9,
                ERROR_PLAYER_STATE_NOT_FOUND = 10,
                ERROR_PLAYER_STATE_INVALID = 11,
                ERROR_ALREADY_STARTED_QUEST = 12,
                ERROR_PARTY_TIMED_OUT = 13,
                ERROR_PLFE_REDIRECT_NEEDED = 14,
                ERROR_UNEXPECTED_PARTY_TYPE = 15
            }
        }

        interface IStartPartyQuestProto {
            quest_id?: (string|null);
        }

        class StartPartyQuestProto implements IStartPartyQuestProto {
            constructor(properties?: POGOProtos.Rpc.IStartPartyQuestProto);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.IStartPartyQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartPartyQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartPartyQuestProto;
            public static toObject(message: POGOProtos.Rpc.StartPartyQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartQuestIncidentProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            quest_id?: (string|null);
        }

        class StartQuestIncidentProto implements IStartQuestIncidentProto {
            constructor(properties?: POGOProtos.Rpc.IStartQuestIncidentProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.IStartQuestIncidentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartQuestIncidentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartQuestIncidentProto;
            public static toObject(message: POGOProtos.Rpc.StartQuestIncidentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartRaidBattleData {
            attacking_pokemon_id?: ((number|Long)[]|null);
            rpc_id?: (number|null);
        }

        class StartRaidBattleData implements IStartRaidBattleData {
            constructor(properties?: POGOProtos.Rpc.IStartRaidBattleData);
            public attacking_pokemon_id: (number|Long)[];
            public rpc_id: number;
            public static encode(message: POGOProtos.Rpc.IStartRaidBattleData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRaidBattleData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRaidBattleData;
            public static toObject(message: POGOProtos.Rpc.StartRaidBattleData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartRaidBattleOutProto {
            result?: (POGOProtos.Rpc.StartRaidBattleOutProto.Result|null);
            battle?: (POGOProtos.Rpc.IBattleProto|null);
            battle_experiment?: (POGOProtos.Rpc.BattleExperiment[]|null);
            session_player_id?: (string|null);
        }

        class StartRaidBattleOutProto implements IStartRaidBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartRaidBattleOutProto);
            public result: POGOProtos.Rpc.StartRaidBattleOutProto.Result;
            public battle?: (POGOProtos.Rpc.IBattleProto|null);
            public battle_experiment: POGOProtos.Rpc.BattleExperiment[];
            public session_player_id: string;
            public static encode(message: POGOProtos.Rpc.IStartRaidBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRaidBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRaidBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.StartRaidBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartRaidBattleOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_GYM_NOT_FOUND = 2,
                ERROR_RAID_UNAVAILABLE = 3,
                ERROR_RAID_COMPLETED = 4,
                ERROR_INVALID_ATTACKERS = 5,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 6,
                ERROR_NOT_IN_RANGE = 7,
                ERROR_POI_INACCESSIBLE = 8,
                ERROR_LOBBY_NOT_FOUND = 9,
                ERROR_NO_TICKET = 10,
                ERROR_INVALID_SERVER = 11,
                ERROR_NEVER_JOINED_BATTLE = 12,
                ERROR_DATA = 13
            }
        }

        interface IStartRaidBattleProto {
            gym_id?: (string|null);
            raid_seed?: (number|Long|null);
            lobby_id?: (number[]|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            player_lat_degrees?: (number|null);
            player_lng_degrees?: (number|null);
            gym_lat_degrees?: (number|null);
            gym_lng_degrees?: (number|null);
        }

        class StartRaidBattleProto implements IStartRaidBattleProto {
            constructor(properties?: POGOProtos.Rpc.IStartRaidBattleProto);
            public gym_id: string;
            public raid_seed: (number|Long);
            public lobby_id: number[];
            public attacking_pokemon_id: (number|Long)[];
            public player_lat_degrees: number;
            public player_lng_degrees: number;
            public gym_lat_degrees: number;
            public gym_lng_degrees: number;
            public static encode(message: POGOProtos.Rpc.IStartRaidBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRaidBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRaidBattleProto;
            public static toObject(message: POGOProtos.Rpc.StartRaidBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartRaidBattleResponseData {
            result?: (POGOProtos.Rpc.StartRaidBattleOutProto.Result|null);
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            highest_friendship_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone|null);
        }

        class StartRaidBattleResponseData implements IStartRaidBattleResponseData {
            constructor(properties?: POGOProtos.Rpc.IStartRaidBattleResponseData);
            public result: POGOProtos.Rpc.StartRaidBattleOutProto.Result;
            public rpc_id: number;
            public round_trip_time_ms: number;
            public highest_friendship_milestone: POGOProtos.Rpc.FriendshipLevelMilestone;
            public static encode(message: POGOProtos.Rpc.IStartRaidBattleResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRaidBattleResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRaidBattleResponseData;
            public static toObject(message: POGOProtos.Rpc.StartRaidBattleResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartRocketBalloonIncidentProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
        }

        class StartRocketBalloonIncidentProto implements IStartRocketBalloonIncidentProto {
            constructor(properties?: POGOProtos.Rpc.IStartRocketBalloonIncidentProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public static encode(message: POGOProtos.Rpc.IStartRocketBalloonIncidentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRocketBalloonIncidentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRocketBalloonIncidentProto;
            public static toObject(message: POGOProtos.Rpc.StartRocketBalloonIncidentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartRouteOutProto {
            status?: (POGOProtos.Rpc.RoutePlayStatus.Status|null);
            route_play?: (POGOProtos.Rpc.IRoutePlayProto|null);
        }

        class StartRouteOutProto implements IStartRouteOutProto {
            constructor(properties?: POGOProtos.Rpc.IStartRouteOutProto);
            public status: POGOProtos.Rpc.RoutePlayStatus.Status;
            public route_play?: (POGOProtos.Rpc.IRoutePlayProto|null);
            public static encode(message: POGOProtos.Rpc.IStartRouteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRouteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRouteOutProto;
            public static toObject(message: POGOProtos.Rpc.StartRouteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartRouteProto {
            route_id?: (string|null);
            entry_fort_id?: (string|null);
            travel_in_reverse?: (boolean|null);
        }

        class StartRouteProto implements IStartRouteProto {
            constructor(properties?: POGOProtos.Rpc.IStartRouteProto);
            public route_id: string;
            public entry_fort_id: string;
            public travel_in_reverse: boolean;
            public static encode(message: POGOProtos.Rpc.IStartRouteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartRouteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartRouteProto;
            public static toObject(message: POGOProtos.Rpc.StartRouteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStartupMeasurementProto {
            num_starts?: (number|Long|null);
            load_to_tos_login_duration_ms?: (number|Long|null);
            load_to_map_duration_ms?: (number|Long|null);
        }

        class StartupMeasurementProto implements IStartupMeasurementProto {
            constructor(properties?: POGOProtos.Rpc.IStartupMeasurementProto);
            public num_starts: (number|Long);
            public load_to_tos_login_duration_ms: (number|Long);
            public load_to_map_duration_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IStartupMeasurementProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartupMeasurementProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartupMeasurementProto;
            public static toObject(message: POGOProtos.Rpc.StartupMeasurementProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StartupMeasurementProto {

            interface IComponentLoadDurations {
                component_name?: (string|null);
                load_duration_ms?: (number|Long|null);
                absolute_duration_ms?: (number|Long|null);
            }

            class ComponentLoadDurations implements IComponentLoadDurations {
                constructor(properties?: POGOProtos.Rpc.StartupMeasurementProto.IComponentLoadDurations);
                public component_name: string;
                public load_duration_ms: (number|Long);
                public absolute_duration_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.StartupMeasurementProto.IComponentLoadDurations, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StartupMeasurementProto.ComponentLoadDurations;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StartupMeasurementProto.ComponentLoadDurations;
                public static toObject(message: POGOProtos.Rpc.StartupMeasurementProto.ComponentLoadDurations, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IStatIncreaseAttributesProto {
            stats_to_increase_limit?: (number|null);
        }

        class StatIncreaseAttributesProto implements IStatIncreaseAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IStatIncreaseAttributesProto);
            public stats_to_increase_limit: number;
            public static encode(message: POGOProtos.Rpc.IStatIncreaseAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StatIncreaseAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StatIncreaseAttributesProto;
            public static toObject(message: POGOProtos.Rpc.StatIncreaseAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStatementOfReason {
            niantic_sor?: (POGOProtos.Rpc.NianticStatementOfReason|null);
            enforcement_id?: (string|null);
        }

        class StatementOfReason implements IStatementOfReason {
            constructor(properties?: POGOProtos.Rpc.IStatementOfReason);
            public niantic_sor: POGOProtos.Rpc.NianticStatementOfReason;
            public enforcement_id: string;
            public static encode(message: POGOProtos.Rpc.IStatementOfReason, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StatementOfReason;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StatementOfReason;
            public static toObject(message: POGOProtos.Rpc.StatementOfReason, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStationCreateDetail {
            caught_in_wild?: (boolean|null);
        }

        class StationCreateDetail implements IStationCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IStationCreateDetail);
            public caught_in_wild: boolean;
            public static encode(message: POGOProtos.Rpc.IStationCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationCreateDetail;
            public static toObject(message: POGOProtos.Rpc.StationCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStationPokemonEncounterOutProto {
            result?: (POGOProtos.Rpc.StationPokemonEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            arplus_attempts_until_flee?: (number|null);
        }

        class StationPokemonEncounterOutProto implements IStationPokemonEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IStationPokemonEncounterOutProto);
            public result: POGOProtos.Rpc.StationPokemonEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public arplus_attempts_until_flee: number;
            public static encode(message: POGOProtos.Rpc.IStationPokemonEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationPokemonEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationPokemonEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.StationPokemonEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StationPokemonEncounterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NOT_AVAILABLE = 2,
                NOT_IN_RANGE = 3,
                ENCOUNTER_ALREADY_FINISHED = 4,
                POKEMON_INVENTORY_FULL = 5
            }
        }

        interface IStationPokemonEncounterProto {
            station_id?: (string|null);
            encounter_id?: (string|null);
        }

        class StationPokemonEncounterProto implements IStationPokemonEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IStationPokemonEncounterProto);
            public station_id: string;
            public encounter_id: string;
            public static encode(message: POGOProtos.Rpc.IStationPokemonEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationPokemonEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationPokemonEncounterProto;
            public static toObject(message: POGOProtos.Rpc.StationPokemonEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStationPokemonOutProto {
            result?: (POGOProtos.Rpc.StationPokemonOutProto.Result|null);
            player_client_stationed_pokemon?: (POGOProtos.Rpc.IPlayerClientStationedPokemonProto|null);
        }

        class StationPokemonOutProto implements IStationPokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IStationPokemonOutProto);
            public result: POGOProtos.Rpc.StationPokemonOutProto.Result;
            public player_client_stationed_pokemon?: (POGOProtos.Rpc.IPlayerClientStationedPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IStationPokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationPokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationPokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.StationPokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StationPokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ALREADY_STATIONED = 2,
                INVALID_POKEMON = 3,
                NOT_IN_RANGE = 4,
                INVALID_STATION = 5,
                POKEMON_NOT_FOUND = 6,
                STATION_NOT_FOUND = 7,
                BATTLE_NOT_COMPLETE = 8,
                STATION_MAX_CAPACITY = 9,
                PLAYER_MAX_CAPACITY = 10
            }
        }

        interface IStationPokemonProto {
            station_id?: (string|null);
            pokemon_id?: (number|Long|null);
            station_lat_degrees?: (number|null);
            station_lng_degrees?: (number|null);
            bread_battle_id?: (string|null);
        }

        class StationPokemonProto implements IStationPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IStationPokemonProto);
            public station_id: string;
            public pokemon_id: (number|Long);
            public station_lat_degrees: number;
            public station_lng_degrees: number;
            public bread_battle_id: string;
            public static encode(message: POGOProtos.Rpc.IStationPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationPokemonProto;
            public static toObject(message: POGOProtos.Rpc.StationPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStationProto {
            id?: (string|null);
            lat?: (number|null);
            lng?: (number|null);
            name?: (string|null);
            battle_details?: (POGOProtos.Rpc.IBreadBattleDetailProto|null);
            player_battle_status?: (POGOProtos.Rpc.StationProto.BattleStatus|null);
            start_time_ms?: (number|Long|null);
            end_time_ms?: (number|Long|null);
            cooldown_complete_ms?: (number|Long|null);
            is_bread_battle_available?: (boolean|null);
            is_inactive?: (boolean|null);
        }

        class StationProto implements IStationProto {
            constructor(properties?: POGOProtos.Rpc.IStationProto);
            public id: string;
            public lat: number;
            public lng: number;
            public name: string;
            public battle_details?: (POGOProtos.Rpc.IBreadBattleDetailProto|null);
            public player_battle_status: POGOProtos.Rpc.StationProto.BattleStatus;
            public start_time_ms: (number|Long);
            public end_time_ms: (number|Long);
            public cooldown_complete_ms: (number|Long);
            public is_bread_battle_available: boolean;
            public is_inactive: boolean;
            public static encode(message: POGOProtos.Rpc.IStationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationProto;
            public static toObject(message: POGOProtos.Rpc.StationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StationProto {

            enum BattleStatus {
                UNSET = 0,
                MARKED = 1,
                COMPLETED = 2
            }
        }

        interface IStationRewardSettingsProto {
            group?: (POGOProtos.Rpc.BreadGroupSettings.BreadTierGroup|null);
            candy?: (number[]|null);
            xl_candy?: (number[]|null);
        }

        class StationRewardSettingsProto implements IStationRewardSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IStationRewardSettingsProto);
            public group: POGOProtos.Rpc.BreadGroupSettings.BreadTierGroup;
            public candy: number[];
            public xl_candy: number[];
            public static encode(message: POGOProtos.Rpc.IStationRewardSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationRewardSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationRewardSettingsProto;
            public static toObject(message: POGOProtos.Rpc.StationRewardSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStationedPokemonTableSettingsProto {
            stationed_pokemon_table_enum?: (POGOProtos.Rpc.StationedPokemonTableSettingsProto.StationedPokemonTable|null);
            tier_boosts?: (POGOProtos.Rpc.ITierBoostSettingsProto[]|null);
        }

        class StationedPokemonTableSettingsProto implements IStationedPokemonTableSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IStationedPokemonTableSettingsProto);
            public stationed_pokemon_table_enum: POGOProtos.Rpc.StationedPokemonTableSettingsProto.StationedPokemonTable;
            public tier_boosts: POGOProtos.Rpc.ITierBoostSettingsProto[];
            public static encode(message: POGOProtos.Rpc.IStationedPokemonTableSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationedPokemonTableSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationedPokemonTableSettingsProto;
            public static toObject(message: POGOProtos.Rpc.StationedPokemonTableSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StationedPokemonTableSettingsProto {

            enum StationedPokemonTable {
                UNSET = 0,
                BREAD_STATIONED_POKEMON_SPAWN_BOOST_TABLE_SETTINGS = 1,
                SOURDOUGH_STATIONED_POKEMON_SPAWN_BOOST_TABLE_SETTINGS = 2,
                STATIONED_POKEMON_POWER_BOOST_TABLE_SETTINGS = 3
            }
        }

        interface IStationedSectionProto {
            pokemon_at_station?: (POGOProtos.Rpc.StationedSectionProto.IStationedProto[]|null);
        }

        class StationedSectionProto implements IStationedSectionProto {
            constructor(properties?: POGOProtos.Rpc.IStationedSectionProto);
            public pokemon_at_station: POGOProtos.Rpc.StationedSectionProto.IStationedProto[];
            public static encode(message: POGOProtos.Rpc.IStationedSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationedSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationedSectionProto;
            public static toObject(message: POGOProtos.Rpc.StationedSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StationedSectionProto {

            interface IStationedProto {
                pokemon_id?: (number|Long|null);
                deployed_timestamp_ms?: (number|Long|null);
            }

            class StationedProto implements IStationedProto {
                constructor(properties?: POGOProtos.Rpc.StationedSectionProto.IStationedProto);
                public pokemon_id: (number|Long);
                public deployed_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.StationedSectionProto.IStationedProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StationedSectionProto.StationedProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StationedSectionProto.StationedProto;
                public static toObject(message: POGOProtos.Rpc.StationedSectionProto.StationedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IStickerCategorySettingsProto {
            enabled?: (boolean|null);
            sticker_category?: (POGOProtos.Rpc.StickerCategorySettingsProto.IStickerCategoryProto[]|null);
        }

        class StickerCategorySettingsProto implements IStickerCategorySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IStickerCategorySettingsProto);
            public enabled: boolean;
            public sticker_category: POGOProtos.Rpc.StickerCategorySettingsProto.IStickerCategoryProto[];
            public static encode(message: POGOProtos.Rpc.IStickerCategorySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StickerCategorySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StickerCategorySettingsProto;
            public static toObject(message: POGOProtos.Rpc.StickerCategorySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StickerCategorySettingsProto {

            interface IStickerCategoryProto {
                category?: (string|null);
                sort_order?: (number|null);
                active?: (boolean|null);
                sticker_id?: (string[]|null);
                preferred_category_icon?: (string|null);
            }

            class StickerCategoryProto implements IStickerCategoryProto {
                constructor(properties?: POGOProtos.Rpc.StickerCategorySettingsProto.IStickerCategoryProto);
                public category: string;
                public sort_order: number;
                public active: boolean;
                public sticker_id: string[];
                public preferred_category_icon: string;
                public static encode(message: POGOProtos.Rpc.StickerCategorySettingsProto.IStickerCategoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StickerCategorySettingsProto.StickerCategoryProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StickerCategorySettingsProto.StickerCategoryProto;
                public static toObject(message: POGOProtos.Rpc.StickerCategorySettingsProto.StickerCategoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IStickerMetadataProto {
            sticker_id?: (string|null);
            sticker_url?: (string|null);
            max_count?: (number|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            category?: (string[]|null);
            release_date?: (number|null);
            region_id?: (number|null);
        }

        class StickerMetadataProto implements IStickerMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IStickerMetadataProto);
            public sticker_id: string;
            public sticker_url: string;
            public max_count: number;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public category: string[];
            public release_date: number;
            public region_id: number;
            public static encode(message: POGOProtos.Rpc.IStickerMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StickerMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StickerMetadataProto;
            public static toObject(message: POGOProtos.Rpc.StickerMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStickerProto {
            sticker_id?: (string|null);
            count?: (number|null);
            used?: (number|null);
        }

        class StickerProto implements IStickerProto {
            constructor(properties?: POGOProtos.Rpc.IStickerProto);
            public sticker_id: string;
            public count: number;
            public used: number;
            public static encode(message: POGOProtos.Rpc.IStickerProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StickerProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StickerProto;
            public static toObject(message: POGOProtos.Rpc.StickerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStickerRewardProto {
            sticker_id?: (string|null);
            amount?: (number|null);
        }

        class StickerRewardProto implements IStickerRewardProto {
            constructor(properties?: POGOProtos.Rpc.IStickerRewardProto);
            public sticker_id: string;
            public amount: number;
            public static encode(message: POGOProtos.Rpc.IStickerRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StickerRewardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StickerRewardProto;
            public static toObject(message: POGOProtos.Rpc.StickerRewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStickerSentProto {
            sticker_id?: (string|null);
        }

        class StickerSentProto implements IStickerSentProto {
            constructor(properties?: POGOProtos.Rpc.IStickerSentProto);
            public sticker_id: string;
            public static encode(message: POGOProtos.Rpc.IStickerSentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StickerSentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StickerSentProto;
            public static toObject(message: POGOProtos.Rpc.StickerSentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStorageMetrics {
            current_cache_size_bytes?: (number|Long|null);
            max_cache_size_bytes?: (number|Long|null);
        }

        class StorageMetrics implements IStorageMetrics {
            constructor(properties?: POGOProtos.Rpc.IStorageMetrics);
            public current_cache_size_bytes: (number|Long);
            public max_cache_size_bytes: (number|Long);
            public static encode(message: POGOProtos.Rpc.IStorageMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StorageMetrics;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StorageMetrics;
            public static toObject(message: POGOProtos.Rpc.StorageMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStoreIapSettingsProto {
            for_store?: (POGOProtos.Rpc.Store|null);
            library_version?: (POGOProtos.Rpc.IapLibraryVersion|null);
        }

        class StoreIapSettingsProto implements IStoreIapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IStoreIapSettingsProto);
            public for_store: POGOProtos.Rpc.Store;
            public library_version: POGOProtos.Rpc.IapLibraryVersion;
            public static encode(message: POGOProtos.Rpc.IStoreIapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StoreIapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StoreIapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.StoreIapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStoryQuestSectionProto {
            quest_id?: (string[]|null);
        }

        class StoryQuestSectionProto implements IStoryQuestSectionProto {
            constructor(properties?: POGOProtos.Rpc.IStoryQuestSectionProto);
            public quest_id: string[];
            public static encode(message: POGOProtos.Rpc.IStoryQuestSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StoryQuestSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StoryQuestSectionProto;
            public static toObject(message: POGOProtos.Rpc.StoryQuestSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStringValue {
            value?: (string|null);
        }

        class StringValue implements IStringValue {
            constructor(properties?: POGOProtos.Rpc.IStringValue);
            public value: string;
            public static encode(message: POGOProtos.Rpc.IStringValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StringValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StringValue;
            public static toObject(message: POGOProtos.Rpc.StringValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStruct {
            fields?: ({ [k: string]: POGOProtos.Rpc.IValue }|null);
        }

        class Struct implements IStruct {
            constructor(properties?: POGOProtos.Rpc.IStruct);
            public fields: { [k: string]: POGOProtos.Rpc.IValue };
            public static encode(message: POGOProtos.Rpc.IStruct, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Struct;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Struct;
            public static toObject(message: POGOProtos.Rpc.Struct, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IStyleShopSettingsProto {
            entry_tooltip_config?: (POGOProtos.Rpc.StyleShopSettingsProto.EntryTooltipConfig|null);
            sets_enabled?: (boolean|null);
            recommended_item_icon_names?: (string[]|null);
            new_item_tags_enabled?: (boolean|null);
        }

        class StyleShopSettingsProto implements IStyleShopSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IStyleShopSettingsProto);
            public entry_tooltip_config: POGOProtos.Rpc.StyleShopSettingsProto.EntryTooltipConfig;
            public sets_enabled: boolean;
            public recommended_item_icon_names: string[];
            public new_item_tags_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IStyleShopSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.StyleShopSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.StyleShopSettingsProto;
            public static toObject(message: POGOProtos.Rpc.StyleShopSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace StyleShopSettingsProto {

            enum EntryTooltipConfig {
                UNSET = 0,
                ITEM_BUBBLE_ONLY = 1,
                RED_DOT_ONLY = 2,
                ALL_ON = 3
            }
        }

        interface ISubmissionCounterSettings {
            submission_counter_enabled?: (boolean|null);
        }

        class SubmissionCounterSettings implements ISubmissionCounterSettings {
            constructor(properties?: POGOProtos.Rpc.ISubmissionCounterSettings);
            public submission_counter_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ISubmissionCounterSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmissionCounterSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmissionCounterSettings;
            public static toObject(message: POGOProtos.Rpc.SubmissionCounterSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISubmitCombatAction {
            combat_action_proto?: (POGOProtos.Rpc.ICombatActionLogProto|null);
        }

        class SubmitCombatAction implements ISubmitCombatAction {
            constructor(properties?: POGOProtos.Rpc.ISubmitCombatAction);
            public combat_action_proto?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            public static encode(message: POGOProtos.Rpc.ISubmitCombatAction, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitCombatAction;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitCombatAction;
            public static toObject(message: POGOProtos.Rpc.SubmitCombatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISubmitCombatChallengePokemonsData {
            rpc_id?: (number|null);
            attacking_pokemon_indexes?: (number[]|null);
            lobby_join_time_offset_ms?: (number|null);
        }

        class SubmitCombatChallengePokemonsData implements ISubmitCombatChallengePokemonsData {
            constructor(properties?: POGOProtos.Rpc.ISubmitCombatChallengePokemonsData);
            public rpc_id: number;
            public attacking_pokemon_indexes: number[];
            public lobby_join_time_offset_ms: number;
            public static encode(message: POGOProtos.Rpc.ISubmitCombatChallengePokemonsData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitCombatChallengePokemonsData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitCombatChallengePokemonsData;
            public static toObject(message: POGOProtos.Rpc.SubmitCombatChallengePokemonsData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISubmitCombatChallengePokemonsOutProto {
            result?: (POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
        }

        class SubmitCombatChallengePokemonsOutProto implements ISubmitCombatChallengePokemonsOutProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitCombatChallengePokemonsOutProto);
            public result: POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public static encode(message: POGOProtos.Rpc.ISubmitCombatChallengePokemonsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto;
            public static toObject(message: POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SubmitCombatChallengePokemonsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_CHALLENGE_STATE = 2,
                ERROR_CHALLENGE_NOT_FOUND = 3,
                ERROR_POKEMON_NOT_IN_INVENTORY = 4,
                ERROR_NOT_ELIGIBLE_LEAGUE = 5,
                ERROR_ALREADY_TIMEDOUT = 6,
                ERROR_ALREADY_CANCELLED = 7,
                ERROR_ACCESS_DENIED = 8,
                ERROR_ALREADY_DECLINED = 9
            }
        }

        interface ISubmitCombatChallengePokemonsProto {
            challenge_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
            lobby_join_time_ms?: (number|Long|null);
        }

        class SubmitCombatChallengePokemonsProto implements ISubmitCombatChallengePokemonsProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitCombatChallengePokemonsProto);
            public challenge_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public lobby_join_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ISubmitCombatChallengePokemonsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitCombatChallengePokemonsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitCombatChallengePokemonsProto;
            public static toObject(message: POGOProtos.Rpc.SubmitCombatChallengePokemonsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISubmitCombatChallengePokemonsResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
        }

        class SubmitCombatChallengePokemonsResponseData implements ISubmitCombatChallengePokemonsResponseData {
            constructor(properties?: POGOProtos.Rpc.ISubmitCombatChallengePokemonsResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.SubmitCombatChallengePokemonsOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
            public static encode(message: POGOProtos.Rpc.ISubmitCombatChallengePokemonsResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitCombatChallengePokemonsResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitCombatChallengePokemonsResponseData;
            public static toObject(message: POGOProtos.Rpc.SubmitCombatChallengePokemonsResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISubmitNewPoiOutProto {
            status?: (POGOProtos.Rpc.SubmitNewPoiOutProto.Status|null);
        }

        class SubmitNewPoiOutProto implements ISubmitNewPoiOutProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitNewPoiOutProto);
            public status: POGOProtos.Rpc.SubmitNewPoiOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ISubmitNewPoiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitNewPoiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitNewPoiOutProto;
            public static toObject(message: POGOProtos.Rpc.SubmitNewPoiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SubmitNewPoiOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                INTERNAL_ERROR = 3,
                TOO_MANY_RECENT_SUBMISSIONS = 4,
                INVALID_INPUT = 5,
                MINOR = 6,
                NOT_AVAILABLE = 7
            }
        }

        interface ISubmitNewPoiProto {
            title?: (string|null);
            long_description?: (string|null);
            lat_e6?: (number|null);
            lng_e6?: (number|null);
            supporting_statement?: (string|null);
        }

        class SubmitNewPoiProto implements ISubmitNewPoiProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitNewPoiProto);
            public title: string;
            public long_description: string;
            public lat_e6: number;
            public lng_e6: number;
            public supporting_statement: string;
            public static encode(message: POGOProtos.Rpc.ISubmitNewPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitNewPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitNewPoiProto;
            public static toObject(message: POGOProtos.Rpc.SubmitNewPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISubmitRouteDraftOutProto {
            result?: (POGOProtos.Rpc.SubmitRouteDraftOutProto.Result|null);
            submitted_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            validation_result?: (POGOProtos.Rpc.IRouteValidation|null);
        }

        class SubmitRouteDraftOutProto implements ISubmitRouteDraftOutProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitRouteDraftOutProto);
            public result: POGOProtos.Rpc.SubmitRouteDraftOutProto.Result;
            public submitted_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            public validation_result?: (POGOProtos.Rpc.IRouteValidation|null);
            public static encode(message: POGOProtos.Rpc.ISubmitRouteDraftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitRouteDraftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitRouteDraftOutProto;
            public static toObject(message: POGOProtos.Rpc.SubmitRouteDraftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SubmitRouteDraftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_ROUTE = 3,
                ERROR_OLD_VERSION = 4,
                ERROR_ROUTE_STATE_NOT_IN_PROGRESS = 5,
                ERROR_TOO_MANY_RECENT_SUBMISSIONS = 6,
                ERROR_ROUTE_SUBMISSION_UNAVAILABLE = 7,
                ERROR_UNVISITED_FORT = 8,
                ERROR_MATCHES_REJECTION = 9,
                ERROR_MODERATION_REJECTION = 10,
                PENDING_MODERATION_RESULT = 11
            }
        }

        interface ISubmitRouteDraftProto {
            route_id?: (string|null);
            route_version?: (number|Long|null);
            approval_override?: (POGOProtos.Rpc.SubmitRouteDraftProto.ApprovalOverride|null);
        }

        class SubmitRouteDraftProto implements ISubmitRouteDraftProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitRouteDraftProto);
            public route_id: string;
            public route_version: (number|Long);
            public approval_override: POGOProtos.Rpc.SubmitRouteDraftProto.ApprovalOverride;
            public static encode(message: POGOProtos.Rpc.ISubmitRouteDraftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitRouteDraftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitRouteDraftProto;
            public static toObject(message: POGOProtos.Rpc.SubmitRouteDraftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SubmitRouteDraftProto {

            enum ApprovalOverride {
                UNSET = 0,
                APPROVE = 1,
                REJECT = 2
            }
        }

        interface ISubmitSleepRecordsQuestProto {
            num_days?: (number|null);
        }

        class SubmitSleepRecordsQuestProto implements ISubmitSleepRecordsQuestProto {
            constructor(properties?: POGOProtos.Rpc.ISubmitSleepRecordsQuestProto);
            public num_days: number;
            public static encode(message: POGOProtos.Rpc.ISubmitSleepRecordsQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SubmitSleepRecordsQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SubmitSleepRecordsQuestProto;
            public static toObject(message: POGOProtos.Rpc.SubmitSleepRecordsQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISuperAwesomeTokenProto {
            token?: (string|null);
        }

        class SuperAwesomeTokenProto implements ISuperAwesomeTokenProto {
            constructor(properties?: POGOProtos.Rpc.ISuperAwesomeTokenProto);
            public token: string;
            public static encode(message: POGOProtos.Rpc.ISuperAwesomeTokenProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SuperAwesomeTokenProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SuperAwesomeTokenProto;
            public static toObject(message: POGOProtos.Rpc.SuperAwesomeTokenProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ISupportedContestTypesSettingsProto {
            contest_types?: (POGOProtos.Rpc.SupportedContestTypesSettingsProto.IContestTypeProto[]|null);
        }

        class SupportedContestTypesSettingsProto implements ISupportedContestTypesSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ISupportedContestTypesSettingsProto);
            public contest_types: POGOProtos.Rpc.SupportedContestTypesSettingsProto.IContestTypeProto[];
            public static encode(message: POGOProtos.Rpc.ISupportedContestTypesSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SupportedContestTypesSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SupportedContestTypesSettingsProto;
            public static toObject(message: POGOProtos.Rpc.SupportedContestTypesSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SupportedContestTypesSettingsProto {

            interface IContestTypeProto {
                contest_metric_type?: (POGOProtos.Rpc.IContestMetricProto|null);
                badge_type?: (POGOProtos.Rpc.HoloBadgeType|null);
            }

            class ContestTypeProto implements IContestTypeProto {
                constructor(properties?: POGOProtos.Rpc.SupportedContestTypesSettingsProto.IContestTypeProto);
                public contest_metric_type?: (POGOProtos.Rpc.IContestMetricProto|null);
                public badge_type: POGOProtos.Rpc.HoloBadgeType;
                public static encode(message: POGOProtos.Rpc.SupportedContestTypesSettingsProto.IContestTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SupportedContestTypesSettingsProto.ContestTypeProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SupportedContestTypesSettingsProto.ContestTypeProto;
                public static toObject(message: POGOProtos.Rpc.SupportedContestTypesSettingsProto.ContestTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ISyncBattleInventoryOutProto {
            result?: (POGOProtos.Rpc.SyncBattleInventoryOutProto.Result|null);
        }

        class SyncBattleInventoryOutProto implements ISyncBattleInventoryOutProto {
            constructor(properties?: POGOProtos.Rpc.ISyncBattleInventoryOutProto);
            public result: POGOProtos.Rpc.SyncBattleInventoryOutProto.Result;
            public static encode(message: POGOProtos.Rpc.ISyncBattleInventoryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SyncBattleInventoryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SyncBattleInventoryOutProto;
            public static toObject(message: POGOProtos.Rpc.SyncBattleInventoryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace SyncBattleInventoryOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface ISyncBattleInventoryProto {
        }

        class SyncBattleInventoryProto implements ISyncBattleInventoryProto {
            constructor(properties?: POGOProtos.Rpc.ISyncBattleInventoryProto);
            public static encode(message: POGOProtos.Rpc.ISyncBattleInventoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.SyncBattleInventoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.SyncBattleInventoryProto;
            public static toObject(message: POGOProtos.Rpc.SyncBattleInventoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITakeSnapshotQuestProto {
            unique_pokemon_id?: (POGOProtos.Rpc.HoloPokemonId[]|null);
        }

        class TakeSnapshotQuestProto implements ITakeSnapshotQuestProto {
            constructor(properties?: POGOProtos.Rpc.ITakeSnapshotQuestProto);
            public unique_pokemon_id: POGOProtos.Rpc.HoloPokemonId[];
            public static encode(message: POGOProtos.Rpc.ITakeSnapshotQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TakeSnapshotQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TakeSnapshotQuestProto;
            public static toObject(message: POGOProtos.Rpc.TakeSnapshotQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITappable {
            type?: (POGOProtos.Rpc.Tappable.TappableType|null);
            id?: (number|null);
            count?: (number|null);
            location_hint_lat?: (number|null);
            location_hint_lng?: (number|null);
            encounter_id?: (number|Long|null);
            location?: (POGOProtos.Rpc.ITappableLocation|null);
            tappable_type_id?: (string|null);
            expiration_time_ms?: (number|Long|null);
        }

        class Tappable implements ITappable {
            constructor(properties?: POGOProtos.Rpc.ITappable);
            public type: POGOProtos.Rpc.Tappable.TappableType;
            public id: number;
            public count: number;
            public location_hint_lat: number;
            public location_hint_lng: number;
            public encounter_id: (number|Long);
            public location?: (POGOProtos.Rpc.ITappableLocation|null);
            public tappable_type_id: string;
            public expiration_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ITappable, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Tappable;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Tappable;
            public static toObject(message: POGOProtos.Rpc.Tappable, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Tappable {

            enum TappableType {
                TAPPABLE_TYPE_UNSET = 0,
                TAPPABLE_TYPE_BREAKFAST = 1,
                TAPPABLE_TYPE_ROUTE_PIN = 2,
                TAPPABLE_TYPE_MAPLE = 3
            }
        }

        interface ITappableEncounterProto {
            result?: (POGOProtos.Rpc.TappableEncounterProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            npc_encounter?: (POGOProtos.Rpc.INpcEncounterProto|null);
        }

        class TappableEncounterProto implements ITappableEncounterProto {
            constructor(properties?: POGOProtos.Rpc.ITappableEncounterProto);
            public result: POGOProtos.Rpc.TappableEncounterProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public npc_encounter?: (POGOProtos.Rpc.INpcEncounterProto|null);
            public static encode(message: POGOProtos.Rpc.ITappableEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TappableEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TappableEncounterProto;
            public static toObject(message: POGOProtos.Rpc.TappableEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TappableEncounterProto {

            enum Result {
                TAPPABLE_ENCOUNTER_UNKNOWN = 0,
                TAPPABLE_ENCOUNTER_SUCCESS = 1,
                TAPPABLE_ENCOUNTER_NOT_AVAILABLE = 2,
                TAPPABLE_ENCOUNTER_ALREADY_FINISHED = 3,
                POKEMON_INVENTORY_FULL = 4
            }
        }

        interface ITappableLocation {
            spawnpoint_id?: (string|null);
            fort_id?: (string|null);
        }

        class TappableLocation implements ITappableLocation {
            constructor(properties?: POGOProtos.Rpc.ITappableLocation);
            public spawnpoint_id?: (string|null);
            public fort_id?: (string|null);
            public location_id?: ("spawnpoint_id"|"fort_id");
            public static encode(message: POGOProtos.Rpc.ITappableLocation, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TappableLocation;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TappableLocation;
            public static toObject(message: POGOProtos.Rpc.TappableLocation, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITappableSettingsProto {
            visible_radius_meters?: (number|null);
            spawn_angle_degrees?: (number|null);
            movement_respawn_threshold_meters?: (number|null);
            buddy_fov_degrees?: (number|null);
            buddy_collect_probability?: (number|null);
            disable_player_collection?: (boolean|null);
            avg_tappables_in_view?: (number|null);
            remove_when_tapped?: (boolean|null);
            max_map_clutter_delta?: (number|null);
            type?: (POGOProtos.Rpc.Tappable.TappableType|null);
            tappable_asset_key?: (string|null);
        }

        class TappableSettingsProto implements ITappableSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITappableSettingsProto);
            public visible_radius_meters: number;
            public spawn_angle_degrees: number;
            public movement_respawn_threshold_meters: number;
            public buddy_fov_degrees: number;
            public buddy_collect_probability: number;
            public disable_player_collection: boolean;
            public avg_tappables_in_view: number;
            public remove_when_tapped: boolean;
            public max_map_clutter_delta: number;
            public type: POGOProtos.Rpc.Tappable.TappableType;
            public tappable_asset_key: string;
            public static encode(message: POGOProtos.Rpc.ITappableSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TappableSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TappableSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TappableSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITeamChangeInfoProto {
            last_acquired_time?: (number|Long|null);
            num_items_acquired?: (number|null);
        }

        class TeamChangeInfoProto implements ITeamChangeInfoProto {
            constructor(properties?: POGOProtos.Rpc.ITeamChangeInfoProto);
            public last_acquired_time: (number|Long);
            public num_items_acquired: number;
            public static encode(message: POGOProtos.Rpc.ITeamChangeInfoProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TeamChangeInfoProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TeamChangeInfoProto;
            public static toObject(message: POGOProtos.Rpc.TeamChangeInfoProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITelemetryCommon {
            timestamp?: (number|Long|null);
            correlation_vector?: (string|null);
            event_id?: (string|null);
            client_timestamp_ms?: (number|Long|null);
        }

        class TelemetryCommon implements ITelemetryCommon {
            constructor(properties?: POGOProtos.Rpc.ITelemetryCommon);
            public timestamp: (number|Long);
            public correlation_vector: string;
            public event_id: string;
            public client_timestamp_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ITelemetryCommon, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TelemetryCommon;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TelemetryCommon;
            public static toObject(message: POGOProtos.Rpc.TelemetryCommon, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITelemetryGlobalSettingsProto {
            enabled?: (boolean|null);
            session_sampling_fraction?: (number|null);
            max_buffer_size_kb?: (number|null);
            batch_size?: (number|null);
            update_interval_ms?: (number|Long|null);
            frame_rate_sample_interval_ms?: (number|Long|null);
            frame_rate_sample_period_ms?: (number|Long|null);
            enable_omni_wrapper_sending?: (boolean|null);
            log_pokemon_missing_pokemon_asset_threshold_sec?: (number|null);
            enable_appsflyer_events?: (boolean|null);
            block_appsflyer_events?: (string[]|null);
            enable_ardk_telemetry?: (boolean|null);
        }

        class TelemetryGlobalSettingsProto implements ITelemetryGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITelemetryGlobalSettingsProto);
            public enabled: boolean;
            public session_sampling_fraction: number;
            public max_buffer_size_kb: number;
            public batch_size: number;
            public update_interval_ms: (number|Long);
            public frame_rate_sample_interval_ms: (number|Long);
            public frame_rate_sample_period_ms: (number|Long);
            public enable_omni_wrapper_sending: boolean;
            public log_pokemon_missing_pokemon_asset_threshold_sec: number;
            public enable_appsflyer_events: boolean;
            public block_appsflyer_events: string[];
            public enable_ardk_telemetry: boolean;
            public static encode(message: POGOProtos.Rpc.ITelemetryGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TelemetryGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TelemetryGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TelemetryGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITelemetryRecordResult {
            record_id?: (string|null);
            status?: (POGOProtos.Rpc.TelemetryRecordResult.Status|null);
            telemetry_type_name?: (string|null);
            failure_detail?: (string|null);
            retry_after_ms?: (number|Long|null);
        }

        class TelemetryRecordResult implements ITelemetryRecordResult {
            constructor(properties?: POGOProtos.Rpc.ITelemetryRecordResult);
            public record_id: string;
            public status: POGOProtos.Rpc.TelemetryRecordResult.Status;
            public telemetry_type_name: string;
            public failure_detail: string;
            public retry_after_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ITelemetryRecordResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TelemetryRecordResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TelemetryRecordResult;
            public static toObject(message: POGOProtos.Rpc.TelemetryRecordResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TelemetryRecordResult {

            enum Status {
                unset = 0,
                invalid_request = 10,
                access_denied = 11,
                not_approved_event = 12,
                backend_error = 20,
                throttled = 30
            }
        }

        interface ITelemetryRequestMetadata {
            user_id?: (string|null);
            is_minor?: (boolean|null);
            env_id?: (string|null);
        }

        class TelemetryRequestMetadata implements ITelemetryRequestMetadata {
            constructor(properties?: POGOProtos.Rpc.ITelemetryRequestMetadata);
            public user_id: string;
            public is_minor: boolean;
            public env_id: string;
            public static encode(message: POGOProtos.Rpc.ITelemetryRequestMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TelemetryRequestMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TelemetryRequestMetadata;
            public static toObject(message: POGOProtos.Rpc.TelemetryRequestMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITelemetryRequestProto {
            api_version?: (string|null);
            message_version?: (string|null);
            telemetry_batch?: (Uint8Array|null);
        }

        class TelemetryRequestProto implements ITelemetryRequestProto {
            constructor(properties?: POGOProtos.Rpc.ITelemetryRequestProto);
            public api_version: string;
            public message_version: string;
            public telemetry_batch: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ITelemetryRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TelemetryRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TelemetryRequestProto;
            public static toObject(message: POGOProtos.Rpc.TelemetryRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITelemetryResponseProto {
            status?: (POGOProtos.Rpc.TelemetryResponseProto.Status|null);
            rows_written?: (number|null);
            failure_detail?: (string|null);
            retryable_failures?: (POGOProtos.Rpc.ITelemetryRecordResult[]|null);
            non_retryable_failures?: (POGOProtos.Rpc.ITelemetryRecordResult[]|null);
        }

        class TelemetryResponseProto implements ITelemetryResponseProto {
            constructor(properties?: POGOProtos.Rpc.ITelemetryResponseProto);
            public status: POGOProtos.Rpc.TelemetryResponseProto.Status;
            public rows_written: number;
            public failure_detail: string;
            public retryable_failures: POGOProtos.Rpc.ITelemetryRecordResult[];
            public non_retryable_failures: POGOProtos.Rpc.ITelemetryRecordResult[];
            public static encode(message: POGOProtos.Rpc.ITelemetryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TelemetryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TelemetryResponseProto;
            public static toObject(message: POGOProtos.Rpc.TelemetryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TelemetryResponseProto {

            enum Status {
                unset = 0,
                success = 1,
                failure = 2,
                partial_failure = 3
            }
        }

        interface ITempEvoGlobalSettingsProto {
        }

        class TempEvoGlobalSettingsProto implements ITempEvoGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITempEvoGlobalSettingsProto);
            public static encode(message: POGOProtos.Rpc.ITempEvoGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TempEvoGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TempEvoGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TempEvoGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITempEvoOverrideExtendedProto {
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
        }

        class TempEvoOverrideExtendedProto implements ITempEvoOverrideExtendedProto {
            constructor(properties?: POGOProtos.Rpc.ITempEvoOverrideExtendedProto);
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.ITempEvoOverrideExtendedProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TempEvoOverrideExtendedProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TempEvoOverrideExtendedProto;
            public static toObject(message: POGOProtos.Rpc.TempEvoOverrideExtendedProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITempEvoOverrideProto {
            temp_evo_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            stats?: (POGOProtos.Rpc.IPokemonStatsAttributesProto|null);
            average_height_m?: (number|null);
            average_weight_kg?: (number|null);
            type_override1?: (POGOProtos.Rpc.HoloPokemonType|null);
            type_override2?: (POGOProtos.Rpc.HoloPokemonType|null);
            cp_multiplier_override?: (number|null);
            camera?: (POGOProtos.Rpc.IPokemonCameraAttributesProto|null);
            encounter?: (POGOProtos.Rpc.IPokemonEncounterAttributesProto|null);
            model_scale_v2?: (number|null);
            model_height?: (number|null);
            buddy_offset_male?: (number[]|null);
            buddy_offset_female?: (number[]|null);
            buddy_portrait_offset?: (number[]|null);
            raid_boss_distance_offset?: (number|null);
            size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            buddy_portrait_rotation?: (number[]|null);
        }

        class TempEvoOverrideProto implements ITempEvoOverrideProto {
            constructor(properties?: POGOProtos.Rpc.ITempEvoOverrideProto);
            public temp_evo_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public stats?: (POGOProtos.Rpc.IPokemonStatsAttributesProto|null);
            public average_height_m: number;
            public average_weight_kg: number;
            public type_override1: POGOProtos.Rpc.HoloPokemonType;
            public type_override2: POGOProtos.Rpc.HoloPokemonType;
            public cp_multiplier_override: number;
            public camera?: (POGOProtos.Rpc.IPokemonCameraAttributesProto|null);
            public encounter?: (POGOProtos.Rpc.IPokemonEncounterAttributesProto|null);
            public model_scale_v2: number;
            public model_height: number;
            public buddy_offset_male: number[];
            public buddy_offset_female: number[];
            public buddy_portrait_offset: number[];
            public raid_boss_distance_offset: number;
            public size_settings?: (POGOProtos.Rpc.IPokemonSizeSettingsProto|null);
            public buddy_portrait_rotation: number[];
            public static encode(message: POGOProtos.Rpc.ITempEvoOverrideProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TempEvoOverrideProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TempEvoOverrideProto;
            public static toObject(message: POGOProtos.Rpc.TempEvoOverrideProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITemplateVariable {
            name?: (string|null);
            literal?: (string|null);
            key?: (string|null);
            lookup_table?: (string|null);
            byte_value?: (Uint8Array|null);
        }

        class TemplateVariable implements ITemplateVariable {
            constructor(properties?: POGOProtos.Rpc.ITemplateVariable);
            public name: string;
            public literal: string;
            public key: string;
            public lookup_table: string;
            public byte_value: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ITemplateVariable, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TemplateVariable;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TemplateVariable;
            public static toObject(message: POGOProtos.Rpc.TemplateVariable, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITemporalFrequencyProto {
            weekdays?: (POGOProtos.Rpc.IWeekdaysProto|null);
            time_gap?: (POGOProtos.Rpc.ITimeGapProto|null);
        }

        class TemporalFrequencyProto implements ITemporalFrequencyProto {
            constructor(properties?: POGOProtos.Rpc.ITemporalFrequencyProto);
            public weekdays?: (POGOProtos.Rpc.IWeekdaysProto|null);
            public time_gap?: (POGOProtos.Rpc.ITimeGapProto|null);
            public Frequency?: ("weekdays"|"time_gap");
            public static encode(message: POGOProtos.Rpc.ITemporalFrequencyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TemporalFrequencyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TemporalFrequencyProto;
            public static toObject(message: POGOProtos.Rpc.TemporalFrequencyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITemporaryEvolutionProto {
            temporary_evolution_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            asset_bundle_value?: (number|null);
            asset_bundle_suffix?: (string|null);
        }

        class TemporaryEvolutionProto implements ITemporaryEvolutionProto {
            constructor(properties?: POGOProtos.Rpc.ITemporaryEvolutionProto);
            public temporary_evolution_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public asset_bundle_value: number;
            public asset_bundle_suffix: string;
            public static encode(message: POGOProtos.Rpc.ITemporaryEvolutionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TemporaryEvolutionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TemporaryEvolutionProto;
            public static toObject(message: POGOProtos.Rpc.TemporaryEvolutionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITemporaryEvolutionResourceProto {
            temporary_evolution_id?: (POGOProtos.Rpc.HoloTemporaryEvolutionId|null);
            energy_count?: (number|null);
            max_energy_count?: (number|null);
        }

        class TemporaryEvolutionResourceProto implements ITemporaryEvolutionResourceProto {
            constructor(properties?: POGOProtos.Rpc.ITemporaryEvolutionResourceProto);
            public temporary_evolution_id: POGOProtos.Rpc.HoloTemporaryEvolutionId;
            public energy_count: number;
            public max_energy_count: number;
            public static encode(message: POGOProtos.Rpc.ITemporaryEvolutionResourceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TemporaryEvolutionResourceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TemporaryEvolutionResourceProto;
            public static toObject(message: POGOProtos.Rpc.TemporaryEvolutionResourceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITemporaryEvolutionSettingsProto {
            pokemon?: (POGOProtos.Rpc.HoloPokemonId|null);
            temporary_evolutions?: (POGOProtos.Rpc.ITemporaryEvolutionProto[]|null);
        }

        class TemporaryEvolutionSettingsProto implements ITemporaryEvolutionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITemporaryEvolutionSettingsProto);
            public pokemon: POGOProtos.Rpc.HoloPokemonId;
            public temporary_evolutions: POGOProtos.Rpc.ITemporaryEvolutionProto[];
            public static encode(message: POGOProtos.Rpc.ITemporaryEvolutionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TemporaryEvolutionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TemporaryEvolutionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TemporaryEvolutionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITicketGiftingFeatureSettingsProto {
            enable_notification_history?: (boolean|null);
            enable_optout_setting?: (boolean|null);
        }

        class TicketGiftingFeatureSettingsProto implements ITicketGiftingFeatureSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITicketGiftingFeatureSettingsProto);
            public enable_notification_history: boolean;
            public enable_optout_setting: boolean;
            public static encode(message: POGOProtos.Rpc.ITicketGiftingFeatureSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TicketGiftingFeatureSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TicketGiftingFeatureSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TicketGiftingFeatureSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITicketGiftingSettingsProto {
            min_player_level?: (number|null);
            daily_player_gifting_limit?: (number|null);
            min_required_friendship_level?: (string|null);
        }

        class TicketGiftingSettingsProto implements ITicketGiftingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITicketGiftingSettingsProto);
            public min_player_level: number;
            public daily_player_gifting_limit: number;
            public min_required_friendship_level: string;
            public static encode(message: POGOProtos.Rpc.ITicketGiftingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TicketGiftingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TicketGiftingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TicketGiftingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITierBoostSettingsProto {
            num_stationed?: (number|null);
            hundredths_of_percent?: (number|null);
            num_boost_icons?: (number|null);
        }

        class TierBoostSettingsProto implements ITierBoostSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITierBoostSettingsProto);
            public num_stationed: number;
            public hundredths_of_percent: number;
            public num_boost_icons: number;
            public static encode(message: POGOProtos.Rpc.ITierBoostSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TierBoostSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TierBoostSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TierBoostSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITiledBlob {
            format_version?: (number|null);
            zoom?: (number|null);
            x?: (number|null);
            y?: (number|null);
            epoch?: (number|null);
            content_type?: (POGOProtos.Rpc.TiledBlob.ContentType|null);
            encoded_data?: (Uint8Array|null);
        }

        class TiledBlob implements ITiledBlob {
            constructor(properties?: POGOProtos.Rpc.ITiledBlob);
            public format_version: number;
            public zoom: number;
            public x: number;
            public y: number;
            public epoch: number;
            public content_type: POGOProtos.Rpc.TiledBlob.ContentType;
            public encoded_data: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ITiledBlob, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TiledBlob;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TiledBlob;
            public static toObject(message: POGOProtos.Rpc.TiledBlob, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TiledBlob {

            enum ContentType {
                NIANTIC_VECTOR_MAPTILE = 0,
                BIOME_RASTER_MAPTILE = 1
            }
        }

        interface ITimeBonusSettingsProto {
            affected_items?: (POGOProtos.Rpc.Item[]|null);
        }

        class TimeBonusSettingsProto implements ITimeBonusSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITimeBonusSettingsProto);
            public affected_items: POGOProtos.Rpc.Item[];
            public static encode(message: POGOProtos.Rpc.ITimeBonusSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimeBonusSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimeBonusSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TimeBonusSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimeGapProto {
            unit?: (POGOProtos.Rpc.TimeGapProto.SpanUnit|null);
            quantity?: (number|Long|null);
            offset?: (POGOProtos.Rpc.ITimeGapProto[]|null);
        }

        class TimeGapProto implements ITimeGapProto {
            constructor(properties?: POGOProtos.Rpc.ITimeGapProto);
            public unit: POGOProtos.Rpc.TimeGapProto.SpanUnit;
            public quantity: (number|Long);
            public offset: POGOProtos.Rpc.ITimeGapProto[];
            public static encode(message: POGOProtos.Rpc.ITimeGapProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimeGapProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimeGapProto;
            public static toObject(message: POGOProtos.Rpc.TimeGapProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TimeGapProto {

            enum SpanUnit {
                UNSET = 0,
                MILLISECOND = 1,
                SECOND = 2,
                MINUTE = 3,
                HOUR = 4,
                DAY = 5,
                WEEK = 6,
                MONTH = 7,
                YEAR = 8,
                DECADE = 9
            }
        }

        interface ITimePeriodCounterSettingsProto {
            limit?: (number|null);
        }

        class TimePeriodCounterSettingsProto implements ITimePeriodCounterSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITimePeriodCounterSettingsProto);
            public limit: number;
            public static encode(message: POGOProtos.Rpc.ITimePeriodCounterSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimePeriodCounterSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimePeriodCounterSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TimePeriodCounterSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimeToPlayable {
            resumed_from?: (POGOProtos.Rpc.TimeToPlayable.ResumedFrom|null);
            time_to_play?: (number|null);
        }

        class TimeToPlayable implements ITimeToPlayable {
            constructor(properties?: POGOProtos.Rpc.ITimeToPlayable);
            public resumed_from: POGOProtos.Rpc.TimeToPlayable.ResumedFrom;
            public time_to_play: number;
            public static encode(message: POGOProtos.Rpc.ITimeToPlayable, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimeToPlayable;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimeToPlayable;
            public static toObject(message: POGOProtos.Rpc.TimeToPlayable, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TimeToPlayable {

            enum ResumedFrom {
                UNDEFINED = 0,
                WARM = 1,
                COLD = 2
            }
        }

        interface ITimeWindow {
            start_ms?: (number|Long|null);
            end_ms?: (number|Long|null);
        }

        class TimeWindow implements ITimeWindow {
            constructor(properties?: POGOProtos.Rpc.ITimeWindow);
            public start_ms: (number|Long);
            public end_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.ITimeWindow, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimeWindow;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimeWindow;
            public static toObject(message: POGOProtos.Rpc.TimeWindow, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimedBranchingQuestSectionProto {
            quest_id?: (string|null);
        }

        class TimedBranchingQuestSectionProto implements ITimedBranchingQuestSectionProto {
            constructor(properties?: POGOProtos.Rpc.ITimedBranchingQuestSectionProto);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.ITimedBranchingQuestSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedBranchingQuestSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedBranchingQuestSectionProto;
            public static toObject(message: POGOProtos.Rpc.TimedBranchingQuestSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimedGroupChallengeDefinitionProto {
            challenge_id?: (string|null);
            display?: (POGOProtos.Rpc.IGroupChallengeDisplayProto|null);
            start_time_ms_inclusive?: (number|Long|null);
            end_time_ms_exclusive?: (number|Long|null);
            challenge_criteria?: (POGOProtos.Rpc.IGroupChallengeCriteriaProto|null);
            is_long_challenge?: (boolean|null);
        }

        class TimedGroupChallengeDefinitionProto implements ITimedGroupChallengeDefinitionProto {
            constructor(properties?: POGOProtos.Rpc.ITimedGroupChallengeDefinitionProto);
            public challenge_id: string;
            public display?: (POGOProtos.Rpc.IGroupChallengeDisplayProto|null);
            public start_time_ms_inclusive: (number|Long);
            public end_time_ms_exclusive: (number|Long);
            public challenge_criteria?: (POGOProtos.Rpc.IGroupChallengeCriteriaProto|null);
            public is_long_challenge: boolean;
            public static encode(message: POGOProtos.Rpc.ITimedGroupChallengeDefinitionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedGroupChallengeDefinitionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedGroupChallengeDefinitionProto;
            public static toObject(message: POGOProtos.Rpc.TimedGroupChallengeDefinitionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimedGroupChallengePlayerStatsProto {
            challenges?: (POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IIndividualChallengeStats[]|null);
        }

        class TimedGroupChallengePlayerStatsProto implements ITimedGroupChallengePlayerStatsProto {
            constructor(properties?: POGOProtos.Rpc.ITimedGroupChallengePlayerStatsProto);
            public challenges: POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IIndividualChallengeStats[];
            public static encode(message: POGOProtos.Rpc.ITimedGroupChallengePlayerStatsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto;
            public static toObject(message: POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TimedGroupChallengePlayerStatsProto {

            interface IIndividualChallengeStats {
                challenge_id?: (string|null);
                player_score?: (number|null);
            }

            class IndividualChallengeStats implements IIndividualChallengeStats {
                constructor(properties?: POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IIndividualChallengeStats);
                public challenge_id: string;
                public player_score: number;
                public static encode(message: POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IIndividualChallengeStats, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IndividualChallengeStats;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IndividualChallengeStats;
                public static toObject(message: POGOProtos.Rpc.TimedGroupChallengePlayerStatsProto.IndividualChallengeStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ITimedGroupChallengeSectionProto {
            challenge_id?: (string|null);
            header_image_url?: (string|null);
        }

        class TimedGroupChallengeSectionProto implements ITimedGroupChallengeSectionProto {
            constructor(properties?: POGOProtos.Rpc.ITimedGroupChallengeSectionProto);
            public challenge_id: string;
            public header_image_url: string;
            public static encode(message: POGOProtos.Rpc.ITimedGroupChallengeSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedGroupChallengeSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedGroupChallengeSectionProto;
            public static toObject(message: POGOProtos.Rpc.TimedGroupChallengeSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimedGroupChallengeSettingsProto {
            widget_auto_update_period_ms?: (number|null);
            friend_leaderboard_background_update_period_ms?: (number|Long|null);
            friend_leaderboard_friends_per_rpc?: (number|null);
            refresh_offline_friends_modulus?: (number|null);
            refresh_non_event_friends_modulus?: (number|null);
            timed_group_challenge_version?: (number|null);
        }

        class TimedGroupChallengeSettingsProto implements ITimedGroupChallengeSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITimedGroupChallengeSettingsProto);
            public widget_auto_update_period_ms: number;
            public friend_leaderboard_background_update_period_ms: (number|Long);
            public friend_leaderboard_friends_per_rpc: number;
            public refresh_offline_friends_modulus: number;
            public refresh_non_event_friends_modulus: number;
            public timed_group_challenge_version: number;
            public static encode(message: POGOProtos.Rpc.ITimedGroupChallengeSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedGroupChallengeSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedGroupChallengeSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TimedGroupChallengeSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimedQuestSectionProto {
            quest_id?: (string|null);
        }

        class TimedQuestSectionProto implements ITimedQuestSectionProto {
            constructor(properties?: POGOProtos.Rpc.ITimedQuestSectionProto);
            public quest_id: string;
            public static encode(message: POGOProtos.Rpc.ITimedQuestSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TimedQuestSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TimedQuestSectionProto;
            public static toObject(message: POGOProtos.Rpc.TimedQuestSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITimestamp {
            seconds?: (number|Long|null);
            nanos?: (number|null);
        }

        class Timestamp implements ITimestamp {
            constructor(properties?: POGOProtos.Rpc.ITimestamp);
            public seconds: (number|Long);
            public nanos: number;
            public static encode(message: POGOProtos.Rpc.ITimestamp, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Timestamp;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Timestamp;
            public static toObject(message: POGOProtos.Rpc.Timestamp, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanAsyncFileUploadCompleteOutProto {
            poi_id?: (string|null);
            post_action_game_info?: (Uint8Array|null);
            error?: (POGOProtos.Rpc.TitanAsyncFileUploadCompleteOutProto.ErrorStatus|null);
            submission_type?: (POGOProtos.Rpc.PlayerSubmissionTypeProto|null);
        }

        class TitanAsyncFileUploadCompleteOutProto implements ITitanAsyncFileUploadCompleteOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanAsyncFileUploadCompleteOutProto);
            public poi_id: string;
            public post_action_game_info: Uint8Array;
            public error: POGOProtos.Rpc.TitanAsyncFileUploadCompleteOutProto.ErrorStatus;
            public submission_type: POGOProtos.Rpc.PlayerSubmissionTypeProto;
            public static encode(message: POGOProtos.Rpc.ITitanAsyncFileUploadCompleteOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanAsyncFileUploadCompleteOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanAsyncFileUploadCompleteOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanAsyncFileUploadCompleteOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanAsyncFileUploadCompleteOutProto {

            enum ErrorStatus {
                UNSET = 0,
                SERVER_UPDATE_FAILED = 1,
                MISSING_SUBMISSION_ID = 2,
                MISSING_SUBMISSION_TYPE = 3,
                MISSING_UPLOAD_STATUS = 4
            }
        }

        interface ITitanAsyncFileUploadCompleteProto {
            submission_id?: (string|null);
            upload_status?: (POGOProtos.Rpc.TitanAsyncFileUploadCompleteProto.Status|null);
            ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
        }

        class TitanAsyncFileUploadCompleteProto implements ITitanAsyncFileUploadCompleteProto {
            constructor(properties?: POGOProtos.Rpc.ITitanAsyncFileUploadCompleteProto);
            public submission_id: string;
            public upload_status: POGOProtos.Rpc.TitanAsyncFileUploadCompleteProto.Status;
            public ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            public static encode(message: POGOProtos.Rpc.ITitanAsyncFileUploadCompleteProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanAsyncFileUploadCompleteProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanAsyncFileUploadCompleteProto;
            public static toObject(message: POGOProtos.Rpc.TitanAsyncFileUploadCompleteProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanAsyncFileUploadCompleteProto {

            enum Status {
                UNSET = 0,
                UPLOAD_DONE = 1,
                UPLOAD_FAILED = 2
            }
        }

        interface ITitanAvailableSubmissionsPerSubmissionType {
            submissions_left?: (number|null);
            min_player_level?: (number|null);
            is_feature_enabled?: (boolean|null);
            time_window_for_submissions_limit_ms?: (number|Long|null);
            max_poi_distance_in_meters?: (number|null);
            blacklisted_os?: (string[]|null);
            blacklisted_device_id?: (string[]|null);
            is_whitelisted_user?: (boolean|null);
            is_upload_later_enabled?: (boolean|null);
            daily_new_submissions?: (number|null);
            max_submissions?: (number|null);
            is_wayfarer_onboarding_enabled?: (boolean|null);
            player_submission_type?: (POGOProtos.Rpc.PlayerSubmissionTypeProto|null);
        }

        class TitanAvailableSubmissionsPerSubmissionType implements ITitanAvailableSubmissionsPerSubmissionType {
            constructor(properties?: POGOProtos.Rpc.ITitanAvailableSubmissionsPerSubmissionType);
            public submissions_left: number;
            public min_player_level: number;
            public is_feature_enabled: boolean;
            public time_window_for_submissions_limit_ms: (number|Long);
            public max_poi_distance_in_meters: number;
            public blacklisted_os: string[];
            public blacklisted_device_id: string[];
            public is_whitelisted_user: boolean;
            public is_upload_later_enabled: boolean;
            public daily_new_submissions: number;
            public max_submissions: number;
            public is_wayfarer_onboarding_enabled: boolean;
            public player_submission_type: POGOProtos.Rpc.PlayerSubmissionTypeProto;
            public static encode(message: POGOProtos.Rpc.ITitanAvailableSubmissionsPerSubmissionType, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanAvailableSubmissionsPerSubmissionType;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanAvailableSubmissionsPerSubmissionType;
            public static toObject(message: POGOProtos.Rpc.TitanAvailableSubmissionsPerSubmissionType, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGameClientPhotoGalleryPoiImageProto {
            image_id?: (string|null);
            poi_id?: (string|null);
            submitter_codename?: (string|null);
            image_url?: (string|null);
            creation_timestamp_ms?: (number|Long|null);
            has_player_voted?: (boolean|null);
            num_votes_from_game?: (number|null);
        }

        class TitanGameClientPhotoGalleryPoiImageProto implements ITitanGameClientPhotoGalleryPoiImageProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGameClientPhotoGalleryPoiImageProto);
            public image_id: string;
            public poi_id: string;
            public submitter_codename: string;
            public image_url: string;
            public creation_timestamp_ms: (number|Long);
            public has_player_voted: boolean;
            public num_votes_from_game: number;
            public static encode(message: POGOProtos.Rpc.ITitanGameClientPhotoGalleryPoiImageProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGameClientPhotoGalleryPoiImageProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGameClientPhotoGalleryPoiImageProto;
            public static toObject(message: POGOProtos.Rpc.TitanGameClientPhotoGalleryPoiImageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGenerateGmapSignedUrlOutProto {
            result?: (POGOProtos.Rpc.TitanGenerateGmapSignedUrlOutProto.Result|null);
            signed_url?: (string|null);
        }

        class TitanGenerateGmapSignedUrlOutProto implements ITitanGenerateGmapSignedUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGenerateGmapSignedUrlOutProto);
            public result: POGOProtos.Rpc.TitanGenerateGmapSignedUrlOutProto.Result;
            public signed_url: string;
            public static encode(message: POGOProtos.Rpc.ITitanGenerateGmapSignedUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGenerateGmapSignedUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGenerateGmapSignedUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGenerateGmapSignedUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGenerateGmapSignedUrlOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_NOT_VALID = 2,
                ERROR_RATE_LIMITED = 3,
                ERROR_MISSING_INPUT = 4,
                ERROR_UNKNOWN = 5
            }
        }

        interface ITitanGenerateGmapSignedUrlProto {
            latitude?: (number|null);
            longitude?: (number|null);
            width?: (number|null);
            height?: (number|null);
            zoom?: (number|null);
            language_code?: (string|null);
            country_code?: (string|null);
            map_style?: (string|null);
            map_type?: (string|null);
            icon_params?: (string|null);
            is_multi_marker_map?: (boolean|null);
            original_location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            proposed_location?: (POGOProtos.Rpc.ILocationE6Proto|null);
        }

        class TitanGenerateGmapSignedUrlProto implements ITitanGenerateGmapSignedUrlProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGenerateGmapSignedUrlProto);
            public latitude: number;
            public longitude: number;
            public width: number;
            public height: number;
            public zoom: number;
            public language_code: string;
            public country_code: string;
            public map_style: string;
            public map_type: string;
            public icon_params: string;
            public is_multi_marker_map: boolean;
            public original_location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public proposed_location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public static encode(message: POGOProtos.Rpc.ITitanGenerateGmapSignedUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGenerateGmapSignedUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGenerateGmapSignedUrlProto;
            public static toObject(message: POGOProtos.Rpc.TitanGenerateGmapSignedUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGeodataServiceGameClientPoiProto {
            poi_id?: (string|null);
            title?: (string|null);
            description?: (string|null);
            location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            image_url?: (string|null);
            is_in_game?: (boolean|null);
        }

        class TitanGeodataServiceGameClientPoiProto implements ITitanGeodataServiceGameClientPoiProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGeodataServiceGameClientPoiProto);
            public poi_id: string;
            public title: string;
            public description: string;
            public location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public image_url: string;
            public is_in_game: boolean;
            public static encode(message: POGOProtos.Rpc.ITitanGeodataServiceGameClientPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGeodataServiceGameClientPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGeodataServiceGameClientPoiProto;
            public static toObject(message: POGOProtos.Rpc.TitanGeodataServiceGameClientPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetARMappingSettingsOutProto {
            is_client_scan_validation_enabled?: (boolean|null);
            client_scan_validation_blocked_os?: (string[]|null);
            client_scan_validation_blocked_device_id?: (string[]|null);
        }

        class TitanGetARMappingSettingsOutProto implements ITitanGetARMappingSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetARMappingSettingsOutProto);
            public is_client_scan_validation_enabled: boolean;
            public client_scan_validation_blocked_os: string[];
            public client_scan_validation_blocked_device_id: string[];
            public static encode(message: POGOProtos.Rpc.ITitanGetARMappingSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetARMappingSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetARMappingSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetARMappingSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetARMappingSettingsProto {
        }

        class TitanGetARMappingSettingsProto implements ITitanGetARMappingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetARMappingSettingsProto);
            public static encode(message: POGOProtos.Rpc.ITitanGetARMappingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetARMappingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetARMappingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetARMappingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetAvailableSubmissionsOutProto {
            submissions_left?: (number|null);
            min_player_level?: (number|null);
            has_valid_email?: (boolean|null);
            is_feature_enabled?: (boolean|null);
            time_window_for_submissions_limit_ms?: (number|Long|null);
            max_poi_distance_in_meters?: (number|null);
            availability_result_per_type?: (POGOProtos.Rpc.ITitanAvailableSubmissionsPerSubmissionType[]|null);
            max_poi_location_edit_move_distance_meters?: (number|null);
            is_upload_later_enabled?: (boolean|null);
            category_cloud_storage_directory_path?: (string|null);
            urban_typology_cloud_storage_path?: (string|null);
            has_wayfarer_account?: (boolean|null);
            passed_wayfarer_quiz?: (boolean|null);
            is_poi_submission_category_enabled?: (boolean|null);
        }

        class TitanGetAvailableSubmissionsOutProto implements ITitanGetAvailableSubmissionsOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetAvailableSubmissionsOutProto);
            public submissions_left: number;
            public min_player_level: number;
            public has_valid_email: boolean;
            public is_feature_enabled: boolean;
            public time_window_for_submissions_limit_ms: (number|Long);
            public max_poi_distance_in_meters: number;
            public availability_result_per_type: POGOProtos.Rpc.ITitanAvailableSubmissionsPerSubmissionType[];
            public max_poi_location_edit_move_distance_meters: number;
            public is_upload_later_enabled: boolean;
            public category_cloud_storage_directory_path: string;
            public urban_typology_cloud_storage_path: string;
            public has_wayfarer_account: boolean;
            public passed_wayfarer_quiz: boolean;
            public is_poi_submission_category_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ITitanGetAvailableSubmissionsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetAvailableSubmissionsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetAvailableSubmissionsOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetAvailableSubmissionsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetAvailableSubmissionsProto {
            submission_types?: (POGOProtos.Rpc.PlayerSubmissionTypeProto[]|null);
            submission_type?: (POGOProtos.Rpc.PlayerSubmissionTypeProto|null);
        }

        class TitanGetAvailableSubmissionsProto implements ITitanGetAvailableSubmissionsProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetAvailableSubmissionsProto);
            public submission_types: POGOProtos.Rpc.PlayerSubmissionTypeProto[];
            public submission_type: POGOProtos.Rpc.PlayerSubmissionTypeProto;
            public static encode(message: POGOProtos.Rpc.ITitanGetAvailableSubmissionsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetAvailableSubmissionsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetAvailableSubmissionsProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetAvailableSubmissionsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetGmapSettingsOutProto {
            result?: (POGOProtos.Rpc.TitanGetGmapSettingsOutProto.Result|null);
            gmap_template_url?: (string|null);
            max_poi_distance_in_meters?: (number|null);
            min_zoom?: (number|null);
            max_zoom?: (number|null);
        }

        class TitanGetGmapSettingsOutProto implements ITitanGetGmapSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetGmapSettingsOutProto);
            public result: POGOProtos.Rpc.TitanGetGmapSettingsOutProto.Result;
            public gmap_template_url: string;
            public max_poi_distance_in_meters: number;
            public min_zoom: number;
            public max_zoom: number;
            public static encode(message: POGOProtos.Rpc.ITitanGetGmapSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetGmapSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetGmapSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetGmapSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGetGmapSettingsOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_MISSING_CONFIG = 3,
                ERROR_NO_UNIQUE_ID = 4
            }
        }

        interface ITitanGetGmapSettingsProto {
        }

        class TitanGetGmapSettingsProto implements ITitanGetGmapSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetGmapSettingsProto);
            public static encode(message: POGOProtos.Rpc.ITitanGetGmapSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetGmapSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetGmapSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetGmapSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetGrapeshotUploadUrlOutProto {
            status?: (POGOProtos.Rpc.TitanGetGrapeshotUploadUrlOutProto.Status|null);
            file_context_to_grapeshot_data?: ({ [k: string]: POGOProtos.Rpc.ITitanGrapeshotUploadingDataProto }|null);
            file_context_to_signed_url?: ({ [k: string]: string }|null);
        }

        class TitanGetGrapeshotUploadUrlOutProto implements ITitanGetGrapeshotUploadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlOutProto);
            public status: POGOProtos.Rpc.TitanGetGrapeshotUploadUrlOutProto.Status;
            public file_context_to_grapeshot_data: { [k: string]: POGOProtos.Rpc.ITitanGrapeshotUploadingDataProto };
            public file_context_to_signed_url: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetGrapeshotUploadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetGrapeshotUploadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetGrapeshotUploadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGetGrapeshotUploadUrlOutProto {

            enum Status {
                UNSET = 0,
                FAILURE = 1,
                SUCCESS = 2,
                MISSING_FILE_CONTEXTS = 3,
                DUPLICATE_FILE_CONTEXT = 4,
                MISSING_SUBMISSION_TYPE = 5,
                MISSING_SUBMISSION_ID = 6,
                ALREADY_UPLOADED = 7
            }
        }

        interface ITitanGetGrapeshotUploadUrlProto {
            submission_id?: (string|null);
            file_upload_context?: (string[]|null);
            developer_id?: (string|null);
            submission_type?: (POGOProtos.Rpc.PlayerSubmissionTypeProto|null);
        }

        class TitanGetGrapeshotUploadUrlProto implements ITitanGetGrapeshotUploadUrlProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlProto);
            public submission_id: string;
            public file_upload_context: string[];
            public developer_id: string;
            public submission_type: POGOProtos.Rpc.PlayerSubmissionTypeProto;
            public static encode(message: POGOProtos.Rpc.ITitanGetGrapeshotUploadUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetGrapeshotUploadUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetGrapeshotUploadUrlProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetGrapeshotUploadUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetImageGallerySettingsOutProto {
            is_image_gallery_enabled?: (boolean|null);
            max_periodic_image_loaded_count?: (number|null);
        }

        class TitanGetImageGallerySettingsOutProto implements ITitanGetImageGallerySettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetImageGallerySettingsOutProto);
            public is_image_gallery_enabled: boolean;
            public max_periodic_image_loaded_count: number;
            public static encode(message: POGOProtos.Rpc.ITitanGetImageGallerySettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetImageGallerySettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetImageGallerySettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetImageGallerySettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetImageGallerySettingsProto {
        }

        class TitanGetImageGallerySettingsProto implements ITitanGetImageGallerySettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetImageGallerySettingsProto);
            public static encode(message: POGOProtos.Rpc.ITitanGetImageGallerySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetImageGallerySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetImageGallerySettingsProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetImageGallerySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetImagesForPoiOutProto {
            status?: (POGOProtos.Rpc.TitanGetImagesForPoiOutProto.Status|null);
            photo_gallery_poi_images?: (POGOProtos.Rpc.ITitanGameClientPhotoGalleryPoiImageProto[]|null);
        }

        class TitanGetImagesForPoiOutProto implements ITitanGetImagesForPoiOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetImagesForPoiOutProto);
            public status: POGOProtos.Rpc.TitanGetImagesForPoiOutProto.Status;
            public photo_gallery_poi_images: POGOProtos.Rpc.ITitanGameClientPhotoGalleryPoiImageProto[];
            public static encode(message: POGOProtos.Rpc.ITitanGetImagesForPoiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetImagesForPoiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetImagesForPoiOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetImagesForPoiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGetImagesForPoiOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                POI_NOT_FOUND = 2,
                INVALID_REQUEST = 3
            }
        }

        interface ITitanGetImagesForPoiProto {
            poi_id?: (string|null);
        }

        class TitanGetImagesForPoiProto implements ITitanGetImagesForPoiProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetImagesForPoiProto);
            public poi_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanGetImagesForPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetImagesForPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetImagesForPoiProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetImagesForPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetMapDataOutProto {
            status?: (POGOProtos.Rpc.TitanGetMapDataOutProto.Status|null);
            pois?: (POGOProtos.Rpc.ITitanGeodataServiceGameClientPoiProto[]|null);
        }

        class TitanGetMapDataOutProto implements ITitanGetMapDataOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetMapDataOutProto);
            public status: POGOProtos.Rpc.TitanGetMapDataOutProto.Status;
            public pois: POGOProtos.Rpc.ITitanGeodataServiceGameClientPoiProto[];
            public static encode(message: POGOProtos.Rpc.ITitanGetMapDataOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetMapDataOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetMapDataOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetMapDataOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGetMapDataOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_REQUEST = 2,
                INTERNAL_ERROR = 3
            }
        }

        interface ITitanGetMapDataProto {
            geodata_types?: (POGOProtos.Rpc.TitanGeodataType[]|null);
            northeast_point?: (POGOProtos.Rpc.ILocationE6Proto|null);
            southwest_point?: (POGOProtos.Rpc.ILocationE6Proto|null);
            api_key?: (string|null);
        }

        class TitanGetMapDataProto implements ITitanGetMapDataProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetMapDataProto);
            public geodata_types: POGOProtos.Rpc.TitanGeodataType[];
            public northeast_point?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public southwest_point?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public api_key: string;
            public static encode(message: POGOProtos.Rpc.ITitanGetMapDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetMapDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetMapDataProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetMapDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetPlayerSubmissionValidationSettingsOutProto {
            banned_metadata_text?: (string[]|null);
        }

        class TitanGetPlayerSubmissionValidationSettingsOutProto implements ITitanGetPlayerSubmissionValidationSettingsOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsOutProto);
            public banned_metadata_text: string[];
            public static encode(message: POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetPlayerSubmissionValidationSettingsOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetPlayerSubmissionValidationSettingsOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetPlayerSubmissionValidationSettingsOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetPlayerSubmissionValidationSettingsProto {
        }

        class TitanGetPlayerSubmissionValidationSettingsProto implements ITitanGetPlayerSubmissionValidationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsProto);
            public static encode(message: POGOProtos.Rpc.ITitanGetPlayerSubmissionValidationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetPlayerSubmissionValidationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetPlayerSubmissionValidationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetPlayerSubmissionValidationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetPoisInRadiusOutProto {
            status?: (POGOProtos.Rpc.TitanGetPoisInRadiusOutProto.Status|null);
            pois?: (POGOProtos.Rpc.ITitanGeodataServiceGameClientPoiProto[]|null);
        }

        class TitanGetPoisInRadiusOutProto implements ITitanGetPoisInRadiusOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetPoisInRadiusOutProto);
            public status: POGOProtos.Rpc.TitanGetPoisInRadiusOutProto.Status;
            public pois: POGOProtos.Rpc.ITitanGeodataServiceGameClientPoiProto[];
            public static encode(message: POGOProtos.Rpc.ITitanGetPoisInRadiusOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetPoisInRadiusOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetPoisInRadiusOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetPoisInRadiusOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGetPoisInRadiusOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INTERNAL_ERROR = 2
            }
        }

        interface ITitanGetPoisInRadiusProto {
            location?: (POGOProtos.Rpc.ILocationE6Proto|null);
        }

        class TitanGetPoisInRadiusProto implements ITitanGetPoisInRadiusProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetPoisInRadiusProto);
            public location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public static encode(message: POGOProtos.Rpc.ITitanGetPoisInRadiusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetPoisInRadiusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetPoisInRadiusProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetPoisInRadiusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGetUploadUrlOutProto {
            status?: (POGOProtos.Rpc.TitanGetUploadUrlOutProto.Status|null);
            signed_url?: (string|null);
            supporting_image_signed_url?: (string|null);
            context_signed_urls?: ({ [k: string]: string }|null);
        }

        class TitanGetUploadUrlOutProto implements ITitanGetUploadUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetUploadUrlOutProto);
            public status: POGOProtos.Rpc.TitanGetUploadUrlOutProto.Status;
            public signed_url: string;
            public supporting_image_signed_url: string;
            public context_signed_urls: { [k: string]: string };
            public static encode(message: POGOProtos.Rpc.ITitanGetUploadUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetUploadUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetUploadUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetUploadUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanGetUploadUrlOutProto {

            enum Status {
                UNSET = 0,
                FAILURES = 1,
                SUCCESS = 2,
                MISSING_IMAGE_CONTEXTS = 3,
                DUPLICATE_IMAGE_CONTEXTS = 4,
                ALREADY_UPLOADED = 5
            }
        }

        interface ITitanGetUploadUrlProto {
            user_id?: (string|null);
            game_unique_id?: (string|null);
            submission_type?: (POGOProtos.Rpc.PlayerSubmissionTypeProto|null);
            submission_id?: (string|null);
            image_contexts?: (string[]|null);
        }

        class TitanGetUploadUrlProto implements ITitanGetUploadUrlProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGetUploadUrlProto);
            public user_id: string;
            public game_unique_id: string;
            public submission_type: POGOProtos.Rpc.PlayerSubmissionTypeProto;
            public submission_id: string;
            public image_contexts: string[];
            public static encode(message: POGOProtos.Rpc.ITitanGetUploadUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGetUploadUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGetUploadUrlProto;
            public static toObject(message: POGOProtos.Rpc.TitanGetUploadUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGrapeshotAuthenticationDataProto {
            authorization?: (string|null);
            date?: (string|null);
        }

        class TitanGrapeshotAuthenticationDataProto implements ITitanGrapeshotAuthenticationDataProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto);
            public authorization: string;
            public date: string;
            public static encode(message: POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGrapeshotAuthenticationDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGrapeshotAuthenticationDataProto;
            public static toObject(message: POGOProtos.Rpc.TitanGrapeshotAuthenticationDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGrapeshotChunkDataProto {
            chunk_file_path?: (string|null);
            chunk_number?: (number|null);
            upload_authentication?: (POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto|null);
            delete_authentication?: (POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto|null);
        }

        class TitanGrapeshotChunkDataProto implements ITitanGrapeshotChunkDataProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGrapeshotChunkDataProto);
            public chunk_file_path: string;
            public chunk_number: number;
            public upload_authentication?: (POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto|null);
            public delete_authentication?: (POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto|null);
            public static encode(message: POGOProtos.Rpc.ITitanGrapeshotChunkDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGrapeshotChunkDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGrapeshotChunkDataProto;
            public static toObject(message: POGOProtos.Rpc.TitanGrapeshotChunkDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGrapeshotComposeDataProto {
            target_file_path?: (string|null);
            authentication?: (POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto|null);
            hash?: (string|null);
        }

        class TitanGrapeshotComposeDataProto implements ITitanGrapeshotComposeDataProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGrapeshotComposeDataProto);
            public target_file_path: string;
            public authentication?: (POGOProtos.Rpc.ITitanGrapeshotAuthenticationDataProto|null);
            public hash: string;
            public static encode(message: POGOProtos.Rpc.ITitanGrapeshotComposeDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGrapeshotComposeDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGrapeshotComposeDataProto;
            public static toObject(message: POGOProtos.Rpc.TitanGrapeshotComposeDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanGrapeshotUploadingDataProto {
            chunk_data?: (POGOProtos.Rpc.ITitanGrapeshotChunkDataProto[]|null);
            compose_data?: (POGOProtos.Rpc.ITitanGrapeshotComposeDataProto|null);
            gcs_bucket?: (string|null);
            number_of_chunks?: (number|null);
        }

        class TitanGrapeshotUploadingDataProto implements ITitanGrapeshotUploadingDataProto {
            constructor(properties?: POGOProtos.Rpc.ITitanGrapeshotUploadingDataProto);
            public chunk_data: POGOProtos.Rpc.ITitanGrapeshotChunkDataProto[];
            public compose_data?: (POGOProtos.Rpc.ITitanGrapeshotComposeDataProto|null);
            public gcs_bucket: string;
            public number_of_chunks: number;
            public static encode(message: POGOProtos.Rpc.ITitanGrapeshotUploadingDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanGrapeshotUploadingDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanGrapeshotUploadingDataProto;
            public static toObject(message: POGOProtos.Rpc.TitanGrapeshotUploadingDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanPlayerSubmissionResponseProto {
            status?: (POGOProtos.Rpc.TitanPlayerSubmissionResponseProto.Status|null);
            submission_id?: (string|null);
            messages?: (string[]|null);
        }

        class TitanPlayerSubmissionResponseProto implements ITitanPlayerSubmissionResponseProto {
            constructor(properties?: POGOProtos.Rpc.ITitanPlayerSubmissionResponseProto);
            public status: POGOProtos.Rpc.TitanPlayerSubmissionResponseProto.Status;
            public submission_id: string;
            public messages: string[];
            public static encode(message: POGOProtos.Rpc.ITitanPlayerSubmissionResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanPlayerSubmissionResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanPlayerSubmissionResponseProto;
            public static toObject(message: POGOProtos.Rpc.TitanPlayerSubmissionResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanPlayerSubmissionResponseProto {

            enum Status {
                STATUS_UNSPECIFIED = 0,
                SUCCESS = 1,
                INTERNAL_ERROR = 2,
                TOO_MANY_RECENT_SUBMISSIONS = 3,
                MINOR = 4,
                NOT_AVAILABLE = 5,
                INVALID_INPUT = 6,
                MISSING_IMAGE = 7,
                DISTANCE_VALIDATION_FAILED = 8,
                ACTIVATION_REQUEST_FAILED = 9
            }
        }

        interface ITitanPoiPlayerMetadataTelemetry {
            device_model?: (string|null);
            device_os?: (string|null);
        }

        class TitanPoiPlayerMetadataTelemetry implements ITitanPoiPlayerMetadataTelemetry {
            constructor(properties?: POGOProtos.Rpc.ITitanPoiPlayerMetadataTelemetry);
            public device_model: string;
            public device_os: string;
            public static encode(message: POGOProtos.Rpc.ITitanPoiPlayerMetadataTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanPoiPlayerMetadataTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanPoiPlayerMetadataTelemetry;
            public static toObject(message: POGOProtos.Rpc.TitanPoiPlayerMetadataTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanPoiSubmissionPhotoUploadErrorTelemetry {
            error_id?: (POGOProtos.Rpc.TitanPoiSubmissionPhotoUploadErrorTelemetry.PoiSubmissionPhotoUploadErrorIds|null);
            image_type?: (POGOProtos.Rpc.TitanPoiImageType|null);
            error_message?: (string|null);
        }

        class TitanPoiSubmissionPhotoUploadErrorTelemetry implements ITitanPoiSubmissionPhotoUploadErrorTelemetry {
            constructor(properties?: POGOProtos.Rpc.ITitanPoiSubmissionPhotoUploadErrorTelemetry);
            public error_id: POGOProtos.Rpc.TitanPoiSubmissionPhotoUploadErrorTelemetry.PoiSubmissionPhotoUploadErrorIds;
            public image_type: POGOProtos.Rpc.TitanPoiImageType;
            public error_message: string;
            public static encode(message: POGOProtos.Rpc.ITitanPoiSubmissionPhotoUploadErrorTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanPoiSubmissionPhotoUploadErrorTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanPoiSubmissionPhotoUploadErrorTelemetry;
            public static toObject(message: POGOProtos.Rpc.TitanPoiSubmissionPhotoUploadErrorTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanPoiSubmissionPhotoUploadErrorTelemetry {

            enum PoiSubmissionPhotoUploadErrorIds {
                UNSET = 0,
                POI_PHOTO_UPLOAD_ERROR = 1,
                POI_PHOTO_UPLOAD_TIMEOUT = 2
            }
        }

        interface ITitanPoiSubmissionTelemetry {
            gui_event_id?: (POGOProtos.Rpc.TitanPoiSubmissionTelemetry.PoiSubmissionGuiEventId|null);
            image_type?: (POGOProtos.Rpc.TitanPoiImageType|null);
            camera_step_id?: (POGOProtos.Rpc.TitanPoiSubmissionTelemetry.PoiCameraStepIds|null);
        }

        class TitanPoiSubmissionTelemetry implements ITitanPoiSubmissionTelemetry {
            constructor(properties?: POGOProtos.Rpc.ITitanPoiSubmissionTelemetry);
            public gui_event_id: POGOProtos.Rpc.TitanPoiSubmissionTelemetry.PoiSubmissionGuiEventId;
            public image_type: POGOProtos.Rpc.TitanPoiImageType;
            public camera_step_id: POGOProtos.Rpc.TitanPoiSubmissionTelemetry.PoiCameraStepIds;
            public static encode(message: POGOProtos.Rpc.ITitanPoiSubmissionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanPoiSubmissionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanPoiSubmissionTelemetry;
            public static toObject(message: POGOProtos.Rpc.TitanPoiSubmissionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanPoiSubmissionTelemetry {

            enum PoiCameraStepIds {
                UNSET = 0,
                ENTER = 1,
                RETAKE = 2,
                CONFIRM = 3,
                EXIT = 4
            }

            enum PoiSubmissionGuiEventId {
                UNKNOWN = 0,
                POI_NOMINATION_ENTER = 1,
                POI_TUTORIAL_COMPLETE = 2,
                POI_MAP_CHANGEDVIEW_MAP = 3,
                POI_MAP_CHANGEDVIEW_SATELLITE = 4,
                POI_MAP_CENTER_LOCATION = 5,
                POI_LOCATION_SET = 6,
                POI_PHOTO_CAMERA_ENTER = 7,
                POI_PHOTO_CAMERA_EXIT = 8,
                POI_TITLE_ENTERED = 9,
                POI_DESCRIPTION_ENTER = 10,
                POI_DETAILS_CONFIRM = 11,
                POI_SUPPORTINGINFO_ENTER = 12,
                POI_SUBMIT_BUTTON_HIT = 13,
                POI_EXIT_BUTTON_HIT = 14
            }
        }

        interface ITitanPoiVideoSubmissionMetadataProto {
            poi_id?: (string|null);
            location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            player_level?: (number|null);
            is_private?: (boolean|null);
            geographic_coverage?: (string|null);
            developer_id?: (string|null);
            ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            user_type?: (POGOProtos.Rpc.UserType|null);
        }

        class TitanPoiVideoSubmissionMetadataProto implements ITitanPoiVideoSubmissionMetadataProto {
            constructor(properties?: POGOProtos.Rpc.ITitanPoiVideoSubmissionMetadataProto);
            public poi_id: string;
            public location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public player_level: number;
            public is_private: boolean;
            public geographic_coverage: string;
            public developer_id: string;
            public ar_common_metadata?: (POGOProtos.Rpc.IARDKARCommonMetadata|null);
            public user_type: POGOProtos.Rpc.UserType;
            public static encode(message: POGOProtos.Rpc.ITitanPoiVideoSubmissionMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanPoiVideoSubmissionMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanPoiVideoSubmissionMetadataProto;
            public static toObject(message: POGOProtos.Rpc.TitanPoiVideoSubmissionMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanPortalCurationImageResult {
        }

        class TitanPortalCurationImageResult implements ITitanPortalCurationImageResult {
            constructor(properties?: POGOProtos.Rpc.ITitanPortalCurationImageResult);
            public static encode(message: POGOProtos.Rpc.ITitanPortalCurationImageResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanPortalCurationImageResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanPortalCurationImageResult;
            public static toObject(message: POGOProtos.Rpc.TitanPortalCurationImageResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanPortalCurationImageResult {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FEATURE_DISABLED = 2,
                ALREADY_UPLOADED = 3,
                IMAGE_NOT_FOUND = 4,
                IMAGE_TOO_BIG = 5,
                IMAGE_NOT_SERVABLE = 6,
                PORTAL_NOT_FOUND = 7
            }
        }

        interface ITitanSubmitMappingRequestProto {
            poi_id?: (string|null);
            nomination_type?: (POGOProtos.Rpc.NominationType|null);
            developer_id?: (string|null);
        }

        class TitanSubmitMappingRequestProto implements ITitanSubmitMappingRequestProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitMappingRequestProto);
            public poi_id: string;
            public nomination_type: POGOProtos.Rpc.NominationType;
            public developer_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitMappingRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitMappingRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitMappingRequestProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitMappingRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitNewPoiOutProto {
            status?: (POGOProtos.Rpc.TitanSubmitNewPoiOutProto.Status|null);
            submission_id?: (string|null);
            messages?: (string[]|null);
            poi_id?: (string|null);
        }

        class TitanSubmitNewPoiOutProto implements ITitanSubmitNewPoiOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitNewPoiOutProto);
            public status: POGOProtos.Rpc.TitanSubmitNewPoiOutProto.Status;
            public submission_id: string;
            public messages: string[];
            public poi_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitNewPoiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitNewPoiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitNewPoiOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitNewPoiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanSubmitNewPoiOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2,
                INTERNAL_ERROR = 3,
                TOO_MANY_RECENT_SUBMISSIONS = 4,
                INVALID_INPUT = 5,
                MINOR = 6,
                NOT_AVAILABLE = 7,
                ALREADY_EXISTS = 8
            }
        }

        interface ITitanSubmitNewPoiProto {
            title?: (string|null);
            long_description?: (string|null);
            lat_e6?: (number|null);
            lng_e6?: (number|null);
            supporting_statement?: (string|null);
            async_file_upload?: (boolean|null);
            player_submitted_category_ids?: (string[]|null);
            category_suggestion?: (string|null);
            developer_id?: (string|null);
            nomination_type?: (POGOProtos.Rpc.NominationType|null);
        }

        class TitanSubmitNewPoiProto implements ITitanSubmitNewPoiProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitNewPoiProto);
            public title: string;
            public long_description: string;
            public lat_e6: number;
            public lng_e6: number;
            public supporting_statement: string;
            public async_file_upload: boolean;
            public player_submitted_category_ids: string[];
            public category_suggestion: string;
            public developer_id: string;
            public nomination_type: POGOProtos.Rpc.NominationType;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitNewPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitNewPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitNewPoiProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitNewPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitPlayerImageVoteForPoiOutProto {
            status?: (POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiOutProto.Status|null);
        }

        class TitanSubmitPlayerImageVoteForPoiOutProto implements ITitanSubmitPlayerImageVoteForPoiOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiOutProto);
            public status: POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TitanSubmitPlayerImageVoteForPoiOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                POI_NOT_FOUND = 2,
                POI_IMAGE_NOT_FOUND = 3,
                INVALID_REQUEST = 6
            }
        }

        interface ITitanSubmitPlayerImageVoteForPoiProto {
            image_ids_to_vote_for?: (string[]|null);
            image_ids_to_unvote?: (string[]|null);
            poi_id?: (string|null);
        }

        class TitanSubmitPlayerImageVoteForPoiProto implements ITitanSubmitPlayerImageVoteForPoiProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiProto);
            public image_ids_to_vote_for: string[];
            public image_ids_to_unvote: string[];
            public poi_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPlayerImageVoteForPoiProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPlayerImageVoteForPoiProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitPoiCategoryVoteRecordProto {
            poi_id?: (string|null);
            player_submitted_category_ids?: (string[]|null);
            category_suggestion?: (string|null);
            developer_id?: (string|null);
        }

        class TitanSubmitPoiCategoryVoteRecordProto implements ITitanSubmitPoiCategoryVoteRecordProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPoiCategoryVoteRecordProto);
            public poi_id: string;
            public player_submitted_category_ids: string[];
            public category_suggestion: string;
            public developer_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPoiCategoryVoteRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPoiCategoryVoteRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPoiCategoryVoteRecordProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPoiCategoryVoteRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitPoiImageProto {
            poi_id?: (string|null);
            async_file_upload?: (boolean|null);
            developer_id?: (string|null);
            nomination_type?: (POGOProtos.Rpc.NominationType|null);
        }

        class TitanSubmitPoiImageProto implements ITitanSubmitPoiImageProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPoiImageProto);
            public poi_id: string;
            public async_file_upload: boolean;
            public developer_id: string;
            public nomination_type: POGOProtos.Rpc.NominationType;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPoiImageProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPoiImageProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPoiImageProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPoiImageProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitPoiLocationUpdateProto {
            poi_id?: (string|null);
            location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            developer_id?: (string|null);
        }

        class TitanSubmitPoiLocationUpdateProto implements ITitanSubmitPoiLocationUpdateProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPoiLocationUpdateProto);
            public poi_id: string;
            public location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public developer_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPoiLocationUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPoiLocationUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPoiLocationUpdateProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPoiLocationUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitPoiTakedownRequestProto {
            poi_id?: (string|null);
            invalid_reason?: (POGOProtos.Rpc.PoiInvalidReason|null);
            developer_id?: (string|null);
            supporting_statement?: (string|null);
        }

        class TitanSubmitPoiTakedownRequestProto implements ITitanSubmitPoiTakedownRequestProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPoiTakedownRequestProto);
            public poi_id: string;
            public invalid_reason: POGOProtos.Rpc.PoiInvalidReason;
            public developer_id: string;
            public supporting_statement: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPoiTakedownRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPoiTakedownRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPoiTakedownRequestProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPoiTakedownRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitPoiTextMetadataUpdateProto {
            poi_id?: (string|null);
            title?: (string|null);
            description?: (string|null);
            developer_id?: (string|null);
        }

        class TitanSubmitPoiTextMetadataUpdateProto implements ITitanSubmitPoiTextMetadataUpdateProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitPoiTextMetadataUpdateProto);
            public poi_id: string;
            public title: string;
            public description: string;
            public developer_id: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitPoiTextMetadataUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitPoiTextMetadataUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitPoiTextMetadataUpdateProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitPoiTextMetadataUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitSponsorPoiLocationUpdateProto {
            poi_id?: (string|null);
            location?: (POGOProtos.Rpc.ILocationE6Proto|null);
        }

        class TitanSubmitSponsorPoiLocationUpdateProto implements ITitanSubmitSponsorPoiLocationUpdateProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitSponsorPoiLocationUpdateProto);
            public poi_id: string;
            public location?: (POGOProtos.Rpc.ILocationE6Proto|null);
            public static encode(message: POGOProtos.Rpc.ITitanSubmitSponsorPoiLocationUpdateProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitSponsorPoiLocationUpdateProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitSponsorPoiLocationUpdateProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitSponsorPoiLocationUpdateProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanSubmitSponsorPoiReportProto {
            poi_id?: (string|null);
            invalid_reason?: (POGOProtos.Rpc.SponsorPoiInvalidReason|null);
            additional_details?: (string|null);
        }

        class TitanSubmitSponsorPoiReportProto implements ITitanSubmitSponsorPoiReportProto {
            constructor(properties?: POGOProtos.Rpc.ITitanSubmitSponsorPoiReportProto);
            public poi_id: string;
            public invalid_reason: POGOProtos.Rpc.SponsorPoiInvalidReason;
            public additional_details: string;
            public static encode(message: POGOProtos.Rpc.ITitanSubmitSponsorPoiReportProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanSubmitSponsorPoiReportProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanSubmitSponsorPoiReportProto;
            public static toObject(message: POGOProtos.Rpc.TitanSubmitSponsorPoiReportProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanTitanGameClientTelemetryOmniProto {
            poi_submission_telemetry?: (POGOProtos.Rpc.ITitanPoiSubmissionTelemetry|null);
            poi_submission_photo_upload_error_telemetry?: (POGOProtos.Rpc.ITitanPoiSubmissionPhotoUploadErrorTelemetry|null);
            player_metadata_telemetry?: (POGOProtos.Rpc.ITitanPoiPlayerMetadataTelemetry|null);
            server_data?: (POGOProtos.Rpc.IPlatformServerData|null);
        }

        class TitanTitanGameClientTelemetryOmniProto implements ITitanTitanGameClientTelemetryOmniProto {
            constructor(properties?: POGOProtos.Rpc.ITitanTitanGameClientTelemetryOmniProto);
            public poi_submission_telemetry?: (POGOProtos.Rpc.ITitanPoiSubmissionTelemetry|null);
            public poi_submission_photo_upload_error_telemetry?: (POGOProtos.Rpc.ITitanPoiSubmissionPhotoUploadErrorTelemetry|null);
            public player_metadata_telemetry?: (POGOProtos.Rpc.ITitanPoiPlayerMetadataTelemetry|null);
            public server_data?: (POGOProtos.Rpc.IPlatformServerData|null);
            public TelemetryData?: ("poi_submission_telemetry"|"poi_submission_photo_upload_error_telemetry"|"player_metadata_telemetry");
            public static encode(message: POGOProtos.Rpc.ITitanTitanGameClientTelemetryOmniProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanTitanGameClientTelemetryOmniProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanTitanGameClientTelemetryOmniProto;
            public static toObject(message: POGOProtos.Rpc.TitanTitanGameClientTelemetryOmniProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanUploadPoiPhotoByUrlOutProto {
            status?: (POGOProtos.Rpc.TitanPortalCurationImageResult.Result|null);
        }

        class TitanUploadPoiPhotoByUrlOutProto implements ITitanUploadPoiPhotoByUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.ITitanUploadPoiPhotoByUrlOutProto);
            public status: POGOProtos.Rpc.TitanPortalCurationImageResult.Result;
            public static encode(message: POGOProtos.Rpc.ITitanUploadPoiPhotoByUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanUploadPoiPhotoByUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanUploadPoiPhotoByUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.TitanUploadPoiPhotoByUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITitanUploadPoiPhotoByUrlProto {
            request_id?: (string|null);
            image_url?: (string|null);
        }

        class TitanUploadPoiPhotoByUrlProto implements ITitanUploadPoiPhotoByUrlProto {
            constructor(properties?: POGOProtos.Rpc.ITitanUploadPoiPhotoByUrlProto);
            public request_id: string;
            public image_url: string;
            public static encode(message: POGOProtos.Rpc.ITitanUploadPoiPhotoByUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TitanUploadPoiPhotoByUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TitanUploadPoiPhotoByUrlProto;
            public static toObject(message: POGOProtos.Rpc.TitanUploadPoiPhotoByUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITodayViewProto {
            sections?: (POGOProtos.Rpc.ITodayViewSectionProto[]|null);
        }

        class TodayViewProto implements ITodayViewProto {
            constructor(properties?: POGOProtos.Rpc.ITodayViewProto);
            public sections: POGOProtos.Rpc.ITodayViewSectionProto[];
            public static encode(message: POGOProtos.Rpc.ITodayViewProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TodayViewProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TodayViewProto;
            public static toObject(message: POGOProtos.Rpc.TodayViewProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITodayViewSectionProto {
            pokecoin?: (POGOProtos.Rpc.IPokecoinSectionProto|null);
            gym_pokemon?: (POGOProtos.Rpc.IGymPokemonSectionProto|null);
            streaks?: (POGOProtos.Rpc.IDailyStreaksProto|null);
            event?: (POGOProtos.Rpc.IEventSectionProto|null);
            up_next?: (POGOProtos.Rpc.IUpNextSectionProto|null);
            timed_quest?: (POGOProtos.Rpc.ITimedQuestSectionProto|null);
            event_banner?: (POGOProtos.Rpc.IEventBannerSectionProto|null);
            timed_group_challenge?: (POGOProtos.Rpc.ITimedGroupChallengeSectionProto|null);
            mini_collection?: (POGOProtos.Rpc.IMiniCollectionSectionProto|null);
            stamp_cards?: (POGOProtos.Rpc.IStampCardSectionProto|null);
            challenge_quests?: (POGOProtos.Rpc.IChallengeQuestSectionProto|null);
            story_quests?: (POGOProtos.Rpc.IStoryQuestSectionProto|null);
            happening_now?: (POGOProtos.Rpc.IHappeningNowSectionProto|null);
            current_events?: (POGOProtos.Rpc.ICurrentEventsSectionProto|null);
            upcoming_events?: (POGOProtos.Rpc.IUpcomingEventsSectionProto|null);
            contest_pokemon?: (POGOProtos.Rpc.IContestPokemonSectionProto|null);
            stationed_pokemon?: (POGOProtos.Rpc.IStationedSectionProto|null);
            timed_branching_quest?: (POGOProtos.Rpc.ITimedBranchingQuestSectionProto|null);
            event_pass?: (POGOProtos.Rpc.IEventPassSectionProto|null);
            training_pokemon?: (POGOProtos.Rpc.ITrainingPokemonSectionProto|null);
        }

        class TodayViewSectionProto implements ITodayViewSectionProto {
            constructor(properties?: POGOProtos.Rpc.ITodayViewSectionProto);
            public pokecoin?: (POGOProtos.Rpc.IPokecoinSectionProto|null);
            public gym_pokemon?: (POGOProtos.Rpc.IGymPokemonSectionProto|null);
            public streaks?: (POGOProtos.Rpc.IDailyStreaksProto|null);
            public event?: (POGOProtos.Rpc.IEventSectionProto|null);
            public up_next?: (POGOProtos.Rpc.IUpNextSectionProto|null);
            public timed_quest?: (POGOProtos.Rpc.ITimedQuestSectionProto|null);
            public event_banner?: (POGOProtos.Rpc.IEventBannerSectionProto|null);
            public timed_group_challenge?: (POGOProtos.Rpc.ITimedGroupChallengeSectionProto|null);
            public mini_collection?: (POGOProtos.Rpc.IMiniCollectionSectionProto|null);
            public stamp_cards?: (POGOProtos.Rpc.IStampCardSectionProto|null);
            public challenge_quests?: (POGOProtos.Rpc.IChallengeQuestSectionProto|null);
            public story_quests?: (POGOProtos.Rpc.IStoryQuestSectionProto|null);
            public happening_now?: (POGOProtos.Rpc.IHappeningNowSectionProto|null);
            public current_events?: (POGOProtos.Rpc.ICurrentEventsSectionProto|null);
            public upcoming_events?: (POGOProtos.Rpc.IUpcomingEventsSectionProto|null);
            public contest_pokemon?: (POGOProtos.Rpc.IContestPokemonSectionProto|null);
            public stationed_pokemon?: (POGOProtos.Rpc.IStationedSectionProto|null);
            public timed_branching_quest?: (POGOProtos.Rpc.ITimedBranchingQuestSectionProto|null);
            public event_pass?: (POGOProtos.Rpc.IEventPassSectionProto|null);
            public training_pokemon?: (POGOProtos.Rpc.ITrainingPokemonSectionProto|null);
            public Section?: ("pokecoin"|"gym_pokemon"|"streaks"|"event"|"up_next"|"timed_quest"|"event_banner"|"timed_group_challenge"|"mini_collection"|"stamp_cards"|"challenge_quests"|"story_quests"|"happening_now"|"current_events"|"upcoming_events"|"contest_pokemon"|"stationed_pokemon"|"timed_branching_quest"|"event_pass"|"training_pokemon");
            public static encode(message: POGOProtos.Rpc.ITodayViewSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TodayViewSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TodayViewSectionProto;
            public static toObject(message: POGOProtos.Rpc.TodayViewSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITodayViewSettingsProto {
            skip_dialog_enabled?: (boolean|null);
            pin_claimable_quest_enabled?: (boolean|null);
            notification_server_authoritative?: (boolean|null);
            favorite_quest_enabled?: (boolean|null);
        }

        class TodayViewSettingsProto implements ITodayViewSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITodayViewSettingsProto);
            public skip_dialog_enabled: boolean;
            public pin_claimable_quest_enabled: boolean;
            public notification_server_authoritative: boolean;
            public favorite_quest_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ITodayViewSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TodayViewSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TodayViewSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TodayViewSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITopicProto {
            topic_id?: (string|null);
            namespace?: (string|null);
        }

        class TopicProto implements ITopicProto {
            constructor(properties?: POGOProtos.Rpc.ITopicProto);
            public topic_id: string;
            public namespace: string;
            public static encode(message: POGOProtos.Rpc.ITopicProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TopicProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TopicProto;
            public static toObject(message: POGOProtos.Rpc.TopicProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITrackedPokemonProto {
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
        }

        class TrackedPokemonProto implements ITrackedPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ITrackedPokemonProto);
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public static encode(message: POGOProtos.Rpc.ITrackedPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TrackedPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TrackedPokemonProto;
            public static toObject(message: POGOProtos.Rpc.TrackedPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITrackedPokemonPushNotificationTelemetry {
            category?: (string|null);
            template_id?: (string|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
        }

        class TrackedPokemonPushNotificationTelemetry implements ITrackedPokemonPushNotificationTelemetry {
            constructor(properties?: POGOProtos.Rpc.ITrackedPokemonPushNotificationTelemetry);
            public category: string;
            public template_id: string;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public static encode(message: POGOProtos.Rpc.ITrackedPokemonPushNotificationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TrackedPokemonPushNotificationTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TrackedPokemonPushNotificationTelemetry;
            public static toObject(message: POGOProtos.Rpc.TrackedPokemonPushNotificationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITradePokemonQuestProto {
            friend_id?: (string[]|null);
        }

        class TradePokemonQuestProto implements ITradePokemonQuestProto {
            constructor(properties?: POGOProtos.Rpc.ITradePokemonQuestProto);
            public friend_id: string[];
            public static encode(message: POGOProtos.Rpc.ITradePokemonQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradePokemonQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradePokemonQuestProto;
            public static toObject(message: POGOProtos.Rpc.TradePokemonQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITradingGlobalSettingsProto {
            enable_trading?: (boolean|null);
            min_player_level?: (number|null);
        }

        class TradingGlobalSettingsProto implements ITradingGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITradingGlobalSettingsProto);
            public enable_trading: boolean;
            public min_player_level: number;
            public static encode(message: POGOProtos.Rpc.ITradingGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradingGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradingGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TradingGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITradingLogEntry {
            result?: (POGOProtos.Rpc.TradingLogEntry.Result|null);
            friend_codename?: (string|null);
            trade_out_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            trade_in_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            price?: (POGOProtos.Rpc.ILootProto|null);
        }

        class TradingLogEntry implements ITradingLogEntry {
            constructor(properties?: POGOProtos.Rpc.ITradingLogEntry);
            public result: POGOProtos.Rpc.TradingLogEntry.Result;
            public friend_codename: string;
            public trade_out_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public trade_in_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public price?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.ITradingLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradingLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradingLogEntry;
            public static toObject(message: POGOProtos.Rpc.TradingLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TradingLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface ITradingProto {
            state?: (POGOProtos.Rpc.TradingProto.TradingState|null);
            expiration_ms?: (number|Long|null);
            player?: (POGOProtos.Rpc.TradingProto.ITradingPlayerProto|null);
            friend?: (POGOProtos.Rpc.TradingProto.ITradingPlayerProto|null);
            trading_s2_cell_id?: (number|Long|null);
            transaction_log?: (string|null);
            friendship_level_data?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            is_special_trading?: (boolean|null);
            pre_trading_friendship_level?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            is_lucky_friend_trading?: (boolean|null);
        }

        class TradingProto implements ITradingProto {
            constructor(properties?: POGOProtos.Rpc.ITradingProto);
            public state: POGOProtos.Rpc.TradingProto.TradingState;
            public expiration_ms: (number|Long);
            public player?: (POGOProtos.Rpc.TradingProto.ITradingPlayerProto|null);
            public friend?: (POGOProtos.Rpc.TradingProto.ITradingPlayerProto|null);
            public trading_s2_cell_id: (number|Long);
            public transaction_log: string;
            public friendship_level_data?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            public is_special_trading: boolean;
            public pre_trading_friendship_level?: (POGOProtos.Rpc.IFriendshipLevelDataProto|null);
            public is_lucky_friend_trading: boolean;
            public static encode(message: POGOProtos.Rpc.ITradingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradingProto;
            public static toObject(message: POGOProtos.Rpc.TradingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TradingProto {

            enum TradingState {
                UNSET_TRADINGSTATE = 0,
                PRIMORDIAL = 1,
                WAIT = 2,
                ACTIVE = 3,
                CONFIRMED = 4,
                FINISHED = 5
            }

            interface ITradingPlayerProto {
                player_id?: (string|null);
                public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                excluded_pokemon?: (POGOProtos.Rpc.TradingProto.TradingPlayerProto.IExcludedPokemon[]|null);
                trading_pokemon?: (POGOProtos.Rpc.TradingProto.ITradingPokemonProto|null);
                bonus?: (POGOProtos.Rpc.ILootProto|null);
                price?: (POGOProtos.Rpc.ILootProto|null);
                can_afford_trading?: (boolean|null);
                has_confirmed?: (boolean|null);
                nia_account_id?: (string|null);
            }

            class TradingPlayerProto implements ITradingPlayerProto {
                constructor(properties?: POGOProtos.Rpc.TradingProto.ITradingPlayerProto);
                public player_id: string;
                public public_profile?: (POGOProtos.Rpc.IPlayerPublicProfileProto|null);
                public excluded_pokemon: POGOProtos.Rpc.TradingProto.TradingPlayerProto.IExcludedPokemon[];
                public trading_pokemon?: (POGOProtos.Rpc.TradingProto.ITradingPokemonProto|null);
                public bonus?: (POGOProtos.Rpc.ILootProto|null);
                public price?: (POGOProtos.Rpc.ILootProto|null);
                public can_afford_trading: boolean;
                public has_confirmed: boolean;
                public nia_account_id: string;
                public static encode(message: POGOProtos.Rpc.TradingProto.ITradingPlayerProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradingProto.TradingPlayerProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradingProto.TradingPlayerProto;
                public static toObject(message: POGOProtos.Rpc.TradingProto.TradingPlayerProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace TradingPlayerProto {

                interface IExcludedPokemon {
                    pokemon_id?: (number|Long|null);
                    exclusion_reason?: (POGOProtos.Rpc.TradingProto.TradingPlayerProto.ExcludedPokemon.ExclusionReason|null);
                }

                class ExcludedPokemon implements IExcludedPokemon {
                    constructor(properties?: POGOProtos.Rpc.TradingProto.TradingPlayerProto.IExcludedPokemon);
                    public pokemon_id: (number|Long);
                    public exclusion_reason: POGOProtos.Rpc.TradingProto.TradingPlayerProto.ExcludedPokemon.ExclusionReason;
                    public static encode(message: POGOProtos.Rpc.TradingProto.TradingPlayerProto.IExcludedPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradingProto.TradingPlayerProto.ExcludedPokemon;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradingProto.TradingPlayerProto.ExcludedPokemon;
                    public static toObject(message: POGOProtos.Rpc.TradingProto.TradingPlayerProto.ExcludedPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace ExcludedPokemon {

                    enum ExclusionReason {
                        UNSET_EXCLUSIONREASON = 0,
                        MYTHICAL_POKEMON = 1,
                        SLASHED = 2,
                        GYM_DEPLOYED = 3,
                        BUDDY = 4,
                        STAMINA_NOT_FULL = 5,
                        EGG_NOT_HATCHED = 6,
                        FRIENDSHIP_LEVEL_LOW = 7,
                        FRIEND_CANNOT_AFFORD = 8,
                        FRIEND_REACHED_DAILY_LIMIT = 9,
                        ALREADY_TRADED = 10,
                        PLAYER_CANNOT_AFFORD = 11,
                        PLAYER_REACHED_DAILY_LIMIT = 12,
                        FAVORITE = 13,
                        TEMP_EVOLVED = 14,
                        FUSION_POKEMON = 15,
                        FUSION_COMPONENT_POKEMON = 16,
                        LAST_BREAD_POKEMON = 17
                    }
                }
            }

            interface ITradingPokemonProto {
                pokemon_id?: (number|Long|null);
                pokedex_entry_number?: (number|null);
                original_cp?: (number|null);
                adjusted_cp_min?: (number|null);
                adjusted_cp_max?: (number|null);
                original_stamina?: (number|null);
                adjusted_stamina_min?: (number|null);
                adjusted_stamina_max?: (number|null);
                friend_level_cap?: (boolean|null);
                move1?: (POGOProtos.Rpc.HoloPokemonMove|null);
                move2?: (POGOProtos.Rpc.HoloPokemonMove|null);
                pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                captured_s2_cell_id?: (number|Long|null);
                traded_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                pokeball?: (POGOProtos.Rpc.Item|null);
                individual_attack?: (number|null);
                individual_defense?: (number|null);
                individual_stamina?: (number|null);
                nickname?: (string|null);
                favorite?: (boolean|null);
                move3?: (POGOProtos.Rpc.HoloPokemonMove|null);
                creation_time_ms?: (number|Long|null);
                height_m?: (number|null);
                weight_kg?: (number|null);
                pokemon_size?: (POGOProtos.Rpc.HoloPokemonSize|null);
                bread_move_slots?: (POGOProtos.Rpc.IBreadMoveSlotProto[]|null);
            }

            class TradingPokemonProto implements ITradingPokemonProto {
                constructor(properties?: POGOProtos.Rpc.TradingProto.ITradingPokemonProto);
                public pokemon_id: (number|Long);
                public pokedex_entry_number: number;
                public original_cp: number;
                public adjusted_cp_min: number;
                public adjusted_cp_max: number;
                public original_stamina: number;
                public adjusted_stamina_min: number;
                public adjusted_stamina_max: number;
                public friend_level_cap: boolean;
                public move1: POGOProtos.Rpc.HoloPokemonMove;
                public move2: POGOProtos.Rpc.HoloPokemonMove;
                public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
                public captured_s2_cell_id: (number|Long);
                public traded_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
                public pokeball: POGOProtos.Rpc.Item;
                public individual_attack: number;
                public individual_defense: number;
                public individual_stamina: number;
                public nickname: string;
                public favorite: boolean;
                public move3: POGOProtos.Rpc.HoloPokemonMove;
                public creation_time_ms: (number|Long);
                public height_m: number;
                public weight_kg: number;
                public pokemon_size: POGOProtos.Rpc.HoloPokemonSize;
                public bread_move_slots: POGOProtos.Rpc.IBreadMoveSlotProto[];
                public static encode(message: POGOProtos.Rpc.TradingProto.ITradingPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TradingProto.TradingPokemonProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TradingProto.TradingPokemonProto;
                public static toObject(message: POGOProtos.Rpc.TradingProto.TradingPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ITrainingCourseQuestProto {
            stat_type?: (POGOProtos.Rpc.PokemonIndividualStatType|null);
            quests?: (POGOProtos.Rpc.IPerStatTrainingCourseQuestProto[]|null);
        }

        class TrainingCourseQuestProto implements ITrainingCourseQuestProto {
            constructor(properties?: POGOProtos.Rpc.ITrainingCourseQuestProto);
            public stat_type: POGOProtos.Rpc.PokemonIndividualStatType;
            public quests: POGOProtos.Rpc.IPerStatTrainingCourseQuestProto[];
            public static encode(message: POGOProtos.Rpc.ITrainingCourseQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TrainingCourseQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TrainingCourseQuestProto;
            public static toObject(message: POGOProtos.Rpc.TrainingCourseQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITrainingPokemonProto {
            pokemon_id?: (number|Long|null);
            quest_ids_to_complete?: (string[]|null);
        }

        class TrainingPokemonProto implements ITrainingPokemonProto {
            constructor(properties?: POGOProtos.Rpc.ITrainingPokemonProto);
            public pokemon_id: (number|Long);
            public quest_ids_to_complete: string[];
            public static encode(message: POGOProtos.Rpc.ITrainingPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TrainingPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TrainingPokemonProto;
            public static toObject(message: POGOProtos.Rpc.TrainingPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITrainingPokemonSectionProto {
            training_pokemon?: (POGOProtos.Rpc.TrainingPokemonSectionProto.ITrainingPokemonProto[]|null);
        }

        class TrainingPokemonSectionProto implements ITrainingPokemonSectionProto {
            constructor(properties?: POGOProtos.Rpc.ITrainingPokemonSectionProto);
            public training_pokemon: POGOProtos.Rpc.TrainingPokemonSectionProto.ITrainingPokemonProto[];
            public static encode(message: POGOProtos.Rpc.ITrainingPokemonSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TrainingPokemonSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TrainingPokemonSectionProto;
            public static toObject(message: POGOProtos.Rpc.TrainingPokemonSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TrainingPokemonSectionProto {

            interface ITrainingPokemonProto {
                pokemon_id?: (number|Long|null);
                training_quests?: (POGOProtos.Rpc.IPokemonTrainingQuestProto|null);
            }

            class TrainingPokemonProto implements ITrainingPokemonProto {
                constructor(properties?: POGOProtos.Rpc.TrainingPokemonSectionProto.ITrainingPokemonProto);
                public pokemon_id: (number|Long);
                public training_quests?: (POGOProtos.Rpc.IPokemonTrainingQuestProto|null);
                public static encode(message: POGOProtos.Rpc.TrainingPokemonSectionProto.ITrainingPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TrainingPokemonSectionProto.TrainingPokemonProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TrainingPokemonSectionProto.TrainingPokemonProto;
                public static toObject(message: POGOProtos.Rpc.TrainingPokemonSectionProto.TrainingPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ITransferContestEntryOutProto {
            status?: (POGOProtos.Rpc.TransferContestEntryOutProto.Status|null);
        }

        class TransferContestEntryOutProto implements ITransferContestEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.ITransferContestEntryOutProto);
            public status: POGOProtos.Rpc.TransferContestEntryOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ITransferContestEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransferContestEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransferContestEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.TransferContestEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TransferContestEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                OUT_OF_RANGE = 3,
                ENTRY_TO_REMOVE_NOT_FOUND = 4,
                POKEMON_ID_TO_TRANSFER_MISSING = 5,
                POKEMON_TO_TRANSFER_DIFFERENT = 6,
                CONTEST_LIMIT_REACHED = 7,
                POKEMON_ID_TO_REPLACE_MISSING = 8,
                CONTEST_ID_TO_REMOVE_MISSING = 9,
                POKEMON_TO_REPLACE_NOT_FOUND = 10,
                POKEMON_TO_REPLACE_DIFFERENT = 11,
                PENDING_REWARD_ENTRY_NOT_ALLOWED = 12
            }
        }

        interface ITransferContestEntryProto {
            fort_id?: (string|null);
            contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            contest_id_to_remove?: (string|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id?: (number|Long|null);
            pokemon_id_to_transfer?: (number|Long|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
            pokemon_id_to_replace?: (number|Long|null);
            entry_point?: (POGOProtos.Rpc.EntryPointForContestEntry|null);
        }

        class TransferContestEntryProto implements ITransferContestEntryProto {
            constructor(properties?: POGOProtos.Rpc.ITransferContestEntryProto);
            public fort_id: string;
            public contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public contest_id_to_remove: string;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id: (number|Long);
            public pokemon_id_to_transfer: (number|Long);
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public pokemon_id_to_replace: (number|Long);
            public entry_point: POGOProtos.Rpc.EntryPointForContestEntry;
            public static encode(message: POGOProtos.Rpc.ITransferContestEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransferContestEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransferContestEntryProto;
            public static toObject(message: POGOProtos.Rpc.TransferContestEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITransferPokemonSizeLeaderboardEntryOutProto {
            status?: (POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryOutProto.Status|null);
        }

        class TransferPokemonSizeLeaderboardEntryOutProto implements ITransferPokemonSizeLeaderboardEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryOutProto);
            public status: POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryOutProto.Status;
            public static encode(message: POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TransferPokemonSizeLeaderboardEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                OUT_OF_RANGE = 3,
                ENTRY_TO_REMOVE_NOT_FOUND = 4,
                POKEMON_ID_TO_TRANSFER_MISSING = 5,
                POKEMON_TO_TRANSFER_DIFFERENT = 6,
                CONTEST_LIMIT_REACHED = 7,
                POKEMON_ID_TO_REPLACE_MISSING = 8,
                CONTEST_ID_TO_REMOVE_MISSING = 9,
                POKEMON_TO_REPLACE_NOT_FOUND = 10,
                POKEMON_TO_REPLACE_DIFFERENT = 11,
                PENDING_REWARD_ENTRY_NOT_ALLOWED = 12
            }
        }

        interface ITransferPokemonSizeLeaderboardEntryProto {
            fort_id?: (string|null);
            contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            contest_id_to_remove?: (string|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id?: (number|Long|null);
            pokemon_id_to_transfer?: (number|Long|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
            pokemon_id_to_replace?: (number|Long|null);
            entry_point?: (POGOProtos.Rpc.EntryPointForContestEntry|null);
        }

        class TransferPokemonSizeLeaderboardEntryProto implements ITransferPokemonSizeLeaderboardEntryProto {
            constructor(properties?: POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryProto);
            public fort_id: string;
            public contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public contest_id_to_remove: string;
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id: (number|Long);
            public pokemon_id_to_transfer: (number|Long);
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public pokemon_id_to_replace: (number|Long);
            public entry_point: POGOProtos.Rpc.EntryPointForContestEntry;
            public static encode(message: POGOProtos.Rpc.ITransferPokemonSizeLeaderboardEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryProto;
            public static toObject(message: POGOProtos.Rpc.TransferPokemonSizeLeaderboardEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITransferPokemonToPokemonHomeOutProto {
            status?: (POGOProtos.Rpc.TransferPokemonToPokemonHomeOutProto.Status|null);
            candy_awarded?: (number|null);
            xl_candy_awarded?: (number|null);
            xl_candy_awarded_per_id?: ({ [k: string]: number }|null);
        }

        class TransferPokemonToPokemonHomeOutProto implements ITransferPokemonToPokemonHomeOutProto {
            constructor(properties?: POGOProtos.Rpc.ITransferPokemonToPokemonHomeOutProto);
            public status: POGOProtos.Rpc.TransferPokemonToPokemonHomeOutProto.Status;
            public candy_awarded: number;
            public xl_candy_awarded: number;
            public xl_candy_awarded_per_id: { [k: string]: number };
            public static encode(message: POGOProtos.Rpc.ITransferPokemonToPokemonHomeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransferPokemonToPokemonHomeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransferPokemonToPokemonHomeOutProto;
            public static toObject(message: POGOProtos.Rpc.TransferPokemonToPokemonHomeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TransferPokemonToPokemonHomeOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                ERROR_NO_NAID_LINKED = 3,
                ERROR_TOO_MANY_POKEMON = 4,
                ERROR_SERVER_CLIENT_ENERGY_COST_MISMATCH = 5,
                ERROR_INSUFFICIENT_ENERGY = 6,
                ERROR_TRANSFER_IN_PROGRESS = 7,
                ERROR_POKEMON_DEPLOYED = 10,
                ERROR_POKEMON_IS_EGG = 11,
                ERROR_POKEMON_IS_BUDDY = 12,
                ERROR_POKEMON_BAD = 13,
                ERROR_POKEMON_IS_MEGA = 14,
                ERROR_POKEMON_FAVORITED = 15,
                ERROR_POKEMON_NOT_FOUND = 16,
                ERROR_VALIDATION_UNKNOWN = 17,
                ERROR_POKEMON_HAS_COSTUME = 21,
                ERROR_POKEMON_IS_SHADOW = 22,
                ERROR_POKEMON_DISALLOWED = 23,
                ERROR_FUSION_POKEMON = 24,
                ERROR_FUSION_COMPONENT_POKEMON = 25,
                ERROR_POKEMON_IS_LAST_MAX = 26,
                ERROR_POKEMON_IS_GMAX = 27,
                ERROR_PHAPI_REQUEST_BODY_FALSE = 30,
                ERROR_PHAPI_REQUEST_PARAMETERS_DNE = 31,
                ERROR_PHAPI_REQUEST_PARAMETERS_FALSE = 32,
                ERROR_PHAPI_MAINTENANCE = 33,
                ERROR_PHAPI_SERVICE_ENDED = 34,
                ERROR_PHAPI_UNKNOWN = 35,
                ERROR_PHAPI_NAID_DOES_NOT_EXIST = 36,
                ERROR_PHAPI_NO_SPACE_IN_BOX = 37,
                ERROR_PHAPI_DATA_CONVERSION_FAILURE = 38,
                ERROR_PHAPI_WAITING_FOR_RECEIPT = 39,
                ERROR_PHAPI_PLAYER_NOT_USING_PH_APP = 40
            }
        }

        interface ITransferPokemonToPokemonHomeProto {
            total_energy_cost?: (number|null);
            pokemon_uuid?: ((number|Long)[]|null);
        }

        class TransferPokemonToPokemonHomeProto implements ITransferPokemonToPokemonHomeProto {
            constructor(properties?: POGOProtos.Rpc.ITransferPokemonToPokemonHomeProto);
            public total_energy_cost: number;
            public pokemon_uuid: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.ITransferPokemonToPokemonHomeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransferPokemonToPokemonHomeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransferPokemonToPokemonHomeProto;
            public static toObject(message: POGOProtos.Rpc.TransferPokemonToPokemonHomeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITransform {
            translation?: (POGOProtos.Rpc.IVector3|null);
            rotation?: (POGOProtos.Rpc.IQuaternion|null);
        }

        class Transform implements ITransform {
            constructor(properties?: POGOProtos.Rpc.ITransform);
            public translation?: (POGOProtos.Rpc.IVector3|null);
            public rotation?: (POGOProtos.Rpc.IQuaternion|null);
            public static encode(message: POGOProtos.Rpc.ITransform, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Transform;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Transform;
            public static toObject(message: POGOProtos.Rpc.Transform, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITransitMetadata {
            route?: (string|null);
            agency?: (string|null);
            color_name?: (string|null);
        }

        class TransitMetadata implements ITransitMetadata {
            constructor(properties?: POGOProtos.Rpc.ITransitMetadata);
            public route: string;
            public agency: string;
            public color_name: string;
            public static encode(message: POGOProtos.Rpc.ITransitMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TransitMetadata;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TransitMetadata;
            public static toObject(message: POGOProtos.Rpc.TransitMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITranslationSettingsProto {
            translation_bundle_ids?: (string[]|null);
        }

        class TranslationSettingsProto implements ITranslationSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITranslationSettingsProto);
            public translation_bundle_ids: string[];
            public static encode(message: POGOProtos.Rpc.ITranslationSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TranslationSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TranslationSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TranslationSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITravelRouteQuestProto {
            route_id?: (string[]|null);
        }

        class TravelRouteQuestProto implements ITravelRouteQuestProto {
            constructor(properties?: POGOProtos.Rpc.ITravelRouteQuestProto);
            public route_id: string[];
            public static encode(message: POGOProtos.Rpc.ITravelRouteQuestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TravelRouteQuestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TravelRouteQuestProto;
            public static toObject(message: POGOProtos.Rpc.TravelRouteQuestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITriangleList {
            coords?: (number[]|null);
            exterior_edges?: (Uint8Array|null);
        }

        class TriangleList implements ITriangleList {
            constructor(properties?: POGOProtos.Rpc.ITriangleList);
            public coords: number[];
            public exterior_edges: Uint8Array;
            public static encode(message: POGOProtos.Rpc.ITriangleList, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TriangleList;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TriangleList;
            public static toObject(message: POGOProtos.Rpc.TriangleList, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TriangleList {

            enum ExteriorEdgeBit {
                NO_BIT = 0,
                EDGE_V0_V1 = 1,
                EDGE_V1_V2 = 2,
                EDGE_V2_V0 = 4
            }
        }

        interface ITutorialCreateDetail {
            caught_in_wild?: (boolean|null);
        }

        class TutorialCreateDetail implements ITutorialCreateDetail {
            constructor(properties?: POGOProtos.Rpc.ITutorialCreateDetail);
            public caught_in_wild: boolean;
            public static encode(message: POGOProtos.Rpc.ITutorialCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TutorialCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TutorialCreateDetail;
            public static toObject(message: POGOProtos.Rpc.TutorialCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITutorialIapItemProto {
            tutorial?: (POGOProtos.Rpc.TutorialCompletion|null);
            iap_item_sku?: (string|null);
        }

        class TutorialIapItemProto implements ITutorialIapItemProto {
            constructor(properties?: POGOProtos.Rpc.ITutorialIapItemProto);
            public tutorial: POGOProtos.Rpc.TutorialCompletion;
            public iap_item_sku: string;
            public static encode(message: POGOProtos.Rpc.ITutorialIapItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TutorialIapItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TutorialIapItemProto;
            public static toObject(message: POGOProtos.Rpc.TutorialIapItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITutorialItemRewardsProto {
            tutorial?: (POGOProtos.Rpc.TutorialCompletion|null);
            item?: (POGOProtos.Rpc.IItemProto[]|null);
        }

        class TutorialItemRewardsProto implements ITutorialItemRewardsProto {
            constructor(properties?: POGOProtos.Rpc.ITutorialItemRewardsProto);
            public tutorial: POGOProtos.Rpc.TutorialCompletion;
            public item: POGOProtos.Rpc.IItemProto[];
            public static encode(message: POGOProtos.Rpc.ITutorialItemRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TutorialItemRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TutorialItemRewardsProto;
            public static toObject(message: POGOProtos.Rpc.TutorialItemRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITutorialTelemetry {
            telemetry_id?: (POGOProtos.Rpc.TutorialTelemetry.TutorialTelemetryId|null);
        }

        class TutorialTelemetry implements ITutorialTelemetry {
            constructor(properties?: POGOProtos.Rpc.ITutorialTelemetry);
            public telemetry_id: POGOProtos.Rpc.TutorialTelemetry.TutorialTelemetryId;
            public static encode(message: POGOProtos.Rpc.ITutorialTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TutorialTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TutorialTelemetry;
            public static toObject(message: POGOProtos.Rpc.TutorialTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TutorialTelemetry {

            enum TutorialTelemetryId {
                UNDEFINED = 0,
                TAG_LEARN_MORE_BUTTON_CLICKED = 1,
                TAG_POPUP_TUTORIAL_SHOWN = 2,
                FRIEND_LIST_LEARN_MORE_BUTTON_CLICKED = 3,
                FRIEND_DETAIL_HELP_BUTTON_CLICKED = 4,
                TASK_TUTORIAL_CURVE_BALL_VIEWED = 5,
                TASK_TUTORIAL_THROW_TYPE_VIEWED = 6,
                TASK_TUTORIAL_GIFT_VIEWED = 7,
                TASK_TUTORIAL_TRADING_VIEWED = 8,
                TASK_TUTORIAL_SNAPSHOT_WILD_VIEWED = 9,
                TASK_TUTORIAL_SNAPSHOT_INVENTORY_VIEWED = 10,
                TASK_TUTORIAL_SNAPSHOT_BUDDY_VIEWED = 11,
                GIFT_TUTORIAL_INTRODUCTION_SHOWN = 12,
                PLAYER_VIEWED_GIFT_TUTORIAL = 13,
                PLAYER_SKIPPED_GIFT_TUTORIAL = 14,
                PLAYER_COMPLETED_GIFT_TUTORIAL = 15,
                LURE_TUTORIAL_INTRODUCTION_SHOWN = 16,
                PLAYER_VIEWED_LURE_TUTORIAL = 17,
                PLAYER_SKIPPED_LURE_TUTORIAL = 18,
                PLAYER_COMPLETED_LURE_TUTORIAL = 19,
                GYM_TUTORIAL_BUTTON_CLICKED = 20,
                RAID_TUTORIAL_BUTTON_CLICKED = 21,
                POTION_AND_REVIVE_TUTORIAL_INTRODUCTION_SHOWN = 22,
                PLAYER_COMPLETED_REVIVE_TUTORIAL = 23,
                PLAYER_COMPLETED_POTION_TUTORIAL = 24,
                BERRY_CATCH_TUTORIAL_SHOWN = 25,
                TRADE_TUTORIAL_INTRODUCTION_SHOWN = 26,
                PLAYER_VIEWED_TRADING_TUTORIAL = 27,
                PLAYER_SKIPPED_TRADING_TUTORIAL = 28,
                PLAYER_COMPLETED_TRADING_TUTORIAL = 29,
                LUCKY_TRADE_TUTORIAL_SHOWN = 30,
                LUCKY_FRIENDS_UNLOCKED_TUTORIAL_SHOWN = 31,
                LUCKY_FRIENDS_TUTORIAL_BUTTON_CLICKED = 32
            }
        }

        interface ITutorialsSettingsProto {
            loading_screen_tips_enabled?: (boolean|null);
            friends_tutorial_enabled?: (boolean|null);
            gifts_tutorial_enabled?: (boolean|null);
            task_help_tutorials_enabled?: (boolean|null);
            revives_and_potions_tutorial_enabled?: (boolean|null);
            razzberry_catch_tutorial_enabled?: (boolean|null);
            lures_tutorial_enabled?: (boolean|null);
            trading_tutorial_enabled?: (boolean|null);
            lucky_trade_tutorial_enabled?: (boolean|null);
            lucky_friend_tutorial_enabled?: (boolean|null);
            pokemon_tagging_tutorial_enabled?: (boolean|null);
            tutorial_item_rewards?: (POGOProtos.Rpc.ITutorialItemRewardsProto[]|null);
            type_effectiveness_tips_enabled?: (boolean|null);
            show_strong_encounter_ticket_page?: (boolean|null);
        }

        class TutorialsSettingsProto implements ITutorialsSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITutorialsSettingsProto);
            public loading_screen_tips_enabled: boolean;
            public friends_tutorial_enabled: boolean;
            public gifts_tutorial_enabled: boolean;
            public task_help_tutorials_enabled: boolean;
            public revives_and_potions_tutorial_enabled: boolean;
            public razzberry_catch_tutorial_enabled: boolean;
            public lures_tutorial_enabled: boolean;
            public trading_tutorial_enabled: boolean;
            public lucky_trade_tutorial_enabled: boolean;
            public lucky_friend_tutorial_enabled: boolean;
            public pokemon_tagging_tutorial_enabled: boolean;
            public tutorial_item_rewards: POGOProtos.Rpc.ITutorialItemRewardsProto[];
            public type_effectiveness_tips_enabled: boolean;
            public show_strong_encounter_ticket_page: boolean;
            public static encode(message: POGOProtos.Rpc.ITutorialsSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TutorialsSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TutorialsSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TutorialsSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITwoForOneEnabledProto {
            enabled?: (boolean|null);
        }

        class TwoForOneEnabledProto implements ITwoForOneEnabledProto {
            constructor(properties?: POGOProtos.Rpc.ITwoForOneEnabledProto);
            public enabled: boolean;
            public static encode(message: POGOProtos.Rpc.ITwoForOneEnabledProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TwoForOneEnabledProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TwoForOneEnabledProto;
            public static toObject(message: POGOProtos.Rpc.TwoForOneEnabledProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITwoWaySharedFriendshipDataProto {
            is_lucky?: (boolean|null);
            lucky_count?: (number|null);
            shared_migrations?: (POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.ISharedMigrations|null);
        }

        class TwoWaySharedFriendshipDataProto implements ITwoWaySharedFriendshipDataProto {
            constructor(properties?: POGOProtos.Rpc.ITwoWaySharedFriendshipDataProto);
            public is_lucky: boolean;
            public lucky_count: number;
            public shared_migrations?: (POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.ISharedMigrations|null);
            public static encode(message: POGOProtos.Rpc.ITwoWaySharedFriendshipDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TwoWaySharedFriendshipDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TwoWaySharedFriendshipDataProto;
            public static toObject(message: POGOProtos.Rpc.TwoWaySharedFriendshipDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace TwoWaySharedFriendshipDataProto {

            interface ISharedMigrations {
                is_gifting_migrated?: (boolean|null);
                is_lucky_data_migrated?: (boolean|null);
            }

            class SharedMigrations implements ISharedMigrations {
                constructor(properties?: POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.ISharedMigrations);
                public is_gifting_migrated: boolean;
                public is_lucky_data_migrated: boolean;
                public static encode(message: POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.ISharedMigrations, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.SharedMigrations;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.SharedMigrations;
                public static toObject(message: POGOProtos.Rpc.TwoWaySharedFriendshipDataProto.SharedMigrations, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IType {
            name?: (string|null);
            fields?: (POGOProtos.Rpc.IField[]|null);
            oneofs?: (string[]|null);
            options?: (POGOProtos.Rpc.IOption[]|null);
            source_context?: (POGOProtos.Rpc.ISourceContext|null);
            syntax?: (POGOProtos.Rpc.Syntax|null);
            edition?: (string|null);
        }

        class Type implements IType {
            constructor(properties?: POGOProtos.Rpc.IType);
            public name: string;
            public fields: POGOProtos.Rpc.IField[];
            public oneofs: string[];
            public options: POGOProtos.Rpc.IOption[];
            public source_context?: (POGOProtos.Rpc.ISourceContext|null);
            public syntax: POGOProtos.Rpc.Syntax;
            public edition: string;
            public static encode(message: POGOProtos.Rpc.IType, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Type;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Type;
            public static toObject(message: POGOProtos.Rpc.Type, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITypeEffectiveSettingsProto {
            attack_scalar?: (number[]|null);
            attack_type?: (POGOProtos.Rpc.HoloPokemonType|null);
        }

        class TypeEffectiveSettingsProto implements ITypeEffectiveSettingsProto {
            constructor(properties?: POGOProtos.Rpc.ITypeEffectiveSettingsProto);
            public attack_scalar: number[];
            public attack_type: POGOProtos.Rpc.HoloPokemonType;
            public static encode(message: POGOProtos.Rpc.ITypeEffectiveSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.TypeEffectiveSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.TypeEffectiveSettingsProto;
            public static toObject(message: POGOProtos.Rpc.TypeEffectiveSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUInt32Value {
            value?: (number|null);
        }

        class UInt32Value implements IUInt32Value {
            constructor(properties?: POGOProtos.Rpc.IUInt32Value);
            public value: number;
            public static encode(message: POGOProtos.Rpc.IUInt32Value, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UInt32Value;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UInt32Value;
            public static toObject(message: POGOProtos.Rpc.UInt32Value, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUInt64Value {
            value?: (number|Long|null);
        }

        class UInt64Value implements IUInt64Value {
            constructor(properties?: POGOProtos.Rpc.IUInt64Value);
            public value: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUInt64Value, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UInt64Value;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UInt64Value;
            public static toObject(message: POGOProtos.Rpc.UInt64Value, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUUID {
            upper?: (number|Long|null);
            lower?: (number|Long|null);
        }

        class UUID implements IUUID {
            constructor(properties?: POGOProtos.Rpc.IUUID);
            public upper: (number|Long);
            public lower: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUUID, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UUID;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UUID;
            public static toObject(message: POGOProtos.Rpc.UUID, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUncommentAnnotationTestProto {
            string_property?: (string|null);
            long_property?: (number|Long|null);
        }

        class UncommentAnnotationTestProto implements IUncommentAnnotationTestProto {
            constructor(properties?: POGOProtos.Rpc.IUncommentAnnotationTestProto);
            public string_property: string;
            public long_property: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUncommentAnnotationTestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UncommentAnnotationTestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UncommentAnnotationTestProto;
            public static toObject(message: POGOProtos.Rpc.UncommentAnnotationTestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUnfusePokemonRequestProto {
            pokemon_id?: (number|Long|null);
            target_form?: (POGOProtos.Rpc.PokemonDisplayProto.Form|null);
        }

        class UnfusePokemonRequestProto implements IUnfusePokemonRequestProto {
            constructor(properties?: POGOProtos.Rpc.IUnfusePokemonRequestProto);
            public pokemon_id: (number|Long);
            public target_form: POGOProtos.Rpc.PokemonDisplayProto.Form;
            public static encode(message: POGOProtos.Rpc.IUnfusePokemonRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UnfusePokemonRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UnfusePokemonRequestProto;
            public static toObject(message: POGOProtos.Rpc.UnfusePokemonRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUnfusePokemonResponseProto {
            result?: (POGOProtos.Rpc.UnfusePokemonResponseProto.Result|null);
            unfused_base_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            unfused_component_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            exp_awarded?: (number|null);
            candy_awarded?: (number|null);
        }

        class UnfusePokemonResponseProto implements IUnfusePokemonResponseProto {
            constructor(properties?: POGOProtos.Rpc.IUnfusePokemonResponseProto);
            public result: POGOProtos.Rpc.UnfusePokemonResponseProto.Result;
            public unfused_base_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public unfused_component_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public exp_awarded: number;
            public candy_awarded: number;
            public static encode(message: POGOProtos.Rpc.IUnfusePokemonResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UnfusePokemonResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UnfusePokemonResponseProto;
            public static toObject(message: POGOProtos.Rpc.UnfusePokemonResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UnfusePokemonResponseProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_MISSING = 2,
                ERROR_INSUFFICIENT_RESOURCES = 3,
                ERROR_QUEST_INCOMPLETE = 4,
                ERROR_POKEMON_CANNOT_CHANGE = 5,
                ERROR_POKEMON_DEPLOYED = 6,
                ERROR_FEATURE_DISABLED = 7,
                ERROR_UNKNOWN = 8
            }
        }

        interface IUninterpretedOption {
            identifier_value?: (string|null);
            positive_int_value?: (number|Long|null);
            negative_int_value?: (number|Long|null);
            double_value?: (number|null);
            string_value?: (Uint8Array|null);
            aggregate_value?: (string|null);
        }

        class UninterpretedOption implements IUninterpretedOption {
            constructor(properties?: POGOProtos.Rpc.IUninterpretedOption);
            public identifier_value: string;
            public positive_int_value: (number|Long);
            public negative_int_value: (number|Long);
            public double_value: number;
            public string_value: Uint8Array;
            public aggregate_value: string;
            public static encode(message: POGOProtos.Rpc.IUninterpretedOption, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UninterpretedOption;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UninterpretedOption;
            public static toObject(message: POGOProtos.Rpc.UninterpretedOption, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UninterpretedOption {

            interface INamePart {
                name_part?: (string|null);
                is_extension?: (boolean|null);
            }

            class NamePart implements INamePart {
                constructor(properties?: POGOProtos.Rpc.UninterpretedOption.INamePart);
                public name_part: string;
                public is_extension: boolean;
                public static encode(message: POGOProtos.Rpc.UninterpretedOption.INamePart, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UninterpretedOption.NamePart;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UninterpretedOption.NamePart;
                public static toObject(message: POGOProtos.Rpc.UninterpretedOption.NamePart, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IUnlinkNintendoAccountOutProto {
            status?: (POGOProtos.Rpc.UnlinkNintendoAccountOutProto.Status|null);
        }

        class UnlinkNintendoAccountOutProto implements IUnlinkNintendoAccountOutProto {
            constructor(properties?: POGOProtos.Rpc.IUnlinkNintendoAccountOutProto);
            public status: POGOProtos.Rpc.UnlinkNintendoAccountOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IUnlinkNintendoAccountOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UnlinkNintendoAccountOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UnlinkNintendoAccountOutProto;
            public static toObject(message: POGOProtos.Rpc.UnlinkNintendoAccountOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UnlinkNintendoAccountOutProto {

            enum Status {
                UNKNOWN = 0,
                SUCCESS = 1,
                ERROR_PLAYER_LEVEL_TOO_LOW = 2,
                ERROR_NO_LINKED_NAID = 3,
                ERROR_TRANSFER_IN_PROGRESS = 4
            }
        }

        interface IUnlinkNintendoAccountProto {
        }

        class UnlinkNintendoAccountProto implements IUnlinkNintendoAccountProto {
            constructor(properties?: POGOProtos.Rpc.IUnlinkNintendoAccountProto);
            public static encode(message: POGOProtos.Rpc.IUnlinkNintendoAccountProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UnlinkNintendoAccountProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UnlinkNintendoAccountProto;
            public static toObject(message: POGOProtos.Rpc.UnlinkNintendoAccountProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUnlockPokemonMoveOutProto {
            result?: (POGOProtos.Rpc.UnlockPokemonMoveOutProto.Result|null);
            unlocked_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class UnlockPokemonMoveOutProto implements IUnlockPokemonMoveOutProto {
            constructor(properties?: POGOProtos.Rpc.IUnlockPokemonMoveOutProto);
            public result: POGOProtos.Rpc.UnlockPokemonMoveOutProto.Result;
            public unlocked_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IUnlockPokemonMoveOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UnlockPokemonMoveOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UnlockPokemonMoveOutProto;
            public static toObject(message: POGOProtos.Rpc.UnlockPokemonMoveOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UnlockPokemonMoveOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_NOT_FOUND = 2,
                ERROR_UNLOCK_NOT_AVAILABLE = 3,
                ERROR_ALREADY_UNLOCKED = 4,
                ERROR_INSUFFICIENT_RESOURCES = 5,
                ERROR_DISABLED = 6
            }
        }

        interface IUnlockPokemonMoveProto {
            pokemon_id?: (number|Long|null);
        }

        class UnlockPokemonMoveProto implements IUnlockPokemonMoveProto {
            constructor(properties?: POGOProtos.Rpc.IUnlockPokemonMoveProto);
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUnlockPokemonMoveProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UnlockPokemonMoveProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UnlockPokemonMoveProto;
            public static toObject(message: POGOProtos.Rpc.UnlockPokemonMoveProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpNextSectionProto {
            event_id?: (string[]|null);
        }

        class UpNextSectionProto implements IUpNextSectionProto {
            constructor(properties?: POGOProtos.Rpc.IUpNextSectionProto);
            public event_id: string[];
            public static encode(message: POGOProtos.Rpc.IUpNextSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpNextSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpNextSectionProto;
            public static toObject(message: POGOProtos.Rpc.UpNextSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpcomingEventsSectionProto {
            events?: (POGOProtos.Rpc.IEventSectionProto[]|null);
        }

        class UpcomingEventsSectionProto implements IUpcomingEventsSectionProto {
            constructor(properties?: POGOProtos.Rpc.IUpcomingEventsSectionProto);
            public events: POGOProtos.Rpc.IEventSectionProto[];
            public static encode(message: POGOProtos.Rpc.IUpcomingEventsSectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpcomingEventsSectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpcomingEventsSectionProto;
            public static toObject(message: POGOProtos.Rpc.UpcomingEventsSectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateAdventureSyncFitnessRequestProto {
            fitness_samples?: (POGOProtos.Rpc.IFitnessSample[]|null);
        }

        class UpdateAdventureSyncFitnessRequestProto implements IUpdateAdventureSyncFitnessRequestProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateAdventureSyncFitnessRequestProto);
            public fitness_samples: POGOProtos.Rpc.IFitnessSample[];
            public static encode(message: POGOProtos.Rpc.IUpdateAdventureSyncFitnessRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateAdventureSyncFitnessRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateAdventureSyncFitnessRequestProto;
            public static toObject(message: POGOProtos.Rpc.UpdateAdventureSyncFitnessRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateAdventureSyncFitnessResponseProto {
            status?: (POGOProtos.Rpc.UpdateAdventureSyncFitnessResponseProto.Status|null);
        }

        class UpdateAdventureSyncFitnessResponseProto implements IUpdateAdventureSyncFitnessResponseProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateAdventureSyncFitnessResponseProto);
            public status: POGOProtos.Rpc.UpdateAdventureSyncFitnessResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdateAdventureSyncFitnessResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateAdventureSyncFitnessResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateAdventureSyncFitnessResponseProto;
            public static toObject(message: POGOProtos.Rpc.UpdateAdventureSyncFitnessResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateAdventureSyncFitnessResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IUpdateAdventureSyncSettingsRequestProto {
            adventure_sync_settings?: (POGOProtos.Rpc.IAdventureSyncSettingsProto|null);
        }

        class UpdateAdventureSyncSettingsRequestProto implements IUpdateAdventureSyncSettingsRequestProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateAdventureSyncSettingsRequestProto);
            public adventure_sync_settings?: (POGOProtos.Rpc.IAdventureSyncSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateAdventureSyncSettingsRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateAdventureSyncSettingsRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateAdventureSyncSettingsRequestProto;
            public static toObject(message: POGOProtos.Rpc.UpdateAdventureSyncSettingsRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateAdventureSyncSettingsResponseProto {
            status?: (POGOProtos.Rpc.UpdateAdventureSyncSettingsResponseProto.Status|null);
        }

        class UpdateAdventureSyncSettingsResponseProto implements IUpdateAdventureSyncSettingsResponseProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateAdventureSyncSettingsResponseProto);
            public status: POGOProtos.Rpc.UpdateAdventureSyncSettingsResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdateAdventureSyncSettingsResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateAdventureSyncSettingsResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateAdventureSyncSettingsResponseProto;
            public static toObject(message: POGOProtos.Rpc.UpdateAdventureSyncSettingsResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateAdventureSyncSettingsResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IUpdateBreadcrumbHistoryRequestProto {
            session_context?: (string|null);
            breadcrumb_history?: (POGOProtos.Rpc.IBreadcrumbRecordProto[]|null);
            initial_update?: (boolean|null);
        }

        class UpdateBreadcrumbHistoryRequestProto implements IUpdateBreadcrumbHistoryRequestProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateBreadcrumbHistoryRequestProto);
            public session_context: string;
            public breadcrumb_history: POGOProtos.Rpc.IBreadcrumbRecordProto[];
            public initial_update: boolean;
            public static encode(message: POGOProtos.Rpc.IUpdateBreadcrumbHistoryRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateBreadcrumbHistoryRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateBreadcrumbHistoryRequestProto;
            public static toObject(message: POGOProtos.Rpc.UpdateBreadcrumbHistoryRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateBreadcrumbHistoryResponseProto {
            status?: (POGOProtos.Rpc.UpdateBreadcrumbHistoryResponseProto.Status|null);
        }

        class UpdateBreadcrumbHistoryResponseProto implements IUpdateBreadcrumbHistoryResponseProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateBreadcrumbHistoryResponseProto);
            public status: POGOProtos.Rpc.UpdateBreadcrumbHistoryResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdateBreadcrumbHistoryResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateBreadcrumbHistoryResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateBreadcrumbHistoryResponseProto;
            public static toObject(message: POGOProtos.Rpc.UpdateBreadcrumbHistoryResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateBreadcrumbHistoryResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IUpdateBulkPlayerLocationRequestProto {
            location_ping_update?: (POGOProtos.Rpc.ILocationPingUpdateProto[]|null);
        }

        class UpdateBulkPlayerLocationRequestProto implements IUpdateBulkPlayerLocationRequestProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateBulkPlayerLocationRequestProto);
            public location_ping_update: POGOProtos.Rpc.ILocationPingUpdateProto[];
            public static encode(message: POGOProtos.Rpc.IUpdateBulkPlayerLocationRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateBulkPlayerLocationRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateBulkPlayerLocationRequestProto;
            public static toObject(message: POGOProtos.Rpc.UpdateBulkPlayerLocationRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateBulkPlayerLocationResponseProto {
            status?: (POGOProtos.Rpc.UpdateBulkPlayerLocationResponseProto.Status|null);
        }

        class UpdateBulkPlayerLocationResponseProto implements IUpdateBulkPlayerLocationResponseProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateBulkPlayerLocationResponseProto);
            public status: POGOProtos.Rpc.UpdateBulkPlayerLocationResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdateBulkPlayerLocationResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateBulkPlayerLocationResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateBulkPlayerLocationResponseProto;
            public static toObject(message: POGOProtos.Rpc.UpdateBulkPlayerLocationResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateBulkPlayerLocationResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_PLAYER_NOT_FOUND = 3
            }
        }

        interface IUpdateCombatData {
            rpc_id?: (number|null);
            action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            combat_request_counter?: (number|null);
        }

        class UpdateCombatData implements IUpdateCombatData {
            constructor(properties?: POGOProtos.Rpc.IUpdateCombatData);
            public rpc_id: number;
            public action?: (POGOProtos.Rpc.ICombatActionLogProto|null);
            public combat_request_counter: number;
            public static encode(message: POGOProtos.Rpc.IUpdateCombatData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateCombatData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateCombatData;
            public static toObject(message: POGOProtos.Rpc.UpdateCombatData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateCombatOutProto {
            result?: (POGOProtos.Rpc.UpdateCombatOutProto.Result|null);
            combat?: (POGOProtos.Rpc.ICombatProto|null);
        }

        class UpdateCombatOutProto implements IUpdateCombatOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateCombatOutProto);
            public result: POGOProtos.Rpc.UpdateCombatOutProto.Result;
            public combat?: (POGOProtos.Rpc.ICombatProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateCombatOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateCombatOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateCombatOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateCombatOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateCombatOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_COMBAT_STATE = 2,
                ERROR_COMBAT_NOT_FOUND = 3,
                ERROR_PLAYER_NOT_IN_COMBAT = 4,
                ERROR_ILLEGAL_ACTION = 5,
                ERROR_INVALID_SUBMIT_TIME = 6,
                ERROR_PLAYER_IN_MINIGAME = 7,
                ERROR_EXISTING_QUEUED_ATTACK = 8,
                ERROR_INVALID_CHANGE_POKEMON = 9,
                ERROR_INSUFFICIENT_ENERGY = 10,
                ERROR_INVALID_MOVE = 11,
                ERROR_INVALID_DURATION_TURNS = 12,
                ERROR_INVALID_MINIGAME_STATE = 13,
                ERROR_INVALID_QUICK_SWAP_POKEMON = 14,
                ERROR_QUICK_SWAP_NOT_AVAILABLE = 15,
                ERROR_INVALID_SUBMIT_TIME_BEFORE_LAST_UPDATED_TURN = 16,
                ERROR_INVALID_SUBMIT_TIME_DURING_STATE_CHANGE = 17,
                ERROR_INVALID_SUBMIT_TIME_OPPONENT_CHARGE_MOVE = 18,
                ERROR_INVALID_SUBMIT_TIME_CMP_TIE_SWAP = 19,
                ERROR_INVALID_MINIGAME_STATE_OFFENSIVE_FINISH = 20,
                ERROR_INVALID_MINIGAME_STATE_DEFENSIVE_START = 21,
                ERROR_INVALID_MINIGAME_STATE_DEFENSIVE_FINISH = 22
            }
        }

        interface IUpdateCombatProto {
            combat_id?: (string|null);
            action?: (POGOProtos.Rpc.ICombatActionProto|null);
            debug_log?: (string|null);
            combat_request_counter?: (number|null);
        }

        class UpdateCombatProto implements IUpdateCombatProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateCombatProto);
            public combat_id: string;
            public action?: (POGOProtos.Rpc.ICombatActionProto|null);
            public debug_log: string;
            public combat_request_counter: number;
            public static encode(message: POGOProtos.Rpc.IUpdateCombatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateCombatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateCombatProto;
            public static toObject(message: POGOProtos.Rpc.UpdateCombatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateCombatResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.UpdateCombatOutProto.Result|null);
            combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
        }

        class UpdateCombatResponseData implements IUpdateCombatResponseData {
            constructor(properties?: POGOProtos.Rpc.IUpdateCombatResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.UpdateCombatOutProto.Result;
            public combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateCombatResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateCombatResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateCombatResponseData;
            public static toObject(message: POGOProtos.Rpc.UpdateCombatResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateCombatResponseTimeTelemetry {
            window_duration?: (number|null);
            count_call?: (number|null);
            average_response_time?: (number|null);
            timeout_count?: (number|null);
            combat_type?: (POGOProtos.Rpc.CombatType|null);
            realm?: (string|null);
            median_response_time?: (number|null);
            min_response_time?: (number|null);
            max_response_time?: (number|null);
            p90_response_time?: (number|null);
        }

        class UpdateCombatResponseTimeTelemetry implements IUpdateCombatResponseTimeTelemetry {
            constructor(properties?: POGOProtos.Rpc.IUpdateCombatResponseTimeTelemetry);
            public window_duration: number;
            public count_call: number;
            public average_response_time: number;
            public timeout_count: number;
            public combat_type: POGOProtos.Rpc.CombatType;
            public realm: string;
            public median_response_time: number;
            public min_response_time: number;
            public max_response_time: number;
            public p90_response_time: number;
            public static encode(message: POGOProtos.Rpc.IUpdateCombatResponseTimeTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateCombatResponseTimeTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateCombatResponseTimeTelemetry;
            public static toObject(message: POGOProtos.Rpc.UpdateCombatResponseTimeTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateContestEntryOutProto {
            status?: (POGOProtos.Rpc.UpdateContestEntryOutProto.Status|null);
        }

        class UpdateContestEntryOutProto implements IUpdateContestEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateContestEntryOutProto);
            public status: POGOProtos.Rpc.UpdateContestEntryOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdateContestEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateContestEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateContestEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateContestEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateContestEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                OUT_OF_RANGE = 3,
                ENTERED_POKEMON_NOT_AVAILABLE = 4,
                POKEMON_ID_TO_REPLACE_MISSING = 5,
                POKEMON_TO_REPLACE_DIFFERENT = 6,
                PLAYER_LIMIT_REACHED = 7,
                CONTEST_LIMIT_REACHED = 8,
                SAME_CYCLE_TRADE_NOT_ALLOWED = 9,
                SAME_SEASON_WINNER_NOT_ALLOWED = 10,
                POKEMON_TO_REPLACE_NOT_FOUND = 11,
                PENDING_REWARD_ENTRY_NOT_ALLOWED = 12
            }
        }

        interface IUpdateContestEntryProto {
            fort_id?: (string|null);
            contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id?: (number|Long|null);
            pokemon_id_to_replace?: (number|Long|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
            entry_point?: (POGOProtos.Rpc.EntryPointForContestEntry|null);
        }

        class UpdateContestEntryProto implements IUpdateContestEntryProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateContestEntryProto);
            public fort_id: string;
            public contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id: (number|Long);
            public pokemon_id_to_replace: (number|Long);
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public entry_point: POGOProtos.Rpc.EntryPointForContestEntry;
            public static encode(message: POGOProtos.Rpc.IUpdateContestEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateContestEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateContestEntryProto;
            public static toObject(message: POGOProtos.Rpc.UpdateContestEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateEventRsvpSelectionOutProto {
            status?: (POGOProtos.Rpc.UpdateEventRsvpSelectionOutProto.Result|null);
            rsvp?: (POGOProtos.Rpc.IEventRsvpProto|null);
        }

        class UpdateEventRsvpSelectionOutProto implements IUpdateEventRsvpSelectionOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateEventRsvpSelectionOutProto);
            public status: POGOProtos.Rpc.UpdateEventRsvpSelectionOutProto.Result;
            public rsvp?: (POGOProtos.Rpc.IEventRsvpProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateEventRsvpSelectionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateEventRsvpSelectionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateEventRsvpSelectionOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateEventRsvpSelectionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateEventRsvpSelectionOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_NOT_FOUND = 3
            }
        }

        interface IUpdateEventRsvpSelectionProto {
            location_id?: (string|null);
            timestamp_ms?: (number|Long|null);
            rsvp_selection?: (POGOProtos.Rpc.RsvpSelection|null);
        }

        class UpdateEventRsvpSelectionProto implements IUpdateEventRsvpSelectionProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateEventRsvpSelectionProto);
            public location_id: string;
            public timestamp_ms: (number|Long);
            public rsvp_selection: POGOProtos.Rpc.RsvpSelection;
            public static encode(message: POGOProtos.Rpc.IUpdateEventRsvpSelectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateEventRsvpSelectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateEventRsvpSelectionProto;
            public static toObject(message: POGOProtos.Rpc.UpdateEventRsvpSelectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateInvasionBattleOutProto {
            status?: (POGOProtos.Rpc.InvasionStatus.Status|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            map_fragment_upgraded?: (boolean|null);
        }

        class UpdateInvasionBattleOutProto implements IUpdateInvasionBattleOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateInvasionBattleOutProto);
            public status: POGOProtos.Rpc.InvasionStatus.Status;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public map_fragment_upgraded: boolean;
            public static encode(message: POGOProtos.Rpc.IUpdateInvasionBattleOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateInvasionBattleOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateInvasionBattleOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateInvasionBattleOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateInvasionBattleProto {
            incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            step?: (number|null);
            health_update?: (POGOProtos.Rpc.IPokemonStaminaUpdateProto[]|null);
            complete_battle?: (boolean|null);
            update_type?: (POGOProtos.Rpc.UpdateInvasionBattleProto.UpdateType|null);
            lobby_join_time_ms?: (number|Long|null);
            combat_quest_update?: (POGOProtos.Rpc.ICombatQuestUpdateProto|null);
        }

        class UpdateInvasionBattleProto implements IUpdateInvasionBattleProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateInvasionBattleProto);
            public incident_lookup?: (POGOProtos.Rpc.IIncidentLookupProto|null);
            public step: number;
            public health_update: POGOProtos.Rpc.IPokemonStaminaUpdateProto[];
            public complete_battle: boolean;
            public update_type: POGOProtos.Rpc.UpdateInvasionBattleProto.UpdateType;
            public lobby_join_time_ms: (number|Long);
            public combat_quest_update?: (POGOProtos.Rpc.ICombatQuestUpdateProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateInvasionBattleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateInvasionBattleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateInvasionBattleProto;
            public static toObject(message: POGOProtos.Rpc.UpdateInvasionBattleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateInvasionBattleProto {

            enum UpdateType {
                POKEMON_HEALTH = 0,
                WIN_BATTLE = 1,
                LOSE_BATTLE = 2
            }
        }

        interface IUpdateIrisSocialSceneOutProto {
            status?: (POGOProtos.Rpc.UpdateIrisSocialSceneOutProto.Status|null);
            updated_placed_pokemon?: (POGOProtos.Rpc.IIrisPokemonObjectProto[]|null);
        }

        class UpdateIrisSocialSceneOutProto implements IUpdateIrisSocialSceneOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateIrisSocialSceneOutProto);
            public status: POGOProtos.Rpc.UpdateIrisSocialSceneOutProto.Status;
            public updated_placed_pokemon: POGOProtos.Rpc.IIrisPokemonObjectProto[];
            public static encode(message: POGOProtos.Rpc.IUpdateIrisSocialSceneOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateIrisSocialSceneOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateIrisSocialSceneOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateIrisSocialSceneOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateIrisSocialSceneOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                POKEMON_TO_ADD_NOT_FOUND_IN_INVENTORY = 2,
                POKEMON_TO_REMOVE_NOT_FOUND_IN_INVENTORY = 3,
                POKEMON_TO_REMOVE_NOT_FOUND_IN_SCENE = 4,
                MAX_NUM_POKEMON_PER_PLAYER_REACHED = 5,
                ERROR_FEATURE_DISABLED = 6,
                ERROR_FORT_NOT_FOUND_OR_NOT_VPS_ELIGIBLE = 7,
                BOTH_POKEMON_TO_ADD_AND_POKEMON_TO_REMOVE_ARE_UNSET = 8,
                POKEMON_TO_ADD_IS_DENYLISTED = 9,
                MISSING_DATA_IN_POKEMON_OBJECT = 10,
                ERROR_POKEMON_LOCKED = 11,
                ERROR_NO_UPDATE_TYPE = 12,
                ERROR_UPDATE_TYPE_EXPRESSION_BUT_NO_EXPRESSION_SPECIFIED = 13
            }
        }

        interface IUpdateIrisSocialSceneProto {
            fort_id?: (string|null);
            iris_pokemon_object_to_add?: (POGOProtos.Rpc.IIrisPokemonObjectProto|null);
            pokemon_id_to_remove?: (number|Long|null);
            iris_session_id?: (string|null);
            vps_session_id?: (string|null);
            fort_lat?: (number|null);
            fort_lng?: (number|null);
            update_type?: (POGOProtos.Rpc.UpdateIrisSocialSceneProto.UpdateType|null);
            pokemon_expression_update?: (POGOProtos.Rpc.IPokemonExpressionUpdateProto|null);
        }

        class UpdateIrisSocialSceneProto implements IUpdateIrisSocialSceneProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateIrisSocialSceneProto);
            public fort_id: string;
            public iris_pokemon_object_to_add?: (POGOProtos.Rpc.IIrisPokemonObjectProto|null);
            public pokemon_id_to_remove: (number|Long);
            public iris_session_id: string;
            public vps_session_id: string;
            public fort_lat: number;
            public fort_lng: number;
            public update_type: POGOProtos.Rpc.UpdateIrisSocialSceneProto.UpdateType;
            public pokemon_expression_update?: (POGOProtos.Rpc.IPokemonExpressionUpdateProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateIrisSocialSceneProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateIrisSocialSceneProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateIrisSocialSceneProto;
            public static toObject(message: POGOProtos.Rpc.UpdateIrisSocialSceneProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateIrisSocialSceneProto {

            enum UpdateType {
                UNSET = 0,
                POKEMON_PLACEMENT = 1,
                POKEMON_EXPRESSION = 2
            }
        }

        interface IUpdateIrisSpawnDataProto {
            fort_id?: (string|null);
            updated_anchors?: (POGOProtos.Rpc.IIrisPokemonObjectProto[]|null);
            event_id?: (number|null);
        }

        class UpdateIrisSpawnDataProto implements IUpdateIrisSpawnDataProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateIrisSpawnDataProto);
            public fort_id: string;
            public updated_anchors: POGOProtos.Rpc.IIrisPokemonObjectProto[];
            public event_id: number;
            public static encode(message: POGOProtos.Rpc.IUpdateIrisSpawnDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateIrisSpawnDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateIrisSpawnDataProto;
            public static toObject(message: POGOProtos.Rpc.UpdateIrisSpawnDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateIrisSpawnDataProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2
            }
        }

        interface IUpdateNotificationOutProto {
            notification_ids?: (string[]|null);
            create_timestamp_ms?: ((number|Long)[]|null);
            state?: (POGOProtos.Rpc.NotificationState|null);
        }

        class UpdateNotificationOutProto implements IUpdateNotificationOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateNotificationOutProto);
            public notification_ids: string[];
            public create_timestamp_ms: (number|Long)[];
            public state: POGOProtos.Rpc.NotificationState;
            public static encode(message: POGOProtos.Rpc.IUpdateNotificationOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateNotificationOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateNotificationOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateNotificationOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateNotificationProto {
            notification_ids?: (string[]|null);
            create_timestamp_ms?: ((number|Long)[]|null);
            state?: (POGOProtos.Rpc.NotificationState|null);
        }

        class UpdateNotificationProto implements IUpdateNotificationProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateNotificationProto);
            public notification_ids: string[];
            public create_timestamp_ms: (number|Long)[];
            public state: POGOProtos.Rpc.NotificationState;
            public static encode(message: POGOProtos.Rpc.IUpdateNotificationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateNotificationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateNotificationProto;
            public static toObject(message: POGOProtos.Rpc.UpdateNotificationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdatePlayerGpsBookmarksOutProto {
            result?: (POGOProtos.Rpc.UpdatePlayerGpsBookmarksOutProto.Result|null);
            gps_bookmarks?: (POGOProtos.Rpc.IGpsBookmarkProto[]|null);
        }

        class UpdatePlayerGpsBookmarksOutProto implements IUpdatePlayerGpsBookmarksOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdatePlayerGpsBookmarksOutProto);
            public result: POGOProtos.Rpc.UpdatePlayerGpsBookmarksOutProto.Result;
            public gps_bookmarks: POGOProtos.Rpc.IGpsBookmarkProto[];
            public static encode(message: POGOProtos.Rpc.IUpdatePlayerGpsBookmarksOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdatePlayerGpsBookmarksOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdatePlayerGpsBookmarksOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdatePlayerGpsBookmarksOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdatePlayerGpsBookmarksOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                COULD_NOT_ADD_BOOKMARK = 2,
                COULD_NOT_REMOVE_BOOKMARK = 3
            }
        }

        interface IUpdatePlayerGpsBookmarksProto {
            added_gps_bookmarks?: (POGOProtos.Rpc.IGpsBookmarkProto[]|null);
            removed_gps_bookmarks?: (POGOProtos.Rpc.IGpsBookmarkProto[]|null);
        }

        class UpdatePlayerGpsBookmarksProto implements IUpdatePlayerGpsBookmarksProto {
            constructor(properties?: POGOProtos.Rpc.IUpdatePlayerGpsBookmarksProto);
            public added_gps_bookmarks: POGOProtos.Rpc.IGpsBookmarkProto[];
            public removed_gps_bookmarks: POGOProtos.Rpc.IGpsBookmarkProto[];
            public static encode(message: POGOProtos.Rpc.IUpdatePlayerGpsBookmarksProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdatePlayerGpsBookmarksProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdatePlayerGpsBookmarksProto;
            public static toObject(message: POGOProtos.Rpc.UpdatePlayerGpsBookmarksProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdatePokemonSizeLeaderboardEntryOutProto {
            status?: (POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryOutProto.Status|null);
        }

        class UpdatePokemonSizeLeaderboardEntryOutProto implements IUpdatePokemonSizeLeaderboardEntryOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryOutProto);
            public status: POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdatePokemonSizeLeaderboardEntryOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                OUT_OF_RANGE = 3,
                ENTERED_POKEMON_NOT_AVAILABLE = 4,
                POKEMON_ID_TO_REPLACE_MISSING = 5,
                POKEMON_TO_REPLACE_DIFFERENT = 6,
                PLAYER_LIMIT_REACHED = 7,
                CONTEST_LIMIT_REACHED = 8,
                SAME_CYCLE_TRADE_NOT_ALLOWED = 9,
                SAME_SEASON_WINNER_NOT_ALLOWED = 10,
                POKEMON_TO_REPLACE_NOT_FOUND = 11,
                PENDING_REWARD_ENTRY_NOT_ALLOWED = 12
            }
        }

        interface IUpdatePokemonSizeLeaderboardEntryProto {
            fort_id?: (string|null);
            contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            pokemon_id?: (number|Long|null);
            pokemon_id_to_replace?: (number|Long|null);
            fort_lat_degrees?: (number|null);
            fort_lng_degrees?: (number|null);
            entry_point?: (POGOProtos.Rpc.EntryPointForContestEntry|null);
        }

        class UpdatePokemonSizeLeaderboardEntryProto implements IUpdatePokemonSizeLeaderboardEntryProto {
            constructor(properties?: POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryProto);
            public fort_id: string;
            public contest_schedule?: (POGOProtos.Rpc.IContestScheduleProto|null);
            public contest_metric?: (POGOProtos.Rpc.IContestMetricProto|null);
            public pokemon_id: (number|Long);
            public pokemon_id_to_replace: (number|Long);
            public fort_lat_degrees: number;
            public fort_lng_degrees: number;
            public entry_point: POGOProtos.Rpc.EntryPointForContestEntry;
            public static encode(message: POGOProtos.Rpc.IUpdatePokemonSizeLeaderboardEntryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryProto;
            public static toObject(message: POGOProtos.Rpc.UpdatePokemonSizeLeaderboardEntryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdatePostcardOutProto {
            result?: (POGOProtos.Rpc.UpdatePostcardOutProto.Result|null);
            postcard?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
        }

        class UpdatePostcardOutProto implements IUpdatePostcardOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdatePostcardOutProto);
            public result: POGOProtos.Rpc.UpdatePostcardOutProto.Result;
            public postcard?: (POGOProtos.Rpc.IPostcardDisplayProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdatePostcardOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdatePostcardOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdatePostcardOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdatePostcardOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdatePostcardOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POSTCARD_DOES_NOT_EXIST = 2,
                ERROR_NOT_ENABLED = 4,
                ERROR_RATE_LIMITED = 5
            }
        }

        interface IUpdatePostcardProto {
            postcard_id?: (string|null);
            favorite?: (boolean|null);
        }

        class UpdatePostcardProto implements IUpdatePostcardProto {
            constructor(properties?: POGOProtos.Rpc.IUpdatePostcardProto);
            public postcard_id: string;
            public favorite: boolean;
            public static encode(message: POGOProtos.Rpc.IUpdatePostcardProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdatePostcardProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdatePostcardProto;
            public static toObject(message: POGOProtos.Rpc.UpdatePostcardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateRouteDraftOutProto {
            result?: (POGOProtos.Rpc.UpdateRouteDraftOutProto.Result|null);
            updated_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            validation_result?: (POGOProtos.Rpc.IRouteValidation|null);
        }

        class UpdateRouteDraftOutProto implements IUpdateRouteDraftOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateRouteDraftOutProto);
            public result: POGOProtos.Rpc.UpdateRouteDraftOutProto.Result;
            public updated_route?: (POGOProtos.Rpc.IRouteCreationProto|null);
            public validation_result?: (POGOProtos.Rpc.IRouteValidation|null);
            public static encode(message: POGOProtos.Rpc.IUpdateRouteDraftOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateRouteDraftOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateRouteDraftOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateRouteDraftOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateRouteDraftOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_INVALID_ROUTE = 3,
                ERROR_OLD_VERSION = 4,
                ERROR_ROUTE_NOT_EDITABLE = 5
            }
        }

        interface IUpdateRouteDraftProto {
            pause?: (boolean|null);
            proposed_route_draft?: (POGOProtos.Rpc.ISharedRouteProto|null);
        }

        class UpdateRouteDraftProto implements IUpdateRouteDraftProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateRouteDraftProto);
            public pause?: (boolean|null);
            public proposed_route_draft?: (POGOProtos.Rpc.ISharedRouteProto|null);
            public NullablePause?: "pause";
            public static encode(message: POGOProtos.Rpc.IUpdateRouteDraftProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateRouteDraftProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateRouteDraftProto;
            public static toObject(message: POGOProtos.Rpc.UpdateRouteDraftProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateSurveyEligibilityOutProto {
            status?: (POGOProtos.Rpc.UpdateSurveyEligibilityOutProto.Status|null);
        }

        class UpdateSurveyEligibilityOutProto implements IUpdateSurveyEligibilityOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateSurveyEligibilityOutProto);
            public status: POGOProtos.Rpc.UpdateSurveyEligibilityOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IUpdateSurveyEligibilityOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateSurveyEligibilityOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateSurveyEligibilityOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateSurveyEligibilityOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateSurveyEligibilityOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_NOT_ENABLED = 3
            }
        }

        interface IUpdateSurveyEligibilityProto {
        }

        class UpdateSurveyEligibilityProto implements IUpdateSurveyEligibilityProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateSurveyEligibilityProto);
            public static encode(message: POGOProtos.Rpc.IUpdateSurveyEligibilityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateSurveyEligibilityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateSurveyEligibilityProto;
            public static toObject(message: POGOProtos.Rpc.UpdateSurveyEligibilityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateTradingOutProto {
            result?: (POGOProtos.Rpc.UpdateTradingOutProto.Result|null);
            trading?: (POGOProtos.Rpc.ITradingProto|null);
        }

        class UpdateTradingOutProto implements IUpdateTradingOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateTradingOutProto);
            public result: POGOProtos.Rpc.UpdateTradingOutProto.Result;
            public trading?: (POGOProtos.Rpc.ITradingProto|null);
            public static encode(message: POGOProtos.Rpc.IUpdateTradingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateTradingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateTradingOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateTradingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateTradingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FRIEND_NOT_FOUND = 3,
                ERROR_INVALID_PLAYER_ID = 4,
                ERROR_INVALID_STATE = 5,
                ERROR_STATE_HANDLER = 6,
                ERROR_INVALID_POKEMON = 7,
                ERROR_INSUFFICIENT_PAYMENT = 8,
                ERROR_TRADING_EXPIRED = 9,
                ERROR_TRADING_FINISHED = 10
            }
        }

        interface IUpdateTradingProto {
            player_id?: (string|null);
            pokemon_id?: (number|Long|null);
        }

        class UpdateTradingProto implements IUpdateTradingProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateTradingProto);
            public player_id: string;
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUpdateTradingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateTradingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateTradingProto;
            public static toObject(message: POGOProtos.Rpc.UpdateTradingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpdateVpsEventOutProto {
            status?: (POGOProtos.Rpc.UpdateVpsEventOutProto.Status|null);
            vps_event_wrapper?: (POGOProtos.Rpc.IVpsEventWrapperProto[]|null);
        }

        class UpdateVpsEventOutProto implements IUpdateVpsEventOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateVpsEventOutProto);
            public status: POGOProtos.Rpc.UpdateVpsEventOutProto.Status;
            public vps_event_wrapper: POGOProtos.Rpc.IVpsEventWrapperProto[];
            public static encode(message: POGOProtos.Rpc.IUpdateVpsEventOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateVpsEventOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateVpsEventOutProto;
            public static toObject(message: POGOProtos.Rpc.UpdateVpsEventOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpdateVpsEventOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_FORT_ID_NOT_FOUND = 3,
                ERROR_VPS_NOT_ENABLED_AT_FORT = 4,
                ERROR_VPS_EVENT_NOT_FOUND = 5,
                ERROR_ADD_ANCHOR_ID_ALREADY_EXISTS = 6,
                ERROR_UPDATE_ANCHOR_ID_DOES_NOT_EXIST = 7
            }
        }

        interface IUpdateVpsEventProto {
            fort_id?: (string|null);
            updated_anchors?: (POGOProtos.Rpc.IAnchorUpdateProto[]|null);
            event_id?: (number|null);
            updated_pokemon_placement?: (POGOProtos.Rpc.IPlacedPokemonUpdateProto[]|null);
        }

        class UpdateVpsEventProto implements IUpdateVpsEventProto {
            constructor(properties?: POGOProtos.Rpc.IUpdateVpsEventProto);
            public fort_id: string;
            public updated_anchors: POGOProtos.Rpc.IAnchorUpdateProto[];
            public event_id: number;
            public updated_pokemon_placement: POGOProtos.Rpc.IPlacedPokemonUpdateProto[];
            public static encode(message: POGOProtos.Rpc.IUpdateVpsEventProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpdateVpsEventProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpdateVpsEventProto;
            public static toObject(message: POGOProtos.Rpc.UpdateVpsEventProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpgradePokemonOutProto {
            result?: (POGOProtos.Rpc.UpgradePokemonOutProto.Result|null);
            upgraded_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            next_upgraded_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            bulk_upgrades_cost_table?: (POGOProtos.Rpc.UpgradePokemonOutProto.IBulkUpgradesCost[]|null);
            awarded_items?: (POGOProtos.Rpc.ILootProto[]|null);
        }

        class UpgradePokemonOutProto implements IUpgradePokemonOutProto {
            constructor(properties?: POGOProtos.Rpc.IUpgradePokemonOutProto);
            public result: POGOProtos.Rpc.UpgradePokemonOutProto.Result;
            public upgraded_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public next_upgraded_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public bulk_upgrades_cost_table: POGOProtos.Rpc.UpgradePokemonOutProto.IBulkUpgradesCost[];
            public awarded_items: POGOProtos.Rpc.ILootProto[];
            public static encode(message: POGOProtos.Rpc.IUpgradePokemonOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpgradePokemonOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpgradePokemonOutProto;
            public static toObject(message: POGOProtos.Rpc.UpgradePokemonOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpgradePokemonOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_POKEMON_NOT_FOUND = 2,
                ERROR_INSUFFICIENT_RESOURCES = 3,
                ERROR_UPGRADE_NOT_AVAILABLE = 4,
                ERROR_POKEMON_IS_DEPLOYED = 5,
                ERROR_DUPLICATE_REQUEST = 6,
                ERROR_FUSION_COMPONENT_POKEMON = 7
            }

            interface IBulkUpgradesCost {
                number_of_upgrades?: (number|null);
                pokemon_level?: (number|null);
                pokemon_cp?: (number|null);
                total_stardust_cost?: (number|null);
                total_candy_cost?: (number|null);
                total_cp_multiplier?: (number|null);
                total_xl_candy_cost?: (number|null);
            }

            class BulkUpgradesCost implements IBulkUpgradesCost {
                constructor(properties?: POGOProtos.Rpc.UpgradePokemonOutProto.IBulkUpgradesCost);
                public number_of_upgrades: number;
                public pokemon_level: number;
                public pokemon_cp: number;
                public total_stardust_cost: number;
                public total_candy_cost: number;
                public total_cp_multiplier: number;
                public total_xl_candy_cost: number;
                public static encode(message: POGOProtos.Rpc.UpgradePokemonOutProto.IBulkUpgradesCost, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpgradePokemonOutProto.BulkUpgradesCost;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpgradePokemonOutProto.BulkUpgradesCost;
                public static toObject(message: POGOProtos.Rpc.UpgradePokemonOutProto.BulkUpgradesCost, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IUpgradePokemonProto {
            pokemon_id?: (number|Long|null);
            preview?: (boolean|null);
            number_of_upgrades?: (number|null);
            pokemon_current_cp?: (number|null);
        }

        class UpgradePokemonProto implements IUpgradePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IUpgradePokemonProto);
            public pokemon_id: (number|Long);
            public preview: boolean;
            public number_of_upgrades: number;
            public pokemon_current_cp: number;
            public static encode(message: POGOProtos.Rpc.IUpgradePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpgradePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpgradePokemonProto;
            public static toObject(message: POGOProtos.Rpc.UpgradePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUploadCombatClientLogOutProto {
            result?: (POGOProtos.Rpc.UploadCombatClientLogOutProto.Result|null);
        }

        class UploadCombatClientLogOutProto implements IUploadCombatClientLogOutProto {
            constructor(properties?: POGOProtos.Rpc.IUploadCombatClientLogOutProto);
            public result: POGOProtos.Rpc.UploadCombatClientLogOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IUploadCombatClientLogOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadCombatClientLogOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadCombatClientLogOutProto;
            public static toObject(message: POGOProtos.Rpc.UploadCombatClientLogOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UploadCombatClientLogOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_ENABLED = 2,
                ERROR_TOO_MANY_REQUESTS = 3,
                ERROR_INVALID_FORMAT = 4,
                ERROR_EXCEEDS_SIZE_LIMIT = 5,
                ERROR_INTERNAL_ERROR = 6
            }
        }

        interface IUploadCombatClientLogProto {
            combat_client_log?: (POGOProtos.Rpc.ICombatClientLog|null);
        }

        class UploadCombatClientLogProto implements IUploadCombatClientLogProto {
            constructor(properties?: POGOProtos.Rpc.IUploadCombatClientLogProto);
            public combat_client_log?: (POGOProtos.Rpc.ICombatClientLog|null);
            public static encode(message: POGOProtos.Rpc.IUploadCombatClientLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadCombatClientLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadCombatClientLogProto;
            public static toObject(message: POGOProtos.Rpc.UploadCombatClientLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUploadManagementSettings {
            upload_management_enabled?: (boolean|null);
            upload_management_texture_size?: (number|null);
            enable_gcs_uploader?: (boolean|null);
        }

        class UploadManagementSettings implements IUploadManagementSettings {
            constructor(properties?: POGOProtos.Rpc.IUploadManagementSettings);
            public upload_management_enabled: boolean;
            public upload_management_texture_size: number;
            public enable_gcs_uploader: boolean;
            public static encode(message: POGOProtos.Rpc.IUploadManagementSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadManagementSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadManagementSettings;
            public static toObject(message: POGOProtos.Rpc.UploadManagementSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUploadManagementTelemetry {
            upload_management_telemetry_id?: (POGOProtos.Rpc.UploadManagementTelemetry.UploadManagementEventId|null);
        }

        class UploadManagementTelemetry implements IUploadManagementTelemetry {
            constructor(properties?: POGOProtos.Rpc.IUploadManagementTelemetry);
            public upload_management_telemetry_id: POGOProtos.Rpc.UploadManagementTelemetry.UploadManagementEventId;
            public static encode(message: POGOProtos.Rpc.IUploadManagementTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadManagementTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadManagementTelemetry;
            public static toObject(message: POGOProtos.Rpc.UploadManagementTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UploadManagementTelemetry {

            enum UploadManagementEventId {
                UNKNOWN = 0,
                UPLOAD_ALL_FROM_ENTRY_POINT = 1,
                UPLOAD_ALL_FROM_UPLOAD_MGMT_MENU = 2,
                CANCEL_ALL_FROM_ENTRY_POINT = 3,
                CANCEL_ALL_FROM_UPLOAD_MGMT_MENU = 4,
                CANCEL_INDIVIDUAL_UPLOAD = 5,
                DELETE_INDIVIDUAL_UPLOAD = 6,
                UPLOAD_ALL_SUCCESS = 7,
                UPLOAD_ALL_FAILURE = 8
            }
        }

        interface IUploadPoiPhotoByUrlOutProto {
            status?: (POGOProtos.Rpc.PortalCurationImageResult.Result|null);
        }

        class UploadPoiPhotoByUrlOutProto implements IUploadPoiPhotoByUrlOutProto {
            constructor(properties?: POGOProtos.Rpc.IUploadPoiPhotoByUrlOutProto);
            public status: POGOProtos.Rpc.PortalCurationImageResult.Result;
            public static encode(message: POGOProtos.Rpc.IUploadPoiPhotoByUrlOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadPoiPhotoByUrlOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadPoiPhotoByUrlOutProto;
            public static toObject(message: POGOProtos.Rpc.UploadPoiPhotoByUrlOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUploadPoiPhotoByUrlProto {
            request_id?: (string|null);
            image_url?: (string|null);
        }

        class UploadPoiPhotoByUrlProto implements IUploadPoiPhotoByUrlProto {
            constructor(properties?: POGOProtos.Rpc.IUploadPoiPhotoByUrlProto);
            public request_id: string;
            public image_url: string;
            public static encode(message: POGOProtos.Rpc.IUploadPoiPhotoByUrlProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadPoiPhotoByUrlProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadPoiPhotoByUrlProto;
            public static toObject(message: POGOProtos.Rpc.UploadPoiPhotoByUrlProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUploadRaidClientLogOutProto {
            result?: (POGOProtos.Rpc.UploadRaidClientLogOutProto.Result|null);
        }

        class UploadRaidClientLogOutProto implements IUploadRaidClientLogOutProto {
            constructor(properties?: POGOProtos.Rpc.IUploadRaidClientLogOutProto);
            public result: POGOProtos.Rpc.UploadRaidClientLogOutProto.Result;
            public static encode(message: POGOProtos.Rpc.IUploadRaidClientLogOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadRaidClientLogOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadRaidClientLogOutProto;
            public static toObject(message: POGOProtos.Rpc.UploadRaidClientLogOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UploadRaidClientLogOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_ENABLED = 2,
                ERROR_TOO_MANY_REQUESTS = 3,
                ERROR_INVALID_FORMAT = 4,
                ERROR_EXCEEDS_SIZE_LIMIT = 5
            }
        }

        interface IUploadRaidClientLogProto {
            raid_client_log?: (POGOProtos.Rpc.IRaidClientLog|null);
            raid_vnext_client_log?: (POGOProtos.Rpc.IRaidVnextClientLogProto|null);
            bread_client_log?: (POGOProtos.Rpc.IBreadClientLogProto|null);
        }

        class UploadRaidClientLogProto implements IUploadRaidClientLogProto {
            constructor(properties?: POGOProtos.Rpc.IUploadRaidClientLogProto);
            public raid_client_log?: (POGOProtos.Rpc.IRaidClientLog|null);
            public raid_vnext_client_log?: (POGOProtos.Rpc.IRaidVnextClientLogProto|null);
            public bread_client_log?: (POGOProtos.Rpc.IBreadClientLogProto|null);
            public Log?: ("raid_client_log"|"raid_vnext_client_log"|"bread_client_log");
            public static encode(message: POGOProtos.Rpc.IUploadRaidClientLogProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UploadRaidClientLogProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UploadRaidClientLogProto;
            public static toObject(message: POGOProtos.Rpc.UploadRaidClientLogProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpsightLoggingSettingsProto {
            use_verbose_logging?: (boolean|null);
            logging_percentage?: (number|null);
            disable_logging?: (boolean|null);
        }

        class UpsightLoggingSettingsProto implements IUpsightLoggingSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IUpsightLoggingSettingsProto);
            public use_verbose_logging: boolean;
            public logging_percentage: number;
            public disable_logging: boolean;
            public static encode(message: POGOProtos.Rpc.IUpsightLoggingSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpsightLoggingSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpsightLoggingSettingsProto;
            public static toObject(message: POGOProtos.Rpc.UpsightLoggingSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUpstream {
            subscribe?: (POGOProtos.Rpc.Upstream.ISubscriptionRequest|null);
            probe?: (POGOProtos.Rpc.Upstream.IProbeResponse|null);
            request_id?: (number|Long|null);
            token?: (Uint8Array|null);
        }

        class Upstream implements IUpstream {
            constructor(properties?: POGOProtos.Rpc.IUpstream);
            public subscribe?: (POGOProtos.Rpc.Upstream.ISubscriptionRequest|null);
            public probe?: (POGOProtos.Rpc.Upstream.IProbeResponse|null);
            public request_id: (number|Long);
            public token: Uint8Array;
            public Message?: ("subscribe"|"probe");
            public static encode(message: POGOProtos.Rpc.IUpstream, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Upstream;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Upstream;
            public static toObject(message: POGOProtos.Rpc.Upstream, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Upstream {

            interface IProbeResponse {
                probe_start_ms?: (number|Long|null);
                game_context?: (string|null);
                network_type?: (POGOProtos.Rpc.Upstream.ProbeResponse.NetworkType|null);
            }

            class ProbeResponse implements IProbeResponse {
                constructor(properties?: POGOProtos.Rpc.Upstream.IProbeResponse);
                public probe_start_ms: (number|Long);
                public game_context: string;
                public network_type: POGOProtos.Rpc.Upstream.ProbeResponse.NetworkType;
                public static encode(message: POGOProtos.Rpc.Upstream.IProbeResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Upstream.ProbeResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Upstream.ProbeResponse;
                public static toObject(message: POGOProtos.Rpc.Upstream.ProbeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ProbeResponse {

                enum NetworkType {
                    UNSET = 0,
                    DATA = 1,
                    WIFI = 2
                }
            }

            interface ISubscriptionRequest {
                topics?: (POGOProtos.Rpc.ITopicProto[]|null);
            }

            class SubscriptionRequest implements ISubscriptionRequest {
                constructor(properties?: POGOProtos.Rpc.Upstream.ISubscriptionRequest);
                public topics: POGOProtos.Rpc.ITopicProto[];
                public static encode(message: POGOProtos.Rpc.Upstream.ISubscriptionRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Upstream.SubscriptionRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Upstream.SubscriptionRequest;
                public static toObject(message: POGOProtos.Rpc.Upstream.SubscriptionRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IUpstreamMessage {
            send_message?: (POGOProtos.Rpc.UpstreamMessage.ISendMessage|null);
            leave_room?: (POGOProtos.Rpc.UpstreamMessage.ILeaveRoom|null);
        }

        class UpstreamMessage implements IUpstreamMessage {
            constructor(properties?: POGOProtos.Rpc.IUpstreamMessage);
            public send_message?: (POGOProtos.Rpc.UpstreamMessage.ISendMessage|null);
            public leave_room?: (POGOProtos.Rpc.UpstreamMessage.ILeaveRoom|null);
            public message?: ("send_message"|"leave_room");
            public static encode(message: POGOProtos.Rpc.IUpstreamMessage, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpstreamMessage;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpstreamMessage;
            public static toObject(message: POGOProtos.Rpc.UpstreamMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UpstreamMessage {

            interface ISendMessage {
                receiver?: (number[]|null);
                tag?: (number|null);
                data?: (Uint8Array|null);
            }

            class SendMessage implements ISendMessage {
                constructor(properties?: POGOProtos.Rpc.UpstreamMessage.ISendMessage);
                public receiver: number[];
                public tag: number;
                public data: Uint8Array;
                public static encode(message: POGOProtos.Rpc.UpstreamMessage.ISendMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpstreamMessage.SendMessage;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpstreamMessage.SendMessage;
                public static toObject(message: POGOProtos.Rpc.UpstreamMessage.SendMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ILeaveRoom {
            }

            class LeaveRoom implements ILeaveRoom {
                constructor(properties?: POGOProtos.Rpc.UpstreamMessage.ILeaveRoom);
                public static encode(message: POGOProtos.Rpc.UpstreamMessage.ILeaveRoom, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpstreamMessage.LeaveRoom;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpstreamMessage.LeaveRoom;
                public static toObject(message: POGOProtos.Rpc.UpstreamMessage.LeaveRoom, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IClockSyncRequest {
                request_unix_time_ms?: (number|Long|null);
            }

            class ClockSyncRequest implements IClockSyncRequest {
                constructor(properties?: POGOProtos.Rpc.UpstreamMessage.IClockSyncRequest);
                public request_unix_time_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.UpstreamMessage.IClockSyncRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UpstreamMessage.ClockSyncRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UpstreamMessage.ClockSyncRequest;
                public static toObject(message: POGOProtos.Rpc.UpstreamMessage.ClockSyncRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IUseIncenseActionOutProto {
            result?: (POGOProtos.Rpc.UseIncenseActionOutProto.Result|null);
            applied_incense?: (POGOProtos.Rpc.IAppliedItemProto|null);
            awarded_items?: (POGOProtos.Rpc.ILootProto|null);
        }

        class UseIncenseActionOutProto implements IUseIncenseActionOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseIncenseActionOutProto);
            public result: POGOProtos.Rpc.UseIncenseActionOutProto.Result;
            public applied_incense?: (POGOProtos.Rpc.IAppliedItemProto|null);
            public awarded_items?: (POGOProtos.Rpc.ILootProto|null);
            public static encode(message: POGOProtos.Rpc.IUseIncenseActionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseIncenseActionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseIncenseActionOutProto;
            public static toObject(message: POGOProtos.Rpc.UseIncenseActionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseIncenseActionOutProto {

            enum Result {
                UNKNOWN = 0,
                SUCCESS = 1,
                INCENSE_ALREADY_ACTIVE = 2,
                NONE_IN_INVENTORY = 3,
                LOCATION_UNSET = 4,
                INCENSE_DISABLED = 5
            }
        }

        interface IUseIncenseActionProto {
            incense_type?: (POGOProtos.Rpc.Item|null);
            usage?: (POGOProtos.Rpc.UseIncenseActionProto.Usage|null);
        }

        class UseIncenseActionProto implements IUseIncenseActionProto {
            constructor(properties?: POGOProtos.Rpc.IUseIncenseActionProto);
            public incense_type: POGOProtos.Rpc.Item;
            public usage: POGOProtos.Rpc.UseIncenseActionProto.Usage;
            public static encode(message: POGOProtos.Rpc.IUseIncenseActionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseIncenseActionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseIncenseActionProto;
            public static toObject(message: POGOProtos.Rpc.UseIncenseActionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseIncenseActionProto {

            enum Usage {
                UNKNOWN = 0,
                USE = 1,
                PAUSE = 2,
                RESUME = 3
            }
        }

        interface IUseItemBattleBoostOutProto {
            result?: (POGOProtos.Rpc.UseItemBattleBoostOutProto.Result|null);
            applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
        }

        class UseItemBattleBoostOutProto implements IUseItemBattleBoostOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemBattleBoostOutProto);
            public result: POGOProtos.Rpc.UseItemBattleBoostOutProto.Result;
            public applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
            public static encode(message: POGOProtos.Rpc.IUseItemBattleBoostOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemBattleBoostOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemBattleBoostOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemBattleBoostOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemBattleBoostOutProto {

            enum Result {
                UNKNOWN = 0,
                SUCCESS = 1,
                ERROR_NO_ITEMS_REMAINING = 2,
                ERROR_INVALID_ITEM_TYPE = 3,
                ERROR_LOCATION_UNSET = 4,
                ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 5,
                ERROR_FEATURE_DISABLED = 6
            }
        }

        interface IUseItemBattleBoostProto {
            item?: (POGOProtos.Rpc.Item|null);
        }

        class UseItemBattleBoostProto implements IUseItemBattleBoostProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemBattleBoostProto);
            public item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IUseItemBattleBoostProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemBattleBoostProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemBattleBoostProto;
            public static toObject(message: POGOProtos.Rpc.UseItemBattleBoostProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemBulkHealOutProto {
            status?: (POGOProtos.Rpc.UseItemBulkHealOutProto.Status|null);
            heal_results?: (POGOProtos.Rpc.UseItemBulkHealOutProto.IHealResult[]|null);
            remaining_item_count?: (number|null);
        }

        class UseItemBulkHealOutProto implements IUseItemBulkHealOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemBulkHealOutProto);
            public status: POGOProtos.Rpc.UseItemBulkHealOutProto.Status;
            public heal_results: POGOProtos.Rpc.UseItemBulkHealOutProto.IHealResult[];
            public remaining_item_count: number;
            public static encode(message: POGOProtos.Rpc.IUseItemBulkHealOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemBulkHealOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemBulkHealOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemBulkHealOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemBulkHealOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_BAD_REQUEST = 2
            }

            interface IHealResult {
                result?: (POGOProtos.Rpc.UseItemBulkHealOutProto.HealResult.Result|null);
                pokemon_id?: (number|Long|null);
                stamina?: (number|null);
            }

            class HealResult implements IHealResult {
                constructor(properties?: POGOProtos.Rpc.UseItemBulkHealOutProto.IHealResult);
                public result: POGOProtos.Rpc.UseItemBulkHealOutProto.HealResult.Result;
                public pokemon_id: (number|Long);
                public stamina: number;
                public static encode(message: POGOProtos.Rpc.UseItemBulkHealOutProto.IHealResult, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemBulkHealOutProto.HealResult;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemBulkHealOutProto.HealResult;
                public static toObject(message: POGOProtos.Rpc.UseItemBulkHealOutProto.HealResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace HealResult {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_NO_POKEMON = 2,
                    ERROR_CANNOT_USE = 3,
                    ERROR_DEPLOYED_TO_FORT = 4,
                    ERROR_FUSION_COMPONENT_POKEMON = 5
                }
            }
        }

        interface IUseItemBulkHealProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: ((number|Long)[]|null);
        }

        class UseItemBulkHealProto implements IUseItemBulkHealProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemBulkHealProto);
            public item: POGOProtos.Rpc.Item;
            public pokemon_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IUseItemBulkHealProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemBulkHealProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemBulkHealProto;
            public static toObject(message: POGOProtos.Rpc.UseItemBulkHealProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemCaptureOutProto {
            success?: (boolean|null);
            item_capture_mult?: (number|null);
            item_flee_mult?: (number|null);
            stop_movement?: (boolean|null);
            stop_attack?: (boolean|null);
            target_max?: (boolean|null);
            target_slow?: (boolean|null);
        }

        class UseItemCaptureOutProto implements IUseItemCaptureOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemCaptureOutProto);
            public success: boolean;
            public item_capture_mult: number;
            public item_flee_mult: number;
            public stop_movement: boolean;
            public stop_attack: boolean;
            public target_max: boolean;
            public target_slow: boolean;
            public static encode(message: POGOProtos.Rpc.IUseItemCaptureOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemCaptureOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemCaptureOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemCaptureOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemCaptureProto {
            item?: (POGOProtos.Rpc.Item|null);
            encounter_id?: (number|Long|null);
            spawn_point_guid?: (string|null);
        }

        class UseItemCaptureProto implements IUseItemCaptureProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemCaptureProto);
            public item: POGOProtos.Rpc.Item;
            public encounter_id: (number|Long);
            public spawn_point_guid: string;
            public static encode(message: POGOProtos.Rpc.IUseItemCaptureProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemCaptureProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemCaptureProto;
            public static toObject(message: POGOProtos.Rpc.UseItemCaptureProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemEggIncubatorOutProto {
            result?: (POGOProtos.Rpc.UseItemEggIncubatorOutProto.Result|null);
            egg_incubator?: (POGOProtos.Rpc.IEggIncubatorProto|null);
        }

        class UseItemEggIncubatorOutProto implements IUseItemEggIncubatorOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemEggIncubatorOutProto);
            public result: POGOProtos.Rpc.UseItemEggIncubatorOutProto.Result;
            public egg_incubator?: (POGOProtos.Rpc.IEggIncubatorProto|null);
            public static encode(message: POGOProtos.Rpc.IUseItemEggIncubatorOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemEggIncubatorOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemEggIncubatorOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemEggIncubatorOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemEggIncubatorOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INCUBATOR_NOT_FOUND = 2,
                ERROR_POKEMON_EGG_NOT_FOUND = 3,
                ERROR_POKEMON_ID_NOT_EGG = 4,
                ERROR_INCUBATOR_ALREADY_IN_USE = 5,
                ERROR_POKEMON_ALREADY_INCUBATING = 6,
                ERROR_INCUBATOR_NO_USES_REMAINING = 7
            }
        }

        interface IUseItemEggIncubatorProto {
            item_id?: (string|null);
            pokemond_id?: (number|Long|null);
            eggs_home_widget_active?: (boolean|null);
        }

        class UseItemEggIncubatorProto implements IUseItemEggIncubatorProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemEggIncubatorProto);
            public item_id: string;
            public pokemond_id: (number|Long);
            public eggs_home_widget_active: boolean;
            public static encode(message: POGOProtos.Rpc.IUseItemEggIncubatorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemEggIncubatorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemEggIncubatorProto;
            public static toObject(message: POGOProtos.Rpc.UseItemEggIncubatorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemEncounterOutProto {
            status?: (POGOProtos.Rpc.UseItemEncounterOutProto.Status|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
        }

        class UseItemEncounterOutProto implements IUseItemEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemEncounterOutProto);
            public status: POGOProtos.Rpc.UseItemEncounterOutProto.Status;
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IUseItemEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemEncounterOutProto {

            enum Status {
                SUCCESS = 0,
                ALREADY_COMPLETED = 1,
                ACTIVE_ITEM_EXISTS = 2,
                NO_ITEM_IN_INVENTORY = 3,
                INVALID_ITEM_CATEGORY = 4
            }
        }

        interface IUseItemEncounterProto {
            item?: (POGOProtos.Rpc.Item|null);
            encounter_id?: (number|Long|null);
            spawn_point_guid?: (string|null);
        }

        class UseItemEncounterProto implements IUseItemEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemEncounterProto);
            public item: POGOProtos.Rpc.Item;
            public encounter_id: (number|Long);
            public spawn_point_guid: string;
            public static encode(message: POGOProtos.Rpc.IUseItemEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemEncounterProto;
            public static toObject(message: POGOProtos.Rpc.UseItemEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemLuckyFriendApplicatorOutProto {
            status?: (POGOProtos.Rpc.UseItemLuckyFriendApplicatorOutProto.Status|null);
        }

        class UseItemLuckyFriendApplicatorOutProto implements IUseItemLuckyFriendApplicatorOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemLuckyFriendApplicatorOutProto);
            public status: POGOProtos.Rpc.UseItemLuckyFriendApplicatorOutProto.Status;
            public static encode(message: POGOProtos.Rpc.IUseItemLuckyFriendApplicatorOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemLuckyFriendApplicatorOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemLuckyFriendApplicatorOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemLuckyFriendApplicatorOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemLuckyFriendApplicatorOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_LOW_FRIEND_LEVEL = 2,
                ERROR_FRIEND_NOT_FOUND = 3,
                ERROR_FRIEND_ALREADY_LUCKY = 4,
                ERROR_FRIEND_SETTING_OFF = 5,
                ERROR_ITEM_NOT_IN_INVENTORY = 6,
                ERROR_INVALID_ITEM_TYPE = 7,
                ERROR_FAILED_TO_UPDATE = 8
            }
        }

        interface IUseItemLuckyFriendApplicatorProto {
            item?: (POGOProtos.Rpc.Item|null);
            friend_id?: (string|null);
        }

        class UseItemLuckyFriendApplicatorProto implements IUseItemLuckyFriendApplicatorProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemLuckyFriendApplicatorProto);
            public item: POGOProtos.Rpc.Item;
            public friend_id: string;
            public static encode(message: POGOProtos.Rpc.IUseItemLuckyFriendApplicatorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemLuckyFriendApplicatorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemLuckyFriendApplicatorProto;
            public static toObject(message: POGOProtos.Rpc.UseItemLuckyFriendApplicatorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemMoveRerollOutProto {
            result?: (POGOProtos.Rpc.UseItemMoveRerollOutProto.Result|null);
            updated_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class UseItemMoveRerollOutProto implements IUseItemMoveRerollOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemMoveRerollOutProto);
            public result: POGOProtos.Rpc.UseItemMoveRerollOutProto.Result;
            public updated_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IUseItemMoveRerollOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemMoveRerollOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemMoveRerollOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemMoveRerollOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemMoveRerollOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                NO_POKEMON = 2,
                NO_OTHER_MOVES = 3,
                NO_PLAYER = 4,
                WRONG_ITEM_TYPE = 5,
                ITEM_NOT_IN_INVENTORY = 6,
                INVALID_POKEMON = 7,
                MOVE_LOCKED = 8,
                MOVE_CANNOT_BE_REROLLED = 9,
                INVALID_ELITE_MOVE = 10,
                NOT_ENOUGH_ITEMS = 11
            }
        }

        interface IUseItemMoveRerollProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: (number|Long|null);
            reroll_unlocked_move?: (boolean|null);
            target_elite_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
            target_special_move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class UseItemMoveRerollProto implements IUseItemMoveRerollProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemMoveRerollProto);
            public item: POGOProtos.Rpc.Item;
            public pokemon_id: (number|Long);
            public reroll_unlocked_move: boolean;
            public target_elite_move: POGOProtos.Rpc.HoloPokemonMove;
            public target_special_move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IUseItemMoveRerollProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemMoveRerollProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemMoveRerollProto;
            public static toObject(message: POGOProtos.Rpc.UseItemMoveRerollProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemMpReplenishOutProto {
            status?: (POGOProtos.Rpc.UseItemMpReplenishOutProto.Status|null);
            old_mp_amount?: (number|null);
            new_mp_amount?: (number|null);
        }

        class UseItemMpReplenishOutProto implements IUseItemMpReplenishOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemMpReplenishOutProto);
            public status: POGOProtos.Rpc.UseItemMpReplenishOutProto.Status;
            public old_mp_amount: number;
            public new_mp_amount: number;
            public static encode(message: POGOProtos.Rpc.IUseItemMpReplenishOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemMpReplenishOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemMpReplenishOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemMpReplenishOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemMpReplenishOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NOT_ENOUGH_ITEM = 2,
                ERROR_MP_FULL = 3,
                ERROR_MP_NOT_ENABLED = 4
            }
        }

        interface IUseItemMpReplenishProto {
        }

        class UseItemMpReplenishProto implements IUseItemMpReplenishProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemMpReplenishProto);
            public static encode(message: POGOProtos.Rpc.IUseItemMpReplenishProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemMpReplenishProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemMpReplenishProto;
            public static toObject(message: POGOProtos.Rpc.UseItemMpReplenishProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemPotionOutProto {
            result?: (POGOProtos.Rpc.UseItemPotionOutProto.Result|null);
            stamina?: (number|null);
        }

        class UseItemPotionOutProto implements IUseItemPotionOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemPotionOutProto);
            public result: POGOProtos.Rpc.UseItemPotionOutProto.Result;
            public stamina: number;
            public static encode(message: POGOProtos.Rpc.IUseItemPotionOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemPotionOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemPotionOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemPotionOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemPotionOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NO_POKEMON = 2,
                ERROR_CANNOT_USE = 3,
                ERROR_DEPLOYED_TO_FORT = 4,
                ERROR_FUSION_COMPONENT_POKEMON = 5
            }
        }

        interface IUseItemPotionProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: (number|Long|null);
        }

        class UseItemPotionProto implements IUseItemPotionProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemPotionProto);
            public item: POGOProtos.Rpc.Item;
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUseItemPotionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemPotionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemPotionProto;
            public static toObject(message: POGOProtos.Rpc.UseItemPotionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemRareCandyOutProto {
            result?: (POGOProtos.Rpc.UseItemRareCandyOutProto.Result|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
        }

        class UseItemRareCandyOutProto implements IUseItemRareCandyOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemRareCandyOutProto);
            public result: POGOProtos.Rpc.UseItemRareCandyOutProto.Result;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public static encode(message: POGOProtos.Rpc.IUseItemRareCandyOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemRareCandyOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemRareCandyOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemRareCandyOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemRareCandyOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_POKEMON_ID = 2,
                NO_PLAYER = 3,
                WRONG_ITEM_TYPE = 4,
                ITEM_NOT_IN_INVENTORY = 5,
                NOT_ENOUGH_ITEMS = 6
            }
        }

        interface IUseItemRareCandyProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            candy_count?: (number|null);
        }

        class UseItemRareCandyProto implements IUseItemRareCandyProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemRareCandyProto);
            public item: POGOProtos.Rpc.Item;
            public pokemon_id: POGOProtos.Rpc.HoloPokemonId;
            public candy_count: number;
            public static encode(message: POGOProtos.Rpc.IUseItemRareCandyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemRareCandyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemRareCandyProto;
            public static toObject(message: POGOProtos.Rpc.UseItemRareCandyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemReviveOutProto {
            result?: (POGOProtos.Rpc.UseItemReviveOutProto.Result|null);
            stamina?: (number|null);
        }

        class UseItemReviveOutProto implements IUseItemReviveOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemReviveOutProto);
            public result: POGOProtos.Rpc.UseItemReviveOutProto.Result;
            public stamina: number;
            public static encode(message: POGOProtos.Rpc.IUseItemReviveOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemReviveOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemReviveOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemReviveOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemReviveOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_NO_POKEMON = 2,
                ERROR_CANNOT_USE = 3,
                ERROR_DEPLOYED_TO_FORT = 4,
                ERROR_FUSION_COMPONENT_POKEMON = 5
            }
        }

        interface IUseItemReviveProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: (number|Long|null);
        }

        class UseItemReviveProto implements IUseItemReviveProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemReviveProto);
            public item: POGOProtos.Rpc.Item;
            public pokemon_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IUseItemReviveProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemReviveProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemReviveProto;
            public static toObject(message: POGOProtos.Rpc.UseItemReviveProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemStardustBoostOutProto {
            result?: (POGOProtos.Rpc.UseItemStardustBoostOutProto.Result|null);
            applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
        }

        class UseItemStardustBoostOutProto implements IUseItemStardustBoostOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemStardustBoostOutProto);
            public result: POGOProtos.Rpc.UseItemStardustBoostOutProto.Result;
            public applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
            public static encode(message: POGOProtos.Rpc.IUseItemStardustBoostOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemStardustBoostOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemStardustBoostOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemStardustBoostOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemStardustBoostOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_ITEM_TYPE = 2,
                ERROR_STARDUST_BOOST_ALREADY_ACTIVE = 3,
                ERROR_NO_ITEMS_REMAINING = 4,
                ERROR_LOCATION_UNSET = 5
            }
        }

        interface IUseItemStardustBoostProto {
            item?: (POGOProtos.Rpc.Item|null);
        }

        class UseItemStardustBoostProto implements IUseItemStardustBoostProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemStardustBoostProto);
            public item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IUseItemStardustBoostProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemStardustBoostProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemStardustBoostProto;
            public static toObject(message: POGOProtos.Rpc.UseItemStardustBoostProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemStatIncreaseOutProto {
            status?: (POGOProtos.Rpc.UseItemStatIncreaseOutProto.Status|null);
            trainee_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class UseItemStatIncreaseOutProto implements IUseItemStatIncreaseOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemStatIncreaseOutProto);
            public status: POGOProtos.Rpc.UseItemStatIncreaseOutProto.Status;
            public trainee_pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IUseItemStatIncreaseOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemStatIncreaseOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemStatIncreaseOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemStatIncreaseOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemStatIncreaseOutProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_ITEM_NOT_IN_INVENTORY = 2,
                ERROR_INVALID_ITEM_TYPE = 3,
                ERROR_CANNOT_BE_USED_ON_POKEMON = 4,
                ERROR_INVALID_POKEMON = 5,
                ERROR_MAX_STAT_LEVEL = 6,
                ERROR_INVALID_STAT = 7,
                ERROR_SURPASSED_LIMIT_OF_STATS_TO_TRAIN = 8,
                ERROR_INVALID_STAT_LEVEL = 9
            }
        }

        interface IUseItemStatIncreaseProto {
            item?: (POGOProtos.Rpc.Item|null);
            pokemon_id?: (number|Long|null);
            stat_types?: (POGOProtos.Rpc.PokemonIndividualStatType[]|null);
            stat_types_with_goal?: (POGOProtos.Rpc.IPokemonTrainingTypeGroupProto[]|null);
        }

        class UseItemStatIncreaseProto implements IUseItemStatIncreaseProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemStatIncreaseProto);
            public item: POGOProtos.Rpc.Item;
            public pokemon_id: (number|Long);
            public stat_types: POGOProtos.Rpc.PokemonIndividualStatType[];
            public stat_types_with_goal: POGOProtos.Rpc.IPokemonTrainingTypeGroupProto[];
            public static encode(message: POGOProtos.Rpc.IUseItemStatIncreaseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemStatIncreaseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemStatIncreaseProto;
            public static toObject(message: POGOProtos.Rpc.UseItemStatIncreaseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseItemXpBoostOutProto {
            result?: (POGOProtos.Rpc.UseItemXpBoostOutProto.Result|null);
            applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
        }

        class UseItemXpBoostOutProto implements IUseItemXpBoostOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemXpBoostOutProto);
            public result: POGOProtos.Rpc.UseItemXpBoostOutProto.Result;
            public applied_items?: (POGOProtos.Rpc.IAppliedItemsProto|null);
            public static encode(message: POGOProtos.Rpc.IUseItemXpBoostOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemXpBoostOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemXpBoostOutProto;
            public static toObject(message: POGOProtos.Rpc.UseItemXpBoostOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseItemXpBoostOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_INVALID_ITEM_TYPE = 2,
                ERROR_XP_BOOST_ALREADY_ACTIVE = 3,
                ERROR_NO_ITEMS_REMAINING = 4,
                ERROR_LOCATION_UNSET = 5
            }
        }

        interface IUseItemXpBoostProto {
            item?: (POGOProtos.Rpc.Item|null);
        }

        class UseItemXpBoostProto implements IUseItemXpBoostProto {
            constructor(properties?: POGOProtos.Rpc.IUseItemXpBoostProto);
            public item: POGOProtos.Rpc.Item;
            public static encode(message: POGOProtos.Rpc.IUseItemXpBoostProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseItemXpBoostProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseItemXpBoostProto;
            public static toObject(message: POGOProtos.Rpc.UseItemXpBoostProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseNonCombatMoveLogEntry {
            pokedex_id?: (POGOProtos.Rpc.HoloPokemonId|null);
            pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            move_id?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class UseNonCombatMoveLogEntry implements IUseNonCombatMoveLogEntry {
            constructor(properties?: POGOProtos.Rpc.IUseNonCombatMoveLogEntry);
            public pokedex_id: POGOProtos.Rpc.HoloPokemonId;
            public pokemon_display?: (POGOProtos.Rpc.IPokemonDisplayProto|null);
            public move_id: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IUseNonCombatMoveLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseNonCombatMoveLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseNonCombatMoveLogEntry;
            public static toObject(message: POGOProtos.Rpc.UseNonCombatMoveLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseNonCombatMoveRequestProto {
            pokemon_id?: (number|Long|null);
            move_type?: (POGOProtos.Rpc.NonCombatMoveType|null);
            number_of_uses?: (number|null);
        }

        class UseNonCombatMoveRequestProto implements IUseNonCombatMoveRequestProto {
            constructor(properties?: POGOProtos.Rpc.IUseNonCombatMoveRequestProto);
            public pokemon_id: (number|Long);
            public move_type: POGOProtos.Rpc.NonCombatMoveType;
            public number_of_uses: number;
            public static encode(message: POGOProtos.Rpc.IUseNonCombatMoveRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseNonCombatMoveRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseNonCombatMoveRequestProto;
            public static toObject(message: POGOProtos.Rpc.UseNonCombatMoveRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUseNonCombatMoveResponseProto {
            status?: (POGOProtos.Rpc.UseNonCombatMoveResponseProto.Status|null);
            applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto|null);
        }

        class UseNonCombatMoveResponseProto implements IUseNonCombatMoveResponseProto {
            constructor(properties?: POGOProtos.Rpc.IUseNonCombatMoveResponseProto);
            public status: POGOProtos.Rpc.UseNonCombatMoveResponseProto.Status;
            public applied_bonus?: (POGOProtos.Rpc.IAppliedBonusProto|null);
            public static encode(message: POGOProtos.Rpc.IUseNonCombatMoveResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseNonCombatMoveResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseNonCombatMoveResponseProto;
            public static toObject(message: POGOProtos.Rpc.UseNonCombatMoveResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseNonCombatMoveResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_NO_POKEMON = 3,
                ERROR_NO_MOVE = 4,
                ERROR_INSUFFICIENT_FUNDS = 5,
                ERROR_EXCEEDS_BONUS_LIMIT = 6,
                ERROR_NOT_ENABLED = 7
            }
        }

        interface IUseSaveForLaterOutProto {
            result?: (POGOProtos.Rpc.UseSaveForLaterOutProto.Result|null);
            save_for_later_pokemon?: (POGOProtos.Rpc.ISaveForLaterBreadPokemonProto|null);
        }

        class UseSaveForLaterOutProto implements IUseSaveForLaterOutProto {
            constructor(properties?: POGOProtos.Rpc.IUseSaveForLaterOutProto);
            public result: POGOProtos.Rpc.UseSaveForLaterOutProto.Result;
            public save_for_later_pokemon?: (POGOProtos.Rpc.ISaveForLaterBreadPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IUseSaveForLaterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseSaveForLaterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseSaveForLaterOutProto;
            public static toObject(message: POGOProtos.Rpc.UseSaveForLaterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace UseSaveForLaterOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_SAVE_FOR_LATER_NOT_FOUND = 2,
                ERROR_SAVE_FOR_LATER_EXPIRED = 3,
                ERROR_SAVE_FOR_LATER_ALREADY_USED = 4,
                ERROR_SAVE_FOR_LATER_ATTEMPT_REACHED = 5,
                ERROR_SAVE_FOR_LATER_NOT_ENABLED = 6
            }
        }

        interface IUseSaveForLaterProto {
            save_for_later_seed?: (string|null);
        }

        class UseSaveForLaterProto implements IUseSaveForLaterProto {
            constructor(properties?: POGOProtos.Rpc.IUseSaveForLaterProto);
            public save_for_later_seed: string;
            public static encode(message: POGOProtos.Rpc.IUseSaveForLaterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UseSaveForLaterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UseSaveForLaterProto;
            public static toObject(message: POGOProtos.Rpc.UseSaveForLaterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUserAttributesProto {
            level?: (number|null);
            xp_percentage?: (number|Long|null);
            pokecoin_count?: (number|Long|null);
            team?: (POGOProtos.Rpc.Team|null);
            catch_streak?: (number|null);
            spin_streak?: (number|null);
            buddy_name?: (string|null);
            is_egg_incubating?: (boolean|null);
            has_eggs?: (boolean|null);
            star_piece_count?: (number|null);
            lucky_egg_count?: (number|null);
            incense_ordinary_count?: (number|null);
            incense_spicy_count?: (number|null);
            incense_cool_count?: (number|null);
            incense_floral_count?: (number|null);
            lure_ordinary_count?: (number|null);
            lure_mossy_count?: (number|null);
            lure_glacial_count?: (number|null);
            lure_magnetic_count?: (number|null);
            using_star_piece?: (boolean|null);
            using_lucky_egg?: (boolean|null);
            using_incense_ordinary?: (boolean|null);
            using_incense_spicy?: (boolean|null);
            using_incense_cool?: (boolean|null);
            using_incense_floral?: (boolean|null);
            using_lure_ordinary?: (boolean|null);
            using_lure_mossy?: (boolean|null);
            using_lure_glacial?: (boolean|null);
            using_lure_magnetic?: (boolean|null);
            adventure_sync_opt_in?: (boolean|null);
            geo_fence_opt_in?: (boolean|null);
            kanto_dex_count?: (number|null);
            johto_dex_count?: (number|null);
            hoenn_dex_count?: (number|null);
            sinnoh_dex_count?: (number|null);
            friend_count?: (number|null);
            field_research_stamp_progress?: (number|null);
            level_up?: (number|null);
            sent_friend_request?: (boolean|null);
            is_egg_incubating_v2?: (string|null);
            has_eggs_v2?: (string|null);
            using_star_piece_v2?: (string|null);
            using_lucky_egg_v2?: (string|null);
            using_incense_ordinary_v2?: (string|null);
            using_incense_spicy_v2?: (string|null);
            using_incense_cool_v2?: (string|null);
            using_incense_floral_v2?: (string|null);
            using_lure_ordinary_v2?: (string|null);
            using_lure_mossy_v2?: (string|null);
            using_lure_glacial_v2?: (string|null);
            using_lure_magnetic_v2?: (string|null);
            adventure_sync_opt_in_v2?: (string|null);
            geo_fence_opt_in_v2?: (string|null);
            unova_dex_count?: (number|null);
            balloon_battles_completed?: (number|null);
            balloon_battles_won?: (number|null);
            kalos_dex_count?: (number|null);
            alola_dex_count?: (number|null);
            galar_dex_count?: (number|null);
            lure_sparkly_count?: (number|null);
            using_lure_sparkly?: (string|null);
            paldea_dex_count?: (number|null);
        }

        class UserAttributesProto implements IUserAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IUserAttributesProto);
            public level: number;
            public xp_percentage: (number|Long);
            public pokecoin_count: (number|Long);
            public team: POGOProtos.Rpc.Team;
            public catch_streak: number;
            public spin_streak: number;
            public buddy_name: string;
            public is_egg_incubating: boolean;
            public has_eggs: boolean;
            public star_piece_count: number;
            public lucky_egg_count: number;
            public incense_ordinary_count: number;
            public incense_spicy_count: number;
            public incense_cool_count: number;
            public incense_floral_count: number;
            public lure_ordinary_count: number;
            public lure_mossy_count: number;
            public lure_glacial_count: number;
            public lure_magnetic_count: number;
            public using_star_piece: boolean;
            public using_lucky_egg: boolean;
            public using_incense_ordinary: boolean;
            public using_incense_spicy: boolean;
            public using_incense_cool: boolean;
            public using_incense_floral: boolean;
            public using_lure_ordinary: boolean;
            public using_lure_mossy: boolean;
            public using_lure_glacial: boolean;
            public using_lure_magnetic: boolean;
            public adventure_sync_opt_in: boolean;
            public geo_fence_opt_in: boolean;
            public kanto_dex_count: number;
            public johto_dex_count: number;
            public hoenn_dex_count: number;
            public sinnoh_dex_count: number;
            public friend_count: number;
            public field_research_stamp_progress: number;
            public level_up: number;
            public sent_friend_request: boolean;
            public is_egg_incubating_v2: string;
            public has_eggs_v2: string;
            public using_star_piece_v2: string;
            public using_lucky_egg_v2: string;
            public using_incense_ordinary_v2: string;
            public using_incense_spicy_v2: string;
            public using_incense_cool_v2: string;
            public using_incense_floral_v2: string;
            public using_lure_ordinary_v2: string;
            public using_lure_mossy_v2: string;
            public using_lure_glacial_v2: string;
            public using_lure_magnetic_v2: string;
            public adventure_sync_opt_in_v2: string;
            public geo_fence_opt_in_v2: string;
            public unova_dex_count: number;
            public balloon_battles_completed: number;
            public balloon_battles_won: number;
            public kalos_dex_count: number;
            public alola_dex_count: number;
            public galar_dex_count: number;
            public lure_sparkly_count: number;
            public using_lure_sparkly: string;
            public paldea_dex_count: number;
            public static encode(message: POGOProtos.Rpc.IUserAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UserAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UserAttributesProto;
            public static toObject(message: POGOProtos.Rpc.UserAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUserIssueWeatherReport {
            gameplayer_weather?: (string|null);
            alert_active?: (boolean|null);
            severity?: (POGOProtos.Rpc.WeatherAlertProto.Severity|null);
            user_report?: (number|null);
        }

        class UserIssueWeatherReport implements IUserIssueWeatherReport {
            constructor(properties?: POGOProtos.Rpc.IUserIssueWeatherReport);
            public gameplayer_weather: string;
            public alert_active: boolean;
            public severity: POGOProtos.Rpc.WeatherAlertProto.Severity;
            public user_report: number;
            public static encode(message: POGOProtos.Rpc.IUserIssueWeatherReport, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UserIssueWeatherReport;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UserIssueWeatherReport;
            public static toObject(message: POGOProtos.Rpc.UserIssueWeatherReport, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUsernameSuggestionSettingsProto {
            feature_enabled?: (boolean|null);
            num_suggestions_displayed?: (number|null);
            num_suggestions_generated?: (number|null);
            name_generation_service_enabled?: (boolean|null);
        }

        class UsernameSuggestionSettingsProto implements IUsernameSuggestionSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IUsernameSuggestionSettingsProto);
            public feature_enabled: boolean;
            public num_suggestions_displayed: number;
            public num_suggestions_generated: number;
            public name_generation_service_enabled: boolean;
            public static encode(message: POGOProtos.Rpc.IUsernameSuggestionSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UsernameSuggestionSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UsernameSuggestionSettingsProto;
            public static toObject(message: POGOProtos.Rpc.UsernameSuggestionSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IUsernameSuggestionTelemetry {
            username_suggestion_telemetry_id?: (POGOProtos.Rpc.UsernameSuggestionTelemetryId|null);
            name_entry_mode?: (POGOProtos.Rpc.EnterUsernameMode|null);
        }

        class UsernameSuggestionTelemetry implements IUsernameSuggestionTelemetry {
            constructor(properties?: POGOProtos.Rpc.IUsernameSuggestionTelemetry);
            public username_suggestion_telemetry_id: POGOProtos.Rpc.UsernameSuggestionTelemetryId;
            public name_entry_mode: POGOProtos.Rpc.EnterUsernameMode;
            public static encode(message: POGOProtos.Rpc.IUsernameSuggestionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.UsernameSuggestionTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.UsernameSuggestionTelemetry;
            public static toObject(message: POGOProtos.Rpc.UsernameSuggestionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryAttribute {
            field?: (POGOProtos.Rpc.IV1TelemetryField|null);
            value?: (POGOProtos.Rpc.IV1TelemetryValue|null);
            timestamp?: (number|Long|null);
        }

        class V1TelemetryAttribute implements IV1TelemetryAttribute {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryAttribute);
            public field?: (POGOProtos.Rpc.IV1TelemetryField|null);
            public value?: (POGOProtos.Rpc.IV1TelemetryValue|null);
            public timestamp: (number|Long);
            public static encode(message: POGOProtos.Rpc.IV1TelemetryAttribute, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryAttribute;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryAttribute;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryAttribute, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace V1TelemetryAttribute {

            interface ILabel {
                field?: (POGOProtos.Rpc.IV1TelemetryField|null);
            }

            class Label implements ILabel {
                constructor(properties?: POGOProtos.Rpc.V1TelemetryAttribute.ILabel);
                public field?: (POGOProtos.Rpc.IV1TelemetryField|null);
                public static encode(message: POGOProtos.Rpc.V1TelemetryAttribute.ILabel, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryAttribute.Label;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryAttribute.Label;
                public static toObject(message: POGOProtos.Rpc.V1TelemetryAttribute.Label, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IV1TelemetryAttributeRecordProto {
            common?: (POGOProtos.Rpc.IV1TelemetryMetadataProto|null);
            attribute?: (POGOProtos.Rpc.IV1TelemetryAttribute|null);
        }

        class V1TelemetryAttributeRecordProto implements IV1TelemetryAttributeRecordProto {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryAttributeRecordProto);
            public common?: (POGOProtos.Rpc.IV1TelemetryMetadataProto|null);
            public attribute?: (POGOProtos.Rpc.IV1TelemetryAttribute|null);
            public static encode(message: POGOProtos.Rpc.IV1TelemetryAttributeRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryAttributeRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryAttributeRecordProto;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryAttributeRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryAttributeV2 {
            attribute_name?: (string|null);
            value?: (POGOProtos.Rpc.IV1TelemetryValue|null);
        }

        class V1TelemetryAttributeV2 implements IV1TelemetryAttributeV2 {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryAttributeV2);
            public attribute_name: string;
            public value?: (POGOProtos.Rpc.IV1TelemetryValue|null);
            public static encode(message: POGOProtos.Rpc.IV1TelemetryAttributeV2, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryAttributeV2;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryAttributeV2;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryAttributeV2, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryBatchProto {
            environment_id?: (string|null);
            events?: (POGOProtos.Rpc.IV1TelemetryEventRecordProto[]|null);
        }

        class V1TelemetryBatchProto implements IV1TelemetryBatchProto {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryBatchProto);
            public environment_id: string;
            public events: POGOProtos.Rpc.IV1TelemetryEventRecordProto[];
            public static encode(message: POGOProtos.Rpc.IV1TelemetryBatchProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryBatchProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryBatchProto;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryBatchProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryEventRecordProto {
            common?: (POGOProtos.Rpc.IV1TelemetryMetadataProto|null);
            event_name?: (string|null);
            encoded_message?: (Uint8Array|null);
            facet_detail_name?: (string|null);
        }

        class V1TelemetryEventRecordProto implements IV1TelemetryEventRecordProto {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryEventRecordProto);
            public common?: (POGOProtos.Rpc.IV1TelemetryMetadataProto|null);
            public event_name: string;
            public encoded_message: Uint8Array;
            public facet_detail_name: string;
            public static encode(message: POGOProtos.Rpc.IV1TelemetryEventRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryEventRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryEventRecordProto;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryEventRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryField {
            entity_name?: (string|null);
            field_path?: (string|null);
        }

        class V1TelemetryField implements IV1TelemetryField {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryField);
            public entity_name: string;
            public field_path: string;
            public static encode(message: POGOProtos.Rpc.IV1TelemetryField, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryField;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryField;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryField, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryKey {
            key_name?: (string|null);
            value?: (POGOProtos.Rpc.IV1TelemetryValue|null);
        }

        class V1TelemetryKey implements IV1TelemetryKey {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryKey);
            public key_name: string;
            public value?: (POGOProtos.Rpc.IV1TelemetryValue|null);
            public static encode(message: POGOProtos.Rpc.IV1TelemetryKey, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryKey;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryKey;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryKey, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IV1TelemetryMetadataProto {
            user_id?: (string|null);
            session_id?: (number|Long|null);
            record_id?: (string|null);
            telemetry_scope_id?: (POGOProtos.Rpc.V1TelemetryMetadataProto.TelemetryScopeId|null);
            is_queryable?: (boolean|null);
            keyvalue_column?: (string|null);
            processing_attempts_count?: (number|null);
            pub_sub_message_id?: (string|null);
        }

        class V1TelemetryMetadataProto implements IV1TelemetryMetadataProto {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryMetadataProto);
            public user_id: string;
            public session_id: (number|Long);
            public record_id: string;
            public telemetry_scope_id: POGOProtos.Rpc.V1TelemetryMetadataProto.TelemetryScopeId;
            public is_queryable: boolean;
            public keyvalue_column: string;
            public processing_attempts_count: number;
            public pub_sub_message_id: string;
            public static encode(message: POGOProtos.Rpc.IV1TelemetryMetadataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryMetadataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryMetadataProto;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryMetadataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace V1TelemetryMetadataProto {

            enum TelemetryScopeId {
                unset = 0,
                platform_server = 1,
                platform_client = 2,
                game_server = 3,
                game_client = 4
            }
        }

        interface IV1TelemetryMetricRecordProto {
            long?: (number|Long|null);
            double?: (number|null);
            boolean?: (boolean|null);
            common?: (POGOProtos.Rpc.IV1TelemetryMetadataProto|null);
            metric_id?: (string|null);
        }

        class V1TelemetryMetricRecordProto implements IV1TelemetryMetricRecordProto {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryMetricRecordProto);
            public long?: (number|Long|null);
            public double?: (number|null);
            public boolean?: (boolean|null);
            public common?: (POGOProtos.Rpc.IV1TelemetryMetadataProto|null);
            public metric_id: string;
            public Value?: ("long"|"double"|"boolean");
            public static encode(message: POGOProtos.Rpc.IV1TelemetryMetricRecordProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryMetricRecordProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryMetricRecordProto;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryMetricRecordProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace V1TelemetryMetricRecordProto {

            enum Kind {
                unspecified = 0,
                gauge = 1,
                delta = 2,
                cumulative = 3
            }
        }

        interface IV1TelemetryValue {
            int_value?: (number|Long|null);
            double_value?: (number|null);
            string_value?: (string|null);
            bool_value?: (boolean|null);
        }

        class V1TelemetryValue implements IV1TelemetryValue {
            constructor(properties?: POGOProtos.Rpc.IV1TelemetryValue);
            public int_value?: (number|Long|null);
            public double_value?: (number|null);
            public string_value?: (string|null);
            public bool_value?: (boolean|null);
            public Value?: ("int_value"|"double_value"|"string_value"|"bool_value");
            public static encode(message: POGOProtos.Rpc.IV1TelemetryValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.V1TelemetryValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.V1TelemetryValue;
            public static toObject(message: POGOProtos.Rpc.V1TelemetryValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IValidateNiaAppleAuthTokenRequestProto {
            nia_apple_auth_token?: (Uint8Array|null);
        }

        class ValidateNiaAppleAuthTokenRequestProto implements IValidateNiaAppleAuthTokenRequestProto {
            constructor(properties?: POGOProtos.Rpc.IValidateNiaAppleAuthTokenRequestProto);
            public nia_apple_auth_token: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IValidateNiaAppleAuthTokenRequestProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ValidateNiaAppleAuthTokenRequestProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ValidateNiaAppleAuthTokenRequestProto;
            public static toObject(message: POGOProtos.Rpc.ValidateNiaAppleAuthTokenRequestProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IValidateNiaAppleAuthTokenResponseProto {
            status?: (POGOProtos.Rpc.ValidateNiaAppleAuthTokenResponseProto.Status|null);
        }

        class ValidateNiaAppleAuthTokenResponseProto implements IValidateNiaAppleAuthTokenResponseProto {
            constructor(properties?: POGOProtos.Rpc.IValidateNiaAppleAuthTokenResponseProto);
            public status: POGOProtos.Rpc.ValidateNiaAppleAuthTokenResponseProto.Status;
            public static encode(message: POGOProtos.Rpc.IValidateNiaAppleAuthTokenResponseProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ValidateNiaAppleAuthTokenResponseProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ValidateNiaAppleAuthTokenResponseProto;
            public static toObject(message: POGOProtos.Rpc.ValidateNiaAppleAuthTokenResponseProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ValidateNiaAppleAuthTokenResponseProto {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                INVALID_AUTH = 2,
                EXPIRED_AUTH = 3,
                SERVER_ERROR = 4
            }
        }

        interface IValue {
            null_value?: (POGOProtos.Rpc.NullValue|null);
            number_value?: (number|null);
            string_value?: (string|null);
            bool_value?: (boolean|null);
            struct_value?: (POGOProtos.Rpc.IStruct|null);
            list_value?: (POGOProtos.Rpc.IListValue|null);
        }

        class Value implements IValue {
            constructor(properties?: POGOProtos.Rpc.IValue);
            public null_value?: (POGOProtos.Rpc.NullValue|null);
            public number_value?: (number|null);
            public string_value?: (string|null);
            public bool_value?: (boolean|null);
            public struct_value?: (POGOProtos.Rpc.IStruct|null);
            public list_value?: (POGOProtos.Rpc.IListValue|null);
            public Kind?: ("null_value"|"number_value"|"string_value"|"bool_value"|"struct_value"|"list_value");
            public static encode(message: POGOProtos.Rpc.IValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Value;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Value;
            public static toObject(message: POGOProtos.Rpc.Value, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVasaClientAction {
            action?: (POGOProtos.Rpc.VasaClientAction.ActionEnum|null);
        }

        class VasaClientAction implements IVasaClientAction {
            constructor(properties?: POGOProtos.Rpc.IVasaClientAction);
            public action: POGOProtos.Rpc.VasaClientAction.ActionEnum;
            public static encode(message: POGOProtos.Rpc.IVasaClientAction, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VasaClientAction;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VasaClientAction;
            public static toObject(message: POGOProtos.Rpc.VasaClientAction, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VasaClientAction {

            enum ActionEnum {
                INVALID_VASA_CLIENT_ACTION = 0,
                COLLECT_ADID = 8000
            }
        }

        interface IVector3 {
            x?: (number|null);
            y?: (number|null);
            z?: (number|null);
        }

        class Vector3 implements IVector3 {
            constructor(properties?: POGOProtos.Rpc.IVector3);
            public x: number;
            public y: number;
            public z: number;
            public static encode(message: POGOProtos.Rpc.IVector3, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.Vector3;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.Vector3;
            public static toObject(message: POGOProtos.Rpc.Vector3, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVerboseLogCombatProto {
            enabled?: (boolean|null);
            enable_core_combat?: (boolean|null);
            enable_combat_challenge_setup?: (boolean|null);
            enable_combat_vs_seeker_setup?: (boolean|null);
            enable_web_socket?: (boolean|null);
            enable_on_application_focus?: (boolean|null);
            enable_on_application_pause?: (boolean|null);
            enable_on_application_quit?: (boolean|null);
            enable_exception_caught?: (boolean|null);
            progress_token_priority?: (number|null);
            enable_rpc_error_data?: (boolean|null);
            client_log_decay_time_in_hours?: (number|null);
        }

        class VerboseLogCombatProto implements IVerboseLogCombatProto {
            constructor(properties?: POGOProtos.Rpc.IVerboseLogCombatProto);
            public enabled: boolean;
            public enable_core_combat: boolean;
            public enable_combat_challenge_setup: boolean;
            public enable_combat_vs_seeker_setup: boolean;
            public enable_web_socket: boolean;
            public enable_on_application_focus: boolean;
            public enable_on_application_pause: boolean;
            public enable_on_application_quit: boolean;
            public enable_exception_caught: boolean;
            public progress_token_priority: number;
            public enable_rpc_error_data: boolean;
            public client_log_decay_time_in_hours: number;
            public static encode(message: POGOProtos.Rpc.IVerboseLogCombatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VerboseLogCombatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VerboseLogCombatProto;
            public static toObject(message: POGOProtos.Rpc.VerboseLogCombatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVerboseLogRaidProto {
            enabled?: (boolean|null);
            enable_join_lobby?: (boolean|null);
            enable_leave_lobby?: (boolean|null);
            enable_lobby_visibility?: (boolean|null);
            enable_get_raid_details?: (boolean|null);
            enable_start_raid_battle?: (boolean|null);
            enable_attack_raid?: (boolean|null);
            enable_send_raid_invitation?: (boolean|null);
            enable_on_application_focus?: (boolean|null);
            enable_on_application_pause?: (boolean|null);
            enable_on_application_quit?: (boolean|null);
            enable_exception_caught?: (boolean|null);
            enable_progress_token?: (boolean|null);
            enable_rpc_error_data?: (boolean|null);
            enable_client_prediction_inconsistency_data?: (boolean|null);
            client_log_decay_time_in_hours?: (number|null);
        }

        class VerboseLogRaidProto implements IVerboseLogRaidProto {
            constructor(properties?: POGOProtos.Rpc.IVerboseLogRaidProto);
            public enabled: boolean;
            public enable_join_lobby: boolean;
            public enable_leave_lobby: boolean;
            public enable_lobby_visibility: boolean;
            public enable_get_raid_details: boolean;
            public enable_start_raid_battle: boolean;
            public enable_attack_raid: boolean;
            public enable_send_raid_invitation: boolean;
            public enable_on_application_focus: boolean;
            public enable_on_application_pause: boolean;
            public enable_on_application_quit: boolean;
            public enable_exception_caught: boolean;
            public enable_progress_token: boolean;
            public enable_rpc_error_data: boolean;
            public enable_client_prediction_inconsistency_data: boolean;
            public client_log_decay_time_in_hours: number;
            public static encode(message: POGOProtos.Rpc.IVerboseLogRaidProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VerboseLogRaidProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VerboseLogRaidProto;
            public static toObject(message: POGOProtos.Rpc.VerboseLogRaidProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVerifyChallengeOutProto {
            success?: (boolean|null);
        }

        class VerifyChallengeOutProto implements IVerifyChallengeOutProto {
            constructor(properties?: POGOProtos.Rpc.IVerifyChallengeOutProto);
            public success: boolean;
            public static encode(message: POGOProtos.Rpc.IVerifyChallengeOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VerifyChallengeOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VerifyChallengeOutProto;
            public static toObject(message: POGOProtos.Rpc.VerifyChallengeOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVerifyChallengeProto {
            token?: (string|null);
        }

        class VerifyChallengeProto implements IVerifyChallengeProto {
            constructor(properties?: POGOProtos.Rpc.IVerifyChallengeProto);
            public token: string;
            public static encode(message: POGOProtos.Rpc.IVerifyChallengeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VerifyChallengeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VerifyChallengeProto;
            public static toObject(message: POGOProtos.Rpc.VerifyChallengeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVersionedKey {
            key?: (POGOProtos.Rpc.IKey|null);
            version?: (number|null);
        }

        class VersionedKey implements IVersionedKey {
            constructor(properties?: POGOProtos.Rpc.IVersionedKey);
            public key?: (POGOProtos.Rpc.IKey|null);
            public version: number;
            public static encode(message: POGOProtos.Rpc.IVersionedKey, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VersionedKey;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VersionedKey;
            public static toObject(message: POGOProtos.Rpc.VersionedKey, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVersionedKeyValuePair {
            key?: (POGOProtos.Rpc.IKey|null);
            value?: (POGOProtos.Rpc.IVersionedValue|null);
        }

        class VersionedKeyValuePair implements IVersionedKeyValuePair {
            constructor(properties?: POGOProtos.Rpc.IVersionedKeyValuePair);
            public key?: (POGOProtos.Rpc.IKey|null);
            public value?: (POGOProtos.Rpc.IVersionedValue|null);
            public static encode(message: POGOProtos.Rpc.IVersionedKeyValuePair, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VersionedKeyValuePair;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VersionedKeyValuePair;
            public static toObject(message: POGOProtos.Rpc.VersionedKeyValuePair, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVersionedValue {
            version?: (number|null);
            data?: (Uint8Array|null);
        }

        class VersionedValue implements IVersionedValue {
            constructor(properties?: POGOProtos.Rpc.IVersionedValue);
            public version: number;
            public data: Uint8Array;
            public static encode(message: POGOProtos.Rpc.IVersionedValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VersionedValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VersionedValue;
            public static toObject(message: POGOProtos.Rpc.VersionedValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IViewPointOfInterestImageTelemetry {
            result?: (string|null);
            fort_id?: (string|null);
            fort_type?: (number|null);
            in_range?: (boolean|null);
            was_gym_interior?: (boolean|null);
            partner_id?: (string|null);
            campaign_id?: (string|null);
        }

        class ViewPointOfInterestImageTelemetry implements IViewPointOfInterestImageTelemetry {
            constructor(properties?: POGOProtos.Rpc.IViewPointOfInterestImageTelemetry);
            public result: string;
            public fort_id: string;
            public fort_type: number;
            public in_range: boolean;
            public was_gym_interior: boolean;
            public partner_id: string;
            public campaign_id: string;
            public static encode(message: POGOProtos.Rpc.IViewPointOfInterestImageTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ViewPointOfInterestImageTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ViewPointOfInterestImageTelemetry;
            public static toObject(message: POGOProtos.Rpc.ViewPointOfInterestImageTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IViewRoutePinOutProto {
            result?: (POGOProtos.Rpc.ViewRoutePinOutProto.Result|null);
            pin?: (POGOProtos.Rpc.IRoutePin|null);
        }

        class ViewRoutePinOutProto implements IViewRoutePinOutProto {
            constructor(properties?: POGOProtos.Rpc.IViewRoutePinOutProto);
            public result: POGOProtos.Rpc.ViewRoutePinOutProto.Result;
            public pin?: (POGOProtos.Rpc.IRoutePin|null);
            public static encode(message: POGOProtos.Rpc.IViewRoutePinOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ViewRoutePinOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ViewRoutePinOutProto;
            public static toObject(message: POGOProtos.Rpc.ViewRoutePinOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace ViewRoutePinOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                ERROR_UNKNOWN = 2,
                ERROR_ROUTE_NOT_FOUND = 3,
                ERROR_PIN_NOT_FOUND = 4
            }
        }

        interface IViewRoutePinProto {
            route_id?: (string|null);
            pin_id?: (string|null);
        }

        class ViewRoutePinProto implements IViewRoutePinProto {
            constructor(properties?: POGOProtos.Rpc.IViewRoutePinProto);
            public route_id: string;
            public pin_id: string;
            public static encode(message: POGOProtos.Rpc.IViewRoutePinProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.ViewRoutePinProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.ViewRoutePinProto;
            public static toObject(message: POGOProtos.Rpc.ViewRoutePinProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVistaGeneralSettingsProto {
            is_feature_enabled?: (boolean|null);
            is_vista_battle_enabled?: (boolean|null);
            is_vista_encounters_enabled?: (boolean|null);
            is_vista_map_enabled?: (boolean|null);
            is_vista_spawns_enabled?: (boolean|null);
            base_environment_pokedex_id_range?: (POGOProtos.Rpc.VistaGeneralSettingsProto.IPokedexIdRange[]|null);
            base_environment_pokedex_id?: (number[]|null);
            theme_override?: (string|null);
            environment_season?: (POGOProtos.Rpc.VistaGeneralSettingsProto.SeasonType|null);
        }

        class VistaGeneralSettingsProto implements IVistaGeneralSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IVistaGeneralSettingsProto);
            public is_feature_enabled: boolean;
            public is_vista_battle_enabled: boolean;
            public is_vista_encounters_enabled: boolean;
            public is_vista_map_enabled: boolean;
            public is_vista_spawns_enabled: boolean;
            public base_environment_pokedex_id_range: POGOProtos.Rpc.VistaGeneralSettingsProto.IPokedexIdRange[];
            public base_environment_pokedex_id: number[];
            public theme_override: string;
            public environment_season: POGOProtos.Rpc.VistaGeneralSettingsProto.SeasonType;
            public static encode(message: POGOProtos.Rpc.IVistaGeneralSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VistaGeneralSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VistaGeneralSettingsProto;
            public static toObject(message: POGOProtos.Rpc.VistaGeneralSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VistaGeneralSettingsProto {

            interface IPokedexIdRange {
                min_inclusive?: (number|null);
                max_inclusive?: (number|null);
            }

            class PokedexIdRange implements IPokedexIdRange {
                constructor(properties?: POGOProtos.Rpc.VistaGeneralSettingsProto.IPokedexIdRange);
                public min_inclusive: number;
                public max_inclusive: number;
                public static encode(message: POGOProtos.Rpc.VistaGeneralSettingsProto.IPokedexIdRange, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VistaGeneralSettingsProto.PokedexIdRange;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VistaGeneralSettingsProto.PokedexIdRange;
                public static toObject(message: POGOProtos.Rpc.VistaGeneralSettingsProto.PokedexIdRange, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum SeasonType {
                SEASON_UNSET = 0,
                SEASON_WINTER = 1,
                SEASON_SPRING = 2,
                SEASON_SUMMER = 3,
                SEASON_FALL = 4
            }
        }

        interface IVpsAnchor {
            id?: (string|null);
            payload?: (Uint8Array|null);
            payload_string?: (string|null);
            hint_image_url?: (string|null);
        }

        class VpsAnchor implements IVpsAnchor {
            constructor(properties?: POGOProtos.Rpc.IVpsAnchor);
            public id: string;
            public payload: Uint8Array;
            public payload_string: string;
            public hint_image_url: string;
            public static encode(message: POGOProtos.Rpc.IVpsAnchor, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsAnchor;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsAnchor;
            public static toObject(message: POGOProtos.Rpc.VpsAnchor, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVpsEventMapDisplayProto {
            event_type?: (POGOProtos.Rpc.VpsEventType|null);
            event_id?: (number|null);
        }

        class VpsEventMapDisplayProto implements IVpsEventMapDisplayProto {
            constructor(properties?: POGOProtos.Rpc.IVpsEventMapDisplayProto);
            public event_type: POGOProtos.Rpc.VpsEventType;
            public event_id: number;
            public static encode(message: POGOProtos.Rpc.IVpsEventMapDisplayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsEventMapDisplayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsEventMapDisplayProto;
            public static toObject(message: POGOProtos.Rpc.VpsEventMapDisplayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVpsEventSettingsProto {
            fort_vps_events?: (POGOProtos.Rpc.VpsEventSettingsProto.IFortVpsEvent[]|null);
        }

        class VpsEventSettingsProto implements IVpsEventSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IVpsEventSettingsProto);
            public fort_vps_events: POGOProtos.Rpc.VpsEventSettingsProto.IFortVpsEvent[];
            public static encode(message: POGOProtos.Rpc.IVpsEventSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsEventSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsEventSettingsProto;
            public static toObject(message: POGOProtos.Rpc.VpsEventSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VpsEventSettingsProto {

            interface IFortVpsEvent {
                fort_id?: (string|null);
                start_time_ms?: (number|Long|null);
                end_time_ms?: (number|Long|null);
                vps_event?: (POGOProtos.Rpc.IVpsEventMapDisplayProto|null);
            }

            class FortVpsEvent implements IFortVpsEvent {
                constructor(properties?: POGOProtos.Rpc.VpsEventSettingsProto.IFortVpsEvent);
                public fort_id: string;
                public start_time_ms: (number|Long);
                public end_time_ms: (number|Long);
                public vps_event?: (POGOProtos.Rpc.IVpsEventMapDisplayProto|null);
                public static encode(message: POGOProtos.Rpc.VpsEventSettingsProto.IFortVpsEvent, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsEventSettingsProto.FortVpsEvent;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsEventSettingsProto.FortVpsEvent;
                public static toObject(message: POGOProtos.Rpc.VpsEventSettingsProto.FortVpsEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IVpsEventWrapperProto {
            event_type?: (POGOProtos.Rpc.VpsEventType|null);
            event_id?: (number|null);
            event_duration?: (POGOProtos.Rpc.VpsEventWrapperProto.IEventDurationProto|null);
            anchors?: (POGOProtos.Rpc.IVpsAnchor[]|null);
            placed_pokemon?: (POGOProtos.Rpc.IIrisPokemonObjectProto[]|null);
        }

        class VpsEventWrapperProto implements IVpsEventWrapperProto {
            constructor(properties?: POGOProtos.Rpc.IVpsEventWrapperProto);
            public event_type: POGOProtos.Rpc.VpsEventType;
            public event_id: number;
            public event_duration?: (POGOProtos.Rpc.VpsEventWrapperProto.IEventDurationProto|null);
            public anchors: POGOProtos.Rpc.IVpsAnchor[];
            public placed_pokemon: POGOProtos.Rpc.IIrisPokemonObjectProto[];
            public static encode(message: POGOProtos.Rpc.IVpsEventWrapperProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsEventWrapperProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsEventWrapperProto;
            public static toObject(message: POGOProtos.Rpc.VpsEventWrapperProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VpsEventWrapperProto {

            interface IEventDurationProto {
                permanent?: (boolean|null);
                start_ms?: (number|Long|null);
                end_ms?: (number|Long|null);
            }

            class EventDurationProto implements IEventDurationProto {
                constructor(properties?: POGOProtos.Rpc.VpsEventWrapperProto.IEventDurationProto);
                public permanent: boolean;
                public start_ms: (number|Long);
                public end_ms: (number|Long);
                public static encode(message: POGOProtos.Rpc.VpsEventWrapperProto.IEventDurationProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsEventWrapperProto.EventDurationProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsEventWrapperProto.EventDurationProto;
                public static toObject(message: POGOProtos.Rpc.VpsEventWrapperProto.EventDurationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IVpsLocalizationStartedEvent {
            localization_target_ids?: (string[]|null);
            vps_session_id?: (string|null);
        }

        class VpsLocalizationStartedEvent implements IVpsLocalizationStartedEvent {
            constructor(properties?: POGOProtos.Rpc.IVpsLocalizationStartedEvent);
            public localization_target_ids: string[];
            public vps_session_id: string;
            public static encode(message: POGOProtos.Rpc.IVpsLocalizationStartedEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsLocalizationStartedEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsLocalizationStartedEvent;
            public static toObject(message: POGOProtos.Rpc.VpsLocalizationStartedEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVpsLocalizationSuccessEvent {
            localization_target_id?: (string|null);
            vps_session_id?: (string|null);
            time_to_localize_ms?: (number|Long|null);
            num_server_requests?: (number|null);
        }

        class VpsLocalizationSuccessEvent implements IVpsLocalizationSuccessEvent {
            constructor(properties?: POGOProtos.Rpc.IVpsLocalizationSuccessEvent);
            public localization_target_id: string;
            public vps_session_id: string;
            public time_to_localize_ms: (number|Long);
            public num_server_requests: number;
            public static encode(message: POGOProtos.Rpc.IVpsLocalizationSuccessEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsLocalizationSuccessEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsLocalizationSuccessEvent;
            public static toObject(message: POGOProtos.Rpc.VpsLocalizationSuccessEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVpsSessionEndedEvent {
            vps_session_id?: (string|null);
            num_server_requests?: (number|null);
            time_tracked_ms?: (number|Long|null);
            total_session_time_ms?: (number|Long|null);
            network_error_codes?: ({ [k: string]: number }|null);
        }

        class VpsSessionEndedEvent implements IVpsSessionEndedEvent {
            constructor(properties?: POGOProtos.Rpc.IVpsSessionEndedEvent);
            public vps_session_id: string;
            public num_server_requests: number;
            public time_tracked_ms: (number|Long);
            public total_session_time_ms: (number|Long);
            public network_error_codes: { [k: string]: number };
            public static encode(message: POGOProtos.Rpc.IVpsSessionEndedEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VpsSessionEndedEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VpsSessionEndedEvent;
            public static toObject(message: POGOProtos.Rpc.VpsSessionEndedEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsActionHistory {
            invoke_time_ms?: (number|Long|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            move_modifier?: (POGOProtos.Rpc.IMoveModifierProto|null);
            item?: (POGOProtos.Rpc.Item|null);
            move?: (POGOProtos.Rpc.HoloPokemonMove|null);
        }

        class VsActionHistory implements IVsActionHistory {
            constructor(properties?: POGOProtos.Rpc.IVsActionHistory);
            public invoke_time_ms: (number|Long);
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public move_modifier?: (POGOProtos.Rpc.IMoveModifierProto|null);
            public item: POGOProtos.Rpc.Item;
            public move: POGOProtos.Rpc.HoloPokemonMove;
            public static encode(message: POGOProtos.Rpc.IVsActionHistory, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsActionHistory;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsActionHistory;
            public static toObject(message: POGOProtos.Rpc.VsActionHistory, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerAttributesProto {
            vs_seeker_status?: (POGOProtos.Rpc.VsSeekerAttributesProto.VsSeekerStatus|null);
            start_km_walked?: (number|null);
            target_km_walked?: (number|null);
            battle_granted_remaining?: (number|null);
            max_battles_in_set?: (number|null);
            reward_track?: (POGOProtos.Rpc.VsSeekerRewardTrack|null);
            battle_now_sku_id?: (string|null);
            additional_battles_granted?: (boolean|null);
        }

        class VsSeekerAttributesProto implements IVsSeekerAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerAttributesProto);
            public vs_seeker_status: POGOProtos.Rpc.VsSeekerAttributesProto.VsSeekerStatus;
            public start_km_walked: number;
            public target_km_walked: number;
            public battle_granted_remaining: number;
            public max_battles_in_set: number;
            public reward_track: POGOProtos.Rpc.VsSeekerRewardTrack;
            public battle_now_sku_id: string;
            public additional_battles_granted: boolean;
            public static encode(message: POGOProtos.Rpc.IVsSeekerAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerAttributesProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerAttributesProto {

            enum VsSeekerStatus {
                UNSET = 0,
                STARTED_CHARGING = 1,
                FULLY_CHARGED = 2,
                ACTIVATED = 3
            }
        }

        interface IVsSeekerBattleResult {
            battle_result?: (POGOProtos.Rpc.CombatPlayerFinishState|null);
            rewards_claimed?: (boolean|null);
            is_pending_pokemon_reward?: (boolean|null);
        }

        class VsSeekerBattleResult implements IVsSeekerBattleResult {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerBattleResult);
            public battle_result: POGOProtos.Rpc.CombatPlayerFinishState;
            public rewards_claimed: boolean;
            public is_pending_pokemon_reward: boolean;
            public static encode(message: POGOProtos.Rpc.IVsSeekerBattleResult, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerBattleResult;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerBattleResult;
            public static toObject(message: POGOProtos.Rpc.VsSeekerBattleResult, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerClientSettingsProto {
            upgrade_iap_sku_id?: (string|null);
            allowed_vs_seeker_league_template_id?: (string[]|null);
        }

        class VsSeekerClientSettingsProto implements IVsSeekerClientSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerClientSettingsProto);
            public upgrade_iap_sku_id: string;
            public allowed_vs_seeker_league_template_id: string[];
            public static encode(message: POGOProtos.Rpc.IVsSeekerClientSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerClientSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerClientSettingsProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerClientSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerCompleteSeasonLogEntry {
            result?: (POGOProtos.Rpc.VsSeekerCompleteSeasonLogEntry.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            rank?: (number|null);
            rating?: (number|null);
        }

        class VsSeekerCompleteSeasonLogEntry implements IVsSeekerCompleteSeasonLogEntry {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerCompleteSeasonLogEntry);
            public result: POGOProtos.Rpc.VsSeekerCompleteSeasonLogEntry.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public rank: number;
            public rating: number;
            public static encode(message: POGOProtos.Rpc.IVsSeekerCompleteSeasonLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerCompleteSeasonLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerCompleteSeasonLogEntry;
            public static toObject(message: POGOProtos.Rpc.VsSeekerCompleteSeasonLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerCompleteSeasonLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IVsSeekerCreateDetail {
            season?: (number|null);
            league?: (string|null);
        }

        class VsSeekerCreateDetail implements IVsSeekerCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerCreateDetail);
            public season: number;
            public league: string;
            public static encode(message: POGOProtos.Rpc.IVsSeekerCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerCreateDetail;
            public static toObject(message: POGOProtos.Rpc.VsSeekerCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerLootProto {
            rank_level?: (number|null);
            reward?: (POGOProtos.Rpc.VsSeekerLootProto.IRewardProto[]|null);
            reward_track?: (POGOProtos.Rpc.VsSeekerRewardTrack|null);
        }

        class VsSeekerLootProto implements IVsSeekerLootProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerLootProto);
            public rank_level: number;
            public reward: POGOProtos.Rpc.VsSeekerLootProto.IRewardProto[];
            public reward_track: POGOProtos.Rpc.VsSeekerRewardTrack;
            public static encode(message: POGOProtos.Rpc.IVsSeekerLootProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerLootProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerLootProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerLootProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerLootProto {

            interface IRewardProto {
                item?: (POGOProtos.Rpc.ILootItemProto|null);
                pokemon_reward?: (boolean|null);
                item_loot_table?: (boolean|null);
                item_loot_table_count?: (number|null);
                item_ranking_loot_table_count?: (number|null);
            }

            class RewardProto implements IRewardProto {
                constructor(properties?: POGOProtos.Rpc.VsSeekerLootProto.IRewardProto);
                public item?: (POGOProtos.Rpc.ILootItemProto|null);
                public pokemon_reward?: (boolean|null);
                public item_loot_table?: (boolean|null);
                public item_loot_table_count?: (number|null);
                public item_ranking_loot_table_count?: (number|null);
                public RewardType?: ("item"|"pokemon_reward"|"item_loot_table"|"item_loot_table_count"|"item_ranking_loot_table_count");
                public static encode(message: POGOProtos.Rpc.VsSeekerLootProto.IRewardProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerLootProto.RewardProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerLootProto.RewardProto;
                public static toObject(message: POGOProtos.Rpc.VsSeekerLootProto.RewardProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IVsSeekerPokemonRewardsProto {
            available_pokemon?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IPokemonUnlockProto[]|null);
            reward_track?: (POGOProtos.Rpc.VsSeekerRewardTrack|null);
        }

        class VsSeekerPokemonRewardsProto implements IVsSeekerPokemonRewardsProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerPokemonRewardsProto);
            public available_pokemon: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IPokemonUnlockProto[];
            public reward_track: POGOProtos.Rpc.VsSeekerRewardTrack;
            public static encode(message: POGOProtos.Rpc.IVsSeekerPokemonRewardsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerPokemonRewardsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerPokemonRewardsProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerPokemonRewardsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerPokemonRewardsProto {

            interface IOverrideIvRangeProto {
                range?: (POGOProtos.Rpc.IRangeProto|null);
                zero?: (boolean|null);
            }

            class OverrideIvRangeProto implements IOverrideIvRangeProto {
                constructor(properties?: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto);
                public range?: (POGOProtos.Rpc.IRangeProto|null);
                public zero?: (boolean|null);
                public OverrideType?: ("range"|"zero");
                public static encode(message: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerPokemonRewardsProto.OverrideIvRangeProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerPokemonRewardsProto.OverrideIvRangeProto;
                public static toObject(message: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.OverrideIvRangeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonUnlockProto {
                pokemon?: (POGOProtos.Rpc.IPokemonEncounterRewardProto|null);
                limited_pokemon_reward?: (POGOProtos.Rpc.ILimitedEditionPokemonEncounterRewardProto|null);
                guaranteed_limited_pokemon_reward?: (POGOProtos.Rpc.ILimitedEditionPokemonEncounterRewardProto|null);
                unlocked_at_rank?: (number|null);
                weight?: (number|null);
                attack_iv_override?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto|null);
                defense_iv_override?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto|null);
                stamina_iv_override?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto|null);
            }

            class PokemonUnlockProto implements IPokemonUnlockProto {
                constructor(properties?: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IPokemonUnlockProto);
                public pokemon?: (POGOProtos.Rpc.IPokemonEncounterRewardProto|null);
                public limited_pokemon_reward?: (POGOProtos.Rpc.ILimitedEditionPokemonEncounterRewardProto|null);
                public guaranteed_limited_pokemon_reward?: (POGOProtos.Rpc.ILimitedEditionPokemonEncounterRewardProto|null);
                public unlocked_at_rank: number;
                public weight: number;
                public attack_iv_override?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto|null);
                public defense_iv_override?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto|null);
                public stamina_iv_override?: (POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IOverrideIvRangeProto|null);
                public RewardType?: ("pokemon"|"limited_pokemon_reward"|"guaranteed_limited_pokemon_reward");
                public static encode(message: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.IPokemonUnlockProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerPokemonRewardsProto.PokemonUnlockProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerPokemonRewardsProto.PokemonUnlockProto;
                public static toObject(message: POGOProtos.Rpc.VsSeekerPokemonRewardsProto.PokemonUnlockProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IVsSeekerRewardEncounterOutProto {
            result?: (POGOProtos.Rpc.VsSeekerRewardEncounterOutProto.Result|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            active_item?: (POGOProtos.Rpc.Item|null);
            encounter_id?: (number|Long|null);
        }

        class VsSeekerRewardEncounterOutProto implements IVsSeekerRewardEncounterOutProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerRewardEncounterOutProto);
            public result: POGOProtos.Rpc.VsSeekerRewardEncounterOutProto.Result;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public capture_probability?: (POGOProtos.Rpc.ICaptureProbabilityProto|null);
            public active_item: POGOProtos.Rpc.Item;
            public encounter_id: (number|Long);
            public static encode(message: POGOProtos.Rpc.IVsSeekerRewardEncounterOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerRewardEncounterOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerRewardEncounterOutProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerRewardEncounterOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerRewardEncounterOutProto {

            enum Result {
                VS_SEEKER_ENCOUNTER_UNKNOWN = 0,
                VS_SEEKER_ENCOUNTER_SUCCESS = 1,
                VS_SEEKER_ENCOUNTER_ALREADY_FINISHED = 2,
                ERROR_PLAYER_NOT_ENOUGH_VICTORIES = 3,
                ERROR_POKEMON_INVENTORY_FULL = 4,
                ERROR_REDEEM_ITEM = 5
            }
        }

        interface IVsSeekerRewardEncounterProto {
            win_index?: (number|null);
        }

        class VsSeekerRewardEncounterProto implements IVsSeekerRewardEncounterProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerRewardEncounterProto);
            public win_index: number;
            public static encode(message: POGOProtos.Rpc.IVsSeekerRewardEncounterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerRewardEncounterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerRewardEncounterProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerRewardEncounterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerScheduleProto {
            start_time_ms?: (number|Long|null);
            end_time_ms?: (number|Long|null);
            vs_seeker_league_template_id?: (string[]|null);
            special_conditions?: (POGOProtos.Rpc.IVsSeekerSpecialCondition[]|null);
        }

        class VsSeekerScheduleProto implements IVsSeekerScheduleProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerScheduleProto);
            public start_time_ms: (number|Long);
            public end_time_ms: (number|Long);
            public vs_seeker_league_template_id: string[];
            public special_conditions: POGOProtos.Rpc.IVsSeekerSpecialCondition[];
            public static encode(message: POGOProtos.Rpc.IVsSeekerScheduleProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerScheduleProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerScheduleProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerScheduleProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerScheduleSettingsProto {
            enabled_combat_hub_main?: (boolean|null);
            enabled_combat_league_view?: (boolean|null);
            enabled_today_view?: (boolean|null);
            season_schedules?: (POGOProtos.Rpc.IVsSeekerSeasonSchedule[]|null);
        }

        class VsSeekerScheduleSettingsProto implements IVsSeekerScheduleSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerScheduleSettingsProto);
            public enabled_combat_hub_main: boolean;
            public enabled_combat_league_view: boolean;
            public enabled_today_view: boolean;
            public season_schedules: POGOProtos.Rpc.IVsSeekerSeasonSchedule[];
            public static encode(message: POGOProtos.Rpc.IVsSeekerScheduleSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerScheduleSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerScheduleSettingsProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerScheduleSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerSeasonSchedule {
            season_title?: (string|null);
            description_key?: (string|null);
            vs_seeker_schedules?: (POGOProtos.Rpc.IVsSeekerScheduleProto[]|null);
            blog_url?: (string|null);
        }

        class VsSeekerSeasonSchedule implements IVsSeekerSeasonSchedule {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerSeasonSchedule);
            public season_title: string;
            public description_key: string;
            public vs_seeker_schedules: POGOProtos.Rpc.IVsSeekerScheduleProto[];
            public blog_url: string;
            public static encode(message: POGOProtos.Rpc.IVsSeekerSeasonSchedule, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerSeasonSchedule;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerSeasonSchedule;
            public static toObject(message: POGOProtos.Rpc.VsSeekerSeasonSchedule, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerSetLogEntry {
            result?: (POGOProtos.Rpc.VsSeekerSetLogEntry.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            new_rank?: (number|null);
            new_rating?: (number|null);
            previous_rank?: (number|null);
            previous_rating?: (number|null);
            number_of_wins?: (number|null);
            number_of_battles?: (number|null);
        }

        class VsSeekerSetLogEntry implements IVsSeekerSetLogEntry {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerSetLogEntry);
            public result: POGOProtos.Rpc.VsSeekerSetLogEntry.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public new_rank: number;
            public new_rating: number;
            public previous_rank: number;
            public previous_rating: number;
            public number_of_wins: number;
            public number_of_battles: number;
            public static encode(message: POGOProtos.Rpc.IVsSeekerSetLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerSetLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerSetLogEntry;
            public static toObject(message: POGOProtos.Rpc.VsSeekerSetLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerSetLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IVsSeekerSpecialCondition {
            special_condition_key?: (string|null);
            special_condition_start_time_ms?: (number|Long|null);
            special_condition_end_time_ms?: (number|Long|null);
        }

        class VsSeekerSpecialCondition implements IVsSeekerSpecialCondition {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerSpecialCondition);
            public special_condition_key: string;
            public special_condition_start_time_ms: (number|Long);
            public special_condition_end_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IVsSeekerSpecialCondition, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerSpecialCondition;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerSpecialCondition;
            public static toObject(message: POGOProtos.Rpc.VsSeekerSpecialCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerStartMatchmakingData {
            rpc_id?: (number|null);
            attacking_pokemon_indexes?: (number[]|null);
        }

        class VsSeekerStartMatchmakingData implements IVsSeekerStartMatchmakingData {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerStartMatchmakingData);
            public rpc_id: number;
            public attacking_pokemon_indexes: number[];
            public static encode(message: POGOProtos.Rpc.IVsSeekerStartMatchmakingData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerStartMatchmakingData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerStartMatchmakingData;
            public static toObject(message: POGOProtos.Rpc.VsSeekerStartMatchmakingData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerStartMatchmakingOutProto {
            result?: (POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            queue_id?: (string|null);
        }

        class VsSeekerStartMatchmakingOutProto implements IVsSeekerStartMatchmakingOutProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerStartMatchmakingOutProto);
            public result: POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeProto|null);
            public queue_id: string;
            public static encode(message: POGOProtos.Rpc.IVsSeekerStartMatchmakingOutProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerStartMatchmakingOutProto {

            enum Result {
                UNSET = 0,
                SUCCESS_OPPONENT_FOUND = 1,
                SUCCESS_QUEUED = 2,
                ERROR_NO_BATTLE_PASSES_LEFT = 3,
                ERROR_ALREADY_IN_QUEUE = 4,
                ERROR_VS_SEEKER_PLAYER_IN_WRONG_SEASON = 5,
                ERROR_PLAYER_HAS_NO_VS_SEEKER = 6,
                ERROR_ACCESS_DENIED = 7,
                ERROR_POKEMON_LINEUP_INELIGIBLE_FOR_LEAGUE = 8,
                ERROR_VS_SEEKER_NOT_ACTIVATED = 9,
                ERROR_TEMPORARILY_UNAVAILABLE = 10,
                ERROR_EXCEEDED_LIMIT = 11,
                ERROR_QUEUE_TOO_FULL = 12
            }
        }

        interface IVsSeekerStartMatchmakingProto {
            combat_league_template_id?: (string|null);
            attacking_pokemon_id?: ((number|Long)[]|null);
        }

        class VsSeekerStartMatchmakingProto implements IVsSeekerStartMatchmakingProto {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerStartMatchmakingProto);
            public combat_league_template_id: string;
            public attacking_pokemon_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IVsSeekerStartMatchmakingProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerStartMatchmakingProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerStartMatchmakingProto;
            public static toObject(message: POGOProtos.Rpc.VsSeekerStartMatchmakingProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerStartMatchmakingResponseData {
            rpc_id?: (number|null);
            round_trip_time_ms?: (number|null);
            result?: (POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto.Result|null);
            challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
        }

        class VsSeekerStartMatchmakingResponseData implements IVsSeekerStartMatchmakingResponseData {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerStartMatchmakingResponseData);
            public rpc_id: number;
            public round_trip_time_ms: number;
            public result: POGOProtos.Rpc.VsSeekerStartMatchmakingOutProto.Result;
            public challenge?: (POGOProtos.Rpc.ICombatChallengeLogProto|null);
            public static encode(message: POGOProtos.Rpc.IVsSeekerStartMatchmakingResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerStartMatchmakingResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerStartMatchmakingResponseData;
            public static toObject(message: POGOProtos.Rpc.VsSeekerStartMatchmakingResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IVsSeekerWinRewardsLogEntry {
            result?: (POGOProtos.Rpc.VsSeekerWinRewardsLogEntry.Result|null);
            rewards?: (POGOProtos.Rpc.ILootProto|null);
            rank?: (number|null);
            win_number?: (number|null);
        }

        class VsSeekerWinRewardsLogEntry implements IVsSeekerWinRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IVsSeekerWinRewardsLogEntry);
            public result: POGOProtos.Rpc.VsSeekerWinRewardsLogEntry.Result;
            public rewards?: (POGOProtos.Rpc.ILootProto|null);
            public rank: number;
            public win_number: number;
            public static encode(message: POGOProtos.Rpc.IVsSeekerWinRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.VsSeekerWinRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.VsSeekerWinRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.VsSeekerWinRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace VsSeekerWinRewardsLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1
            }
        }

        interface IWainaGetRewardsRequest {
            sleep_day?: (number|null);
        }

        class WainaGetRewardsRequest implements IWainaGetRewardsRequest {
            constructor(properties?: POGOProtos.Rpc.IWainaGetRewardsRequest);
            public sleep_day: number;
            public static encode(message: POGOProtos.Rpc.IWainaGetRewardsRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WainaGetRewardsRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WainaGetRewardsRequest;
            public static toObject(message: POGOProtos.Rpc.WainaGetRewardsRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWainaGetRewardsResponse {
            status?: (POGOProtos.Rpc.WainaGetRewardsResponse.Status|null);
            loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            reward_tier_sec?: (number|null);
            buddy_bonus_heart?: (number|null);
            buddy?: (POGOProtos.Rpc.IPokemonProto|null);
        }

        class WainaGetRewardsResponse implements IWainaGetRewardsResponse {
            constructor(properties?: POGOProtos.Rpc.IWainaGetRewardsResponse);
            public status: POGOProtos.Rpc.WainaGetRewardsResponse.Status;
            public loot_proto?: (POGOProtos.Rpc.ILootProto|null);
            public reward_tier_sec: number;
            public buddy_bonus_heart: number;
            public buddy?: (POGOProtos.Rpc.IPokemonProto|null);
            public static encode(message: POGOProtos.Rpc.IWainaGetRewardsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WainaGetRewardsResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WainaGetRewardsResponse;
            public static toObject(message: POGOProtos.Rpc.WainaGetRewardsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WainaGetRewardsResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2,
                ERROR_ALREADY_REWARDED = 3,
                ERROR_SLEEP_RECORDS_NOT_AFTER_TIMESTAMP = 4,
                ERROR_MISSING_SLEEP_RECORD = 5,
                ERROR_NOTIFICATION = 6
            }
        }

        interface IWainaPreferences {
            ball?: (POGOProtos.Rpc.Item|null);
            autocatch?: (boolean|null);
            autospin?: (boolean|null);
            notify_spin?: (boolean|null);
            notify_catch?: (boolean|null);
            notify_push?: (boolean|null);
            always_advertise?: (boolean|null);
            sleep_tracking?: (boolean|null);
            sleep_reward_time_sec?: (number|null);
            voice_effect?: (boolean|null);
        }

        class WainaPreferences implements IWainaPreferences {
            constructor(properties?: POGOProtos.Rpc.IWainaPreferences);
            public ball: POGOProtos.Rpc.Item;
            public autocatch: boolean;
            public autospin: boolean;
            public notify_spin: boolean;
            public notify_catch: boolean;
            public notify_push: boolean;
            public always_advertise: boolean;
            public sleep_tracking: boolean;
            public sleep_reward_time_sec: number;
            public voice_effect: boolean;
            public static encode(message: POGOProtos.Rpc.IWainaPreferences, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WainaPreferences;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WainaPreferences;
            public static toObject(message: POGOProtos.Rpc.WainaPreferences, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWainaSubmitSleepDataRequest {
            sleep_record?: (POGOProtos.Rpc.IClientSleepRecord[]|null);
        }

        class WainaSubmitSleepDataRequest implements IWainaSubmitSleepDataRequest {
            constructor(properties?: POGOProtos.Rpc.IWainaSubmitSleepDataRequest);
            public sleep_record: POGOProtos.Rpc.IClientSleepRecord[];
            public static encode(message: POGOProtos.Rpc.IWainaSubmitSleepDataRequest, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WainaSubmitSleepDataRequest;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WainaSubmitSleepDataRequest;
            public static toObject(message: POGOProtos.Rpc.WainaSubmitSleepDataRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWainaSubmitSleepDataResponse {
            status?: (POGOProtos.Rpc.WainaSubmitSleepDataResponse.Status|null);
        }

        class WainaSubmitSleepDataResponse implements IWainaSubmitSleepDataResponse {
            constructor(properties?: POGOProtos.Rpc.IWainaSubmitSleepDataResponse);
            public status: POGOProtos.Rpc.WainaSubmitSleepDataResponse.Status;
            public static encode(message: POGOProtos.Rpc.IWainaSubmitSleepDataResponse, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WainaSubmitSleepDataResponse;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WainaSubmitSleepDataResponse;
            public static toObject(message: POGOProtos.Rpc.WainaSubmitSleepDataResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WainaSubmitSleepDataResponse {

            enum Status {
                UNSET = 0,
                SUCCESS = 1,
                ERROR = 2
            }
        }

        interface IWallabySettingsProto {
            enable?: (boolean|null);
            activity_length_s?: (number|null);
            test_mask?: (number|null);
        }

        class WallabySettingsProto implements IWallabySettingsProto {
            constructor(properties?: POGOProtos.Rpc.IWallabySettingsProto);
            public enable: boolean;
            public activity_length_s: number;
            public test_mask: number;
            public static encode(message: POGOProtos.Rpc.IWallabySettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WallabySettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WallabySettingsProto;
            public static toObject(message: POGOProtos.Rpc.WallabySettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWayfarerOnboardingFlowTelemetry {
            event_type?: (POGOProtos.Rpc.WayfarerOnboardingFlowTelemetry.EventType|null);
        }

        class WayfarerOnboardingFlowTelemetry implements IWayfarerOnboardingFlowTelemetry {
            constructor(properties?: POGOProtos.Rpc.IWayfarerOnboardingFlowTelemetry);
            public event_type: POGOProtos.Rpc.WayfarerOnboardingFlowTelemetry.EventType;
            public static encode(message: POGOProtos.Rpc.IWayfarerOnboardingFlowTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WayfarerOnboardingFlowTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WayfarerOnboardingFlowTelemetry;
            public static toObject(message: POGOProtos.Rpc.WayfarerOnboardingFlowTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WayfarerOnboardingFlowTelemetry {

            enum EventType {
                UNSET = 0,
                ENTER_WAYFARER_WEBSITE = 1,
                DEFER_WAYFARER_ONBOARDING = 2,
                SIMPLIFIED_ONBOARDING_OK = 3
            }
        }

        interface IWayspotEditTelemetry {
            wayspot_edit_telemetry_id?: (POGOProtos.Rpc.WayspotEditTelemetry.WayspotEditEventId|null);
        }

        class WayspotEditTelemetry implements IWayspotEditTelemetry {
            constructor(properties?: POGOProtos.Rpc.IWayspotEditTelemetry);
            public wayspot_edit_telemetry_id: POGOProtos.Rpc.WayspotEditTelemetry.WayspotEditEventId;
            public static encode(message: POGOProtos.Rpc.IWayspotEditTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WayspotEditTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WayspotEditTelemetry;
            public static toObject(message: POGOProtos.Rpc.WayspotEditTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WayspotEditTelemetry {

            enum WayspotEditEventId {
                UNKNOWN = 0,
                EDIT_IMAGE_UPLOAD_NOW = 1,
                EDIT_IMAGE_UPLOAD_LATER = 2
            }
        }

        interface IWeatherAffinityProto {
            weather_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
            pokemon_type?: (POGOProtos.Rpc.HoloPokemonType[]|null);
            weakness_pokemon_type?: (POGOProtos.Rpc.HoloPokemonType[]|null);
        }

        class WeatherAffinityProto implements IWeatherAffinityProto {
            constructor(properties?: POGOProtos.Rpc.IWeatherAffinityProto);
            public weather_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
            public pokemon_type: POGOProtos.Rpc.HoloPokemonType[];
            public weakness_pokemon_type: POGOProtos.Rpc.HoloPokemonType[];
            public static encode(message: POGOProtos.Rpc.IWeatherAffinityProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAffinityProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAffinityProto;
            public static toObject(message: POGOProtos.Rpc.WeatherAffinityProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWeatherAlertProto {
            severity?: (POGOProtos.Rpc.WeatherAlertProto.Severity|null);
            warn_weather?: (boolean|null);
        }

        class WeatherAlertProto implements IWeatherAlertProto {
            constructor(properties?: POGOProtos.Rpc.IWeatherAlertProto);
            public severity: POGOProtos.Rpc.WeatherAlertProto.Severity;
            public warn_weather: boolean;
            public static encode(message: POGOProtos.Rpc.IWeatherAlertProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAlertProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAlertProto;
            public static toObject(message: POGOProtos.Rpc.WeatherAlertProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WeatherAlertProto {

            enum Severity {
                NONE = 0,
                MODERATE = 1,
                EXTREME = 2
            }
        }

        interface IWeatherAlertSettingsProto {
            warn_weather?: (boolean|null);
            default_severity?: (POGOProtos.Rpc.WeatherAlertProto.Severity|null);
            ignores?: (POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertIgnoreSettings[]|null);
            enforces?: (POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertEnforceSettings[]|null);
        }

        class WeatherAlertSettingsProto implements IWeatherAlertSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IWeatherAlertSettingsProto);
            public warn_weather: boolean;
            public default_severity: POGOProtos.Rpc.WeatherAlertProto.Severity;
            public ignores: POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertIgnoreSettings[];
            public enforces: POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertEnforceSettings[];
            public static encode(message: POGOProtos.Rpc.IWeatherAlertSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAlertSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAlertSettingsProto;
            public static toObject(message: POGOProtos.Rpc.WeatherAlertSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WeatherAlertSettingsProto {

            interface IAlertEnforceSettings {
                country_code?: (string|null);
                when?: (POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition|null);
            }

            class AlertEnforceSettings implements IAlertEnforceSettings {
                constructor(properties?: POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertEnforceSettings);
                public country_code: string;
                public when?: (POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition|null);
                public static encode(message: POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertEnforceSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings;
                public static toObject(message: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AlertEnforceSettings {

                interface IEnforceCondition {
                    color?: (string[]|null);
                    type?: (string[]|null);
                    category?: (string[]|null);
                }

                class EnforceCondition implements IEnforceCondition {
                    constructor(properties?: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition);
                    public color: string[];
                    public type: string[];
                    public category: string[];
                    public static encode(message: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.IEnforceCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.EnforceCondition;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.EnforceCondition;
                    public static toObject(message: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertEnforceSettings.EnforceCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IAlertIgnoreSettings {
                country_code?: (string|null);
                when?: (POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition|null);
            }

            class AlertIgnoreSettings implements IAlertIgnoreSettings {
                constructor(properties?: POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertIgnoreSettings);
                public country_code: string;
                public when?: (POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition|null);
                public static encode(message: POGOProtos.Rpc.WeatherAlertSettingsProto.IAlertIgnoreSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings;
                public static toObject(message: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AlertIgnoreSettings {

                interface IOverrideCondition {
                    color?: (string[]|null);
                    type?: (string[]|null);
                }

                class OverrideCondition implements IOverrideCondition {
                    constructor(properties?: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition);
                    public color: string[];
                    public type: string[];
                    public static encode(message: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.IOverrideCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.OverrideCondition;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.OverrideCondition;
                    public static toObject(message: POGOProtos.Rpc.WeatherAlertSettingsProto.AlertIgnoreSettings.OverrideCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface IWeatherBonusProto {
            cp_base_level_bonus?: (number|null);
            guaranteed_individual_values?: (number|null);
            stardust_bonus_multiplier?: (number|null);
            attack_bonus_multiplier?: (number|null);
            raid_encounter_cp_base_level_bonus?: (number|null);
            raid_encounter_guaranteed_individual_values?: (number|null);
            buddy_emotion_favorite_weather_increment?: (number|null);
            buddy_emotion_dislike_weather_decrement?: (number|null);
            raid_encounter_shadow_guaranteed_individual_values?: (number|null);
        }

        class WeatherBonusProto implements IWeatherBonusProto {
            constructor(properties?: POGOProtos.Rpc.IWeatherBonusProto);
            public cp_base_level_bonus: number;
            public guaranteed_individual_values: number;
            public stardust_bonus_multiplier: number;
            public attack_bonus_multiplier: number;
            public raid_encounter_cp_base_level_bonus: number;
            public raid_encounter_guaranteed_individual_values: number;
            public buddy_emotion_favorite_weather_increment: number;
            public buddy_emotion_dislike_weather_decrement: number;
            public raid_encounter_shadow_guaranteed_individual_values: number;
            public static encode(message: POGOProtos.Rpc.IWeatherBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherBonusProto;
            public static toObject(message: POGOProtos.Rpc.WeatherBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWeatherDetailClickTelemetry {
            gameplay_weather_type?: (string|null);
            alert_active?: (boolean|null);
            severity?: (POGOProtos.Rpc.WeatherAlertProto.Severity|null);
        }

        class WeatherDetailClickTelemetry implements IWeatherDetailClickTelemetry {
            constructor(properties?: POGOProtos.Rpc.IWeatherDetailClickTelemetry);
            public gameplay_weather_type: string;
            public alert_active: boolean;
            public severity: POGOProtos.Rpc.WeatherAlertProto.Severity;
            public static encode(message: POGOProtos.Rpc.IWeatherDetailClickTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherDetailClickTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherDetailClickTelemetry;
            public static toObject(message: POGOProtos.Rpc.WeatherDetailClickTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWeatherSettingsProto {
            gameplay_settings?: (POGOProtos.Rpc.WeatherSettingsProto.IGameplayWeatherSettingsProto|null);
            display_settings?: (POGOProtos.Rpc.WeatherSettingsProto.IDisplayWeatherSettingsProto|null);
            alert_settings?: (POGOProtos.Rpc.IWeatherAlertSettingsProto|null);
            stale_settings?: (POGOProtos.Rpc.WeatherSettingsProto.IStaleWeatherSettingsProto|null);
        }

        class WeatherSettingsProto implements IWeatherSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IWeatherSettingsProto);
            public gameplay_settings?: (POGOProtos.Rpc.WeatherSettingsProto.IGameplayWeatherSettingsProto|null);
            public display_settings?: (POGOProtos.Rpc.WeatherSettingsProto.IDisplayWeatherSettingsProto|null);
            public alert_settings?: (POGOProtos.Rpc.IWeatherAlertSettingsProto|null);
            public stale_settings?: (POGOProtos.Rpc.WeatherSettingsProto.IStaleWeatherSettingsProto|null);
            public static encode(message: POGOProtos.Rpc.IWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto;
            public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WeatherSettingsProto {

            interface IDisplayWeatherSettingsProto {
                display_level_settings?: (POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings[]|null);
                wind_level_settings?: (POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings|null);
            }

            class DisplayWeatherSettingsProto implements IDisplayWeatherSettingsProto {
                constructor(properties?: POGOProtos.Rpc.WeatherSettingsProto.IDisplayWeatherSettingsProto);
                public display_level_settings: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings[];
                public wind_level_settings?: (POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings|null);
                public static encode(message: POGOProtos.Rpc.WeatherSettingsProto.IDisplayWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto;
                public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DisplayWeatherSettingsProto {

                interface IDisplayLevelSettings {
                    condition_enums?: (string[]|null);
                    cloud_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
                    rain_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
                    snow_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
                    fog_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
                    special_effect_level?: (POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel|null);
                }

                class DisplayLevelSettings implements IDisplayLevelSettings {
                    constructor(properties?: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings);
                    public condition_enums: string[];
                    public cloud_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
                    public rain_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
                    public snow_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
                    public fog_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
                    public special_effect_level: POGOProtos.Rpc.DisplayWeatherProto.DisplayLevel;
                    public static encode(message: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IDisplayLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.DisplayLevelSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.DisplayLevelSettings;
                    public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.DisplayLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWindLevelSettings {
                    wind_level1_speed?: (number|null);
                    wind_level2_speed?: (number|null);
                    wind_level3_speed?: (number|null);
                }

                class WindLevelSettings implements IWindLevelSettings {
                    constructor(properties?: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings);
                    public wind_level1_speed: number;
                    public wind_level2_speed: number;
                    public wind_level3_speed: number;
                    public static encode(message: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.IWindLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.WindLevelSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.WindLevelSettings;
                    public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto.DisplayWeatherSettingsProto.WindLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IGameplayWeatherSettingsProto {
                condition_map?: (POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings[]|null);
                min_speed_for_windy?: (number|null);
                conditions_for_windy?: (string[]|null);
            }

            class GameplayWeatherSettingsProto implements IGameplayWeatherSettingsProto {
                constructor(properties?: POGOProtos.Rpc.WeatherSettingsProto.IGameplayWeatherSettingsProto);
                public condition_map: POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings[];
                public min_speed_for_windy: number;
                public conditions_for_windy: string[];
                public static encode(message: POGOProtos.Rpc.WeatherSettingsProto.IGameplayWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto;
                public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GameplayWeatherSettingsProto {

                interface IConditionMapSettings {
                    gameplay_condition?: (POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition|null);
                    provider_enums?: (string[]|null);
                }

                class ConditionMapSettings implements IConditionMapSettings {
                    constructor(properties?: POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings);
                    public gameplay_condition: POGOProtos.Rpc.GameplayWeatherProto.WeatherCondition;
                    public provider_enums: string[];
                    public static encode(message: POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.IConditionMapSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.ConditionMapSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.ConditionMapSettings;
                    public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto.GameplayWeatherSettingsProto.ConditionMapSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IStaleWeatherSettingsProto {
                max_stale_weather_threshold_in_hrs?: (number|null);
                default_weather_condition_code?: (number|null);
            }

            class StaleWeatherSettingsProto implements IStaleWeatherSettingsProto {
                constructor(properties?: POGOProtos.Rpc.WeatherSettingsProto.IStaleWeatherSettingsProto);
                public max_stale_weather_threshold_in_hrs: number;
                public default_weather_condition_code: number;
                public static encode(message: POGOProtos.Rpc.WeatherSettingsProto.IStaleWeatherSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeatherSettingsProto.StaleWeatherSettingsProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeatherSettingsProto.StaleWeatherSettingsProto;
                public static toObject(message: POGOProtos.Rpc.WeatherSettingsProto.StaleWeatherSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IWebSocketResponseData {
            combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
        }

        class WebSocketResponseData implements IWebSocketResponseData {
            constructor(properties?: POGOProtos.Rpc.IWebSocketResponseData);
            public combat?: (POGOProtos.Rpc.ICombatForLogProto|null);
            public static encode(message: POGOProtos.Rpc.IWebSocketResponseData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WebSocketResponseData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WebSocketResponseData;
            public static toObject(message: POGOProtos.Rpc.WebSocketResponseData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWebTelemetry {
            web_click_ids?: (POGOProtos.Rpc.WebTelemetryIds|null);
            url?: (string|null);
            fort_id?: (string|null);
            partner_id?: (string|null);
            campaign_id?: (string|null);
        }

        class WebTelemetry implements IWebTelemetry {
            constructor(properties?: POGOProtos.Rpc.IWebTelemetry);
            public web_click_ids: POGOProtos.Rpc.WebTelemetryIds;
            public url: string;
            public fort_id: string;
            public partner_id: string;
            public campaign_id: string;
            public static encode(message: POGOProtos.Rpc.IWebTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WebTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WebTelemetry;
            public static toObject(message: POGOProtos.Rpc.WebTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWebstoreRewardsLogEntry {
            result?: (POGOProtos.Rpc.WebstoreRewardsLogEntry.Result|null);
            name?: (string|null);
            image_url?: (string|null);
            rewards?: (POGOProtos.Rpc.IRedeemPasscodeRewardProto|null);
        }

        class WebstoreRewardsLogEntry implements IWebstoreRewardsLogEntry {
            constructor(properties?: POGOProtos.Rpc.IWebstoreRewardsLogEntry);
            public result: POGOProtos.Rpc.WebstoreRewardsLogEntry.Result;
            public name: string;
            public image_url: string;
            public rewards?: (POGOProtos.Rpc.IRedeemPasscodeRewardProto|null);
            public static encode(message: POGOProtos.Rpc.IWebstoreRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WebstoreRewardsLogEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WebstoreRewardsLogEntry;
            public static toObject(message: POGOProtos.Rpc.WebstoreRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WebstoreRewardsLogEntry {

            enum Result {
                UNSET = 0,
                SUCCESS = 1,
                FAILURE = 2
            }
        }

        interface IWebstoreUserDataProto {
            level?: (number|null);
            team?: (POGOProtos.Rpc.Team|null);
            inventory_storage?: (POGOProtos.Rpc.WebstoreUserDataProto.IStorage|null);
            pokemon_storage?: (POGOProtos.Rpc.WebstoreUserDataProto.IStorage|null);
            postcard_storage?: (POGOProtos.Rpc.WebstoreUserDataProto.IStorage|null);
        }

        class WebstoreUserDataProto implements IWebstoreUserDataProto {
            constructor(properties?: POGOProtos.Rpc.IWebstoreUserDataProto);
            public level: number;
            public team: POGOProtos.Rpc.Team;
            public inventory_storage?: (POGOProtos.Rpc.WebstoreUserDataProto.IStorage|null);
            public pokemon_storage?: (POGOProtos.Rpc.WebstoreUserDataProto.IStorage|null);
            public postcard_storage?: (POGOProtos.Rpc.WebstoreUserDataProto.IStorage|null);
            public static encode(message: POGOProtos.Rpc.IWebstoreUserDataProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WebstoreUserDataProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WebstoreUserDataProto;
            public static toObject(message: POGOProtos.Rpc.WebstoreUserDataProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WebstoreUserDataProto {

            interface IStorage {
                used_space?: (number|null);
                max_space?: (number|null);
            }

            class Storage implements IStorage {
                constructor(properties?: POGOProtos.Rpc.WebstoreUserDataProto.IStorage);
                public used_space: number;
                public max_space: number;
                public static encode(message: POGOProtos.Rpc.WebstoreUserDataProto.IStorage, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WebstoreUserDataProto.Storage;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WebstoreUserDataProto.Storage;
                public static toObject(message: POGOProtos.Rpc.WebstoreUserDataProto.Storage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IWeekdaysProto {
            days?: (POGOProtos.Rpc.WeekdaysProto.DayName[]|null);
        }

        class WeekdaysProto implements IWeekdaysProto {
            constructor(properties?: POGOProtos.Rpc.IWeekdaysProto);
            public days: POGOProtos.Rpc.WeekdaysProto.DayName[];
            public static encode(message: POGOProtos.Rpc.IWeekdaysProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeekdaysProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeekdaysProto;
            public static toObject(message: POGOProtos.Rpc.WeekdaysProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WeekdaysProto {

            enum DayName {
                UNSET = 0,
                MONDAY = 1,
                TUESDAY = 2,
                WEDNESDAY = 3,
                THURSDAY = 4,
                FRIDAY = 5,
                SATURDAY = 6,
                SUNDAY = 7
            }
        }

        interface IWeeklyChallengeGlobalSettingsProto {
            enable_weekly_challenges?: (boolean|null);
            enable_send_invite?: (boolean|null);
        }

        class WeeklyChallengeGlobalSettingsProto implements IWeeklyChallengeGlobalSettingsProto {
            constructor(properties?: POGOProtos.Rpc.IWeeklyChallengeGlobalSettingsProto);
            public enable_weekly_challenges: boolean;
            public enable_send_invite: boolean;
            public static encode(message: POGOProtos.Rpc.IWeeklyChallengeGlobalSettingsProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WeeklyChallengeGlobalSettingsProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WeeklyChallengeGlobalSettingsProto;
            public static toObject(message: POGOProtos.Rpc.WeeklyChallengeGlobalSettingsProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWildCreateDetail {
            caught_in_wild?: (boolean|null);
        }

        class WildCreateDetail implements IWildCreateDetail {
            constructor(properties?: POGOProtos.Rpc.IWildCreateDetail);
            public caught_in_wild: boolean;
            public static encode(message: POGOProtos.Rpc.IWildCreateDetail, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WildCreateDetail;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WildCreateDetail;
            public static toObject(message: POGOProtos.Rpc.WildCreateDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWildPokemonProto {
            encounter_id?: (number|Long|null);
            last_modified_ms?: (number|Long|null);
            latitude?: (number|null);
            longitude?: (number|null);
            spawn_point_id?: (string|null);
            pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            time_till_hidden_ms?: (number|null);
        }

        class WildPokemonProto implements IWildPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IWildPokemonProto);
            public encounter_id: (number|Long);
            public last_modified_ms: (number|Long);
            public latitude: number;
            public longitude: number;
            public spawn_point_id: string;
            public pokemon?: (POGOProtos.Rpc.IPokemonProto|null);
            public time_till_hidden_ms: number;
            public static encode(message: POGOProtos.Rpc.IWildPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WildPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WildPokemonProto;
            public static toObject(message: POGOProtos.Rpc.WildPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithAuthProviderTypeProto {
            auth_provider_type?: (string[]|null);
        }

        class WithAuthProviderTypeProto implements IWithAuthProviderTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithAuthProviderTypeProto);
            public auth_provider_type: string[];
            public static encode(message: POGOProtos.Rpc.IWithAuthProviderTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithAuthProviderTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithAuthProviderTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithAuthProviderTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithBadgeTypeProto {
            badge_type?: (POGOProtos.Rpc.HoloBadgeType[]|null);
            badge_rank?: (number|null);
            amount?: (number|null);
            badge_types_to_exclude?: (POGOProtos.Rpc.HoloBadgeType[]|null);
        }

        class WithBadgeTypeProto implements IWithBadgeTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithBadgeTypeProto);
            public badge_type: POGOProtos.Rpc.HoloBadgeType[];
            public badge_rank: number;
            public amount: number;
            public badge_types_to_exclude: POGOProtos.Rpc.HoloBadgeType[];
            public static encode(message: POGOProtos.Rpc.IWithBadgeTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithBadgeTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithBadgeTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithBadgeTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithBreadDoughPokemonProto {
        }

        class WithBreadDoughPokemonProto implements IWithBreadDoughPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IWithBreadDoughPokemonProto);
            public static encode(message: POGOProtos.Rpc.IWithBreadDoughPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithBreadDoughPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithBreadDoughPokemonProto;
            public static toObject(message: POGOProtos.Rpc.WithBreadDoughPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithBreadMoveTypeProto {
            bread_move?: (POGOProtos.Rpc.IBreadMoveSlotProto[]|null);
        }

        class WithBreadMoveTypeProto implements IWithBreadMoveTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithBreadMoveTypeProto);
            public bread_move: POGOProtos.Rpc.IBreadMoveSlotProto[];
            public static encode(message: POGOProtos.Rpc.IWithBreadMoveTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithBreadMoveTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithBreadMoveTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithBreadMoveTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithBreadPokemonProto {
        }

        class WithBreadPokemonProto implements IWithBreadPokemonProto {
            constructor(properties?: POGOProtos.Rpc.IWithBreadPokemonProto);
            public static encode(message: POGOProtos.Rpc.IWithBreadPokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithBreadPokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithBreadPokemonProto;
            public static toObject(message: POGOProtos.Rpc.WithBreadPokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithBuddyProto {
            min_buddy_level?: (POGOProtos.Rpc.BuddyLevel|null);
            must_be_on_map?: (boolean|null);
        }

        class WithBuddyProto implements IWithBuddyProto {
            constructor(properties?: POGOProtos.Rpc.IWithBuddyProto);
            public min_buddy_level: POGOProtos.Rpc.BuddyLevel;
            public must_be_on_map: boolean;
            public static encode(message: POGOProtos.Rpc.IWithBuddyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithBuddyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithBuddyProto;
            public static toObject(message: POGOProtos.Rpc.WithBuddyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithCombatTypeProto {
            combat_type?: (POGOProtos.Rpc.CombatType[]|null);
        }

        class WithCombatTypeProto implements IWithCombatTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithCombatTypeProto);
            public combat_type: POGOProtos.Rpc.CombatType[];
            public static encode(message: POGOProtos.Rpc.IWithCombatTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithCombatTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithCombatTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithCombatTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithCurveBallProto {
        }

        class WithCurveBallProto implements IWithCurveBallProto {
            constructor(properties?: POGOProtos.Rpc.IWithCurveBallProto);
            public static encode(message: POGOProtos.Rpc.IWithCurveBallProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithCurveBallProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithCurveBallProto;
            public static toObject(message: POGOProtos.Rpc.WithCurveBallProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithDailyBuddyAffectionProto {
            min_buddy_affection_earned_today?: (number|null);
        }

        class WithDailyBuddyAffectionProto implements IWithDailyBuddyAffectionProto {
            constructor(properties?: POGOProtos.Rpc.IWithDailyBuddyAffectionProto);
            public min_buddy_affection_earned_today: number;
            public static encode(message: POGOProtos.Rpc.IWithDailyBuddyAffectionProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithDailyBuddyAffectionProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithDailyBuddyAffectionProto;
            public static toObject(message: POGOProtos.Rpc.WithDailyBuddyAffectionProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithDailyCaptureBonusProto {
        }

        class WithDailyCaptureBonusProto implements IWithDailyCaptureBonusProto {
            constructor(properties?: POGOProtos.Rpc.IWithDailyCaptureBonusProto);
            public static encode(message: POGOProtos.Rpc.IWithDailyCaptureBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithDailyCaptureBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithDailyCaptureBonusProto;
            public static toObject(message: POGOProtos.Rpc.WithDailyCaptureBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithDailySpinBonusProto {
        }

        class WithDailySpinBonusProto implements IWithDailySpinBonusProto {
            constructor(properties?: POGOProtos.Rpc.IWithDailySpinBonusProto);
            public static encode(message: POGOProtos.Rpc.IWithDailySpinBonusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithDailySpinBonusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithDailySpinBonusProto;
            public static toObject(message: POGOProtos.Rpc.WithDailySpinBonusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithDeviceTypeProto {
            device_type?: (POGOProtos.Rpc.DeviceType[]|null);
        }

        class WithDeviceTypeProto implements IWithDeviceTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithDeviceTypeProto);
            public device_type: POGOProtos.Rpc.DeviceType[];
            public static encode(message: POGOProtos.Rpc.IWithDeviceTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithDeviceTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithDeviceTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithDeviceTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithDistanceProto {
            distance_km?: (number|null);
        }

        class WithDistanceProto implements IWithDistanceProto {
            constructor(properties?: POGOProtos.Rpc.IWithDistanceProto);
            public distance_km: number;
            public static encode(message: POGOProtos.Rpc.IWithDistanceProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithDistanceProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithDistanceProto;
            public static toObject(message: POGOProtos.Rpc.WithDistanceProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithElapsedTimeProto {
            elapsed_time_ms?: (number|Long|null);
        }

        class WithElapsedTimeProto implements IWithElapsedTimeProto {
            constructor(properties?: POGOProtos.Rpc.IWithElapsedTimeProto);
            public elapsed_time_ms: (number|Long);
            public static encode(message: POGOProtos.Rpc.IWithElapsedTimeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithElapsedTimeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithElapsedTimeProto;
            public static toObject(message: POGOProtos.Rpc.WithElapsedTimeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithEncounterTypeProto {
            encounter_type?: (POGOProtos.Rpc.EncounterType[]|null);
        }

        class WithEncounterTypeProto implements IWithEncounterTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithEncounterTypeProto);
            public encounter_type: POGOProtos.Rpc.EncounterType[];
            public static encode(message: POGOProtos.Rpc.IWithEncounterTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithEncounterTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithEncounterTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithEncounterTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithFortIdProto {
            fort_ids?: (string[]|null);
        }

        class WithFortIdProto implements IWithFortIdProto {
            constructor(properties?: POGOProtos.Rpc.IWithFortIdProto);
            public fort_ids: string[];
            public static encode(message: POGOProtos.Rpc.IWithFortIdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithFortIdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithFortIdProto;
            public static toObject(message: POGOProtos.Rpc.WithFortIdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithFriendLevelProto {
            friendship_level_milestone?: (POGOProtos.Rpc.FriendshipLevelMilestone[]|null);
        }

        class WithFriendLevelProto implements IWithFriendLevelProto {
            constructor(properties?: POGOProtos.Rpc.IWithFriendLevelProto);
            public friendship_level_milestone: POGOProtos.Rpc.FriendshipLevelMilestone[];
            public static encode(message: POGOProtos.Rpc.IWithFriendLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithFriendLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithFriendLevelProto;
            public static toObject(message: POGOProtos.Rpc.WithFriendLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithFriendsRaidProto {
            friend_location?: (POGOProtos.Rpc.RaidLocationRequirement|null);
            min_friends_in_raid?: (number|null);
        }

        class WithFriendsRaidProto implements IWithFriendsRaidProto {
            constructor(properties?: POGOProtos.Rpc.IWithFriendsRaidProto);
            public friend_location: POGOProtos.Rpc.RaidLocationRequirement;
            public min_friends_in_raid: number;
            public static encode(message: POGOProtos.Rpc.IWithFriendsRaidProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithFriendsRaidProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithFriendsRaidProto;
            public static toObject(message: POGOProtos.Rpc.WithFriendsRaidProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithGblRankProto {
            rank?: (number|null);
        }

        class WithGblRankProto implements IWithGblRankProto {
            constructor(properties?: POGOProtos.Rpc.IWithGblRankProto);
            public rank: number;
            public static encode(message: POGOProtos.Rpc.IWithGblRankProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithGblRankProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithGblRankProto;
            public static toObject(message: POGOProtos.Rpc.WithGblRankProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithInPartyProto {
        }

        class WithInPartyProto implements IWithInPartyProto {
            constructor(properties?: POGOProtos.Rpc.IWithInPartyProto);
            public static encode(message: POGOProtos.Rpc.IWithInPartyProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithInPartyProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithInPartyProto;
            public static toObject(message: POGOProtos.Rpc.WithInPartyProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithInvasionCharacterProto {
            category?: (POGOProtos.Rpc.EnumWrapper.CharacterCategory[]|null);
            invasion_character?: (POGOProtos.Rpc.EnumWrapper.InvasionCharacter[]|null);
        }

        class WithInvasionCharacterProto implements IWithInvasionCharacterProto {
            constructor(properties?: POGOProtos.Rpc.IWithInvasionCharacterProto);
            public category: POGOProtos.Rpc.EnumWrapper.CharacterCategory[];
            public invasion_character: POGOProtos.Rpc.EnumWrapper.InvasionCharacter[];
            public static encode(message: POGOProtos.Rpc.IWithInvasionCharacterProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithInvasionCharacterProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithInvasionCharacterProto;
            public static toObject(message: POGOProtos.Rpc.WithInvasionCharacterProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithItemProto {
            item?: (POGOProtos.Rpc.Item|null);
            items?: (POGOProtos.Rpc.Item[]|null);
        }

        class WithItemProto implements IWithItemProto {
            constructor(properties?: POGOProtos.Rpc.IWithItemProto);
            public item: POGOProtos.Rpc.Item;
            public items: POGOProtos.Rpc.Item[];
            public static encode(message: POGOProtos.Rpc.IWithItemProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithItemProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithItemProto;
            public static toObject(message: POGOProtos.Rpc.WithItemProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithItemTypeProto {
            item_type?: (POGOProtos.Rpc.HoloItemType[]|null);
        }

        class WithItemTypeProto implements IWithItemTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithItemTypeProto);
            public item_type: POGOProtos.Rpc.HoloItemType[];
            public static encode(message: POGOProtos.Rpc.IWithItemTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithItemTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithItemTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithItemTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithLocationProto {
            s2_cell_id?: ((number|Long)[]|null);
        }

        class WithLocationProto implements IWithLocationProto {
            constructor(properties?: POGOProtos.Rpc.IWithLocationProto);
            public s2_cell_id: (number|Long)[];
            public static encode(message: POGOProtos.Rpc.IWithLocationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithLocationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithLocationProto;
            public static toObject(message: POGOProtos.Rpc.WithLocationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithMaxCpProto {
            max_cp?: (number|null);
        }

        class WithMaxCpProto implements IWithMaxCpProto {
            constructor(properties?: POGOProtos.Rpc.IWithMaxCpProto);
            public max_cp: number;
            public static encode(message: POGOProtos.Rpc.IWithMaxCpProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithMaxCpProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithMaxCpProto;
            public static toObject(message: POGOProtos.Rpc.WithMaxCpProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithNpcCombatProto {
            requires_win?: (boolean|null);
            combat_npc_trainer_id?: (string[]|null);
        }

        class WithNpcCombatProto implements IWithNpcCombatProto {
            constructor(properties?: POGOProtos.Rpc.IWithNpcCombatProto);
            public requires_win: boolean;
            public combat_npc_trainer_id: string[];
            public static encode(message: POGOProtos.Rpc.IWithNpcCombatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithNpcCombatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithNpcCombatProto;
            public static toObject(message: POGOProtos.Rpc.WithNpcCombatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithOpponentPokemonBattleStatusProto {
            require_defeat?: (boolean|null);
            opponent_pokemon_type?: (POGOProtos.Rpc.HoloPokemonType[]|null);
        }

        class WithOpponentPokemonBattleStatusProto implements IWithOpponentPokemonBattleStatusProto {
            constructor(properties?: POGOProtos.Rpc.IWithOpponentPokemonBattleStatusProto);
            public require_defeat: boolean;
            public opponent_pokemon_type: POGOProtos.Rpc.HoloPokemonType[];
            public static encode(message: POGOProtos.Rpc.IWithOpponentPokemonBattleStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithOpponentPokemonBattleStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithOpponentPokemonBattleStatusProto;
            public static toObject(message: POGOProtos.Rpc.WithOpponentPokemonBattleStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPageTypeProto {
            page_type?: (POGOProtos.Rpc.PageType|null);
        }

        class WithPageTypeProto implements IWithPageTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithPageTypeProto);
            public page_type: POGOProtos.Rpc.PageType;
            public static encode(message: POGOProtos.Rpc.IWithPageTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPageTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPageTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithPageTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPlayerLevelProto {
            level?: (number|null);
        }

        class WithPlayerLevelProto implements IWithPlayerLevelProto {
            constructor(properties?: POGOProtos.Rpc.IWithPlayerLevelProto);
            public level: number;
            public static encode(message: POGOProtos.Rpc.IWithPlayerLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPlayerLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPlayerLevelProto;
            public static toObject(message: POGOProtos.Rpc.WithPlayerLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPoiSponsorIdProto {
            sponsor_id?: (string[]|null);
        }

        class WithPoiSponsorIdProto implements IWithPoiSponsorIdProto {
            constructor(properties?: POGOProtos.Rpc.IWithPoiSponsorIdProto);
            public sponsor_id: string[];
            public static encode(message: POGOProtos.Rpc.IWithPoiSponsorIdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPoiSponsorIdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPoiSponsorIdProto;
            public static toObject(message: POGOProtos.Rpc.WithPoiSponsorIdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonAlignmentProto {
            alignment?: (POGOProtos.Rpc.PokemonDisplayProto.Alignment[]|null);
        }

        class WithPokemonAlignmentProto implements IWithPokemonAlignmentProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonAlignmentProto);
            public alignment: POGOProtos.Rpc.PokemonDisplayProto.Alignment[];
            public static encode(message: POGOProtos.Rpc.IWithPokemonAlignmentProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonAlignmentProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonAlignmentProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonAlignmentProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonCategoryProto {
            category_name?: (string|null);
            pokemon_ids?: (POGOProtos.Rpc.HoloPokemonId[]|null);
        }

        class WithPokemonCategoryProto implements IWithPokemonCategoryProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonCategoryProto);
            public category_name: string;
            public pokemon_ids: POGOProtos.Rpc.HoloPokemonId[];
            public static encode(message: POGOProtos.Rpc.IWithPokemonCategoryProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonCategoryProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonCategoryProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonCategoryProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonCostumeProto {
            require_no_costume?: (boolean|null);
        }

        class WithPokemonCostumeProto implements IWithPokemonCostumeProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonCostumeProto);
            public require_no_costume: boolean;
            public static encode(message: POGOProtos.Rpc.IWithPokemonCostumeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonCostumeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonCostumeProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonCostumeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonCpLimitProto {
            min_cp?: (number|null);
            max_cp?: (number|null);
        }

        class WithPokemonCpLimitProto implements IWithPokemonCpLimitProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonCpLimitProto);
            public min_cp: number;
            public max_cp: number;
            public static encode(message: POGOProtos.Rpc.IWithPokemonCpLimitProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonCpLimitProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonCpLimitProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonCpLimitProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonCpProto {
            max_cp?: (number|null);
            min_cp?: (number|null);
        }

        class WithPokemonCpProto implements IWithPokemonCpProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonCpProto);
            public max_cp: number;
            public min_cp: number;
            public static encode(message: POGOProtos.Rpc.IWithPokemonCpProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonCpProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonCpProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonCpProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonFormProto {
            forms?: (POGOProtos.Rpc.PokemonDisplayProto.Form[]|null);
        }

        class WithPokemonFormProto implements IWithPokemonFormProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonFormProto);
            public forms: POGOProtos.Rpc.PokemonDisplayProto.Form[];
            public static encode(message: POGOProtos.Rpc.IWithPokemonFormProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonFormProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonFormProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonFormProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonLevelProto {
            max_level?: (boolean|null);
        }

        class WithPokemonLevelProto implements IWithPokemonLevelProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonLevelProto);
            public max_level: boolean;
            public static encode(message: POGOProtos.Rpc.IWithPokemonLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonLevelProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonMoveProto {
            move_ids?: (POGOProtos.Rpc.HoloPokemonMove[]|null);
        }

        class WithPokemonMoveProto implements IWithPokemonMoveProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonMoveProto);
            public move_ids: POGOProtos.Rpc.HoloPokemonMove[];
            public static encode(message: POGOProtos.Rpc.IWithPokemonMoveProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonMoveProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonMoveProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonMoveProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonSizeProto {
            pokemon_size?: (POGOProtos.Rpc.HoloPokemonSize[]|null);
        }

        class WithPokemonSizeProto implements IWithPokemonSizeProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonSizeProto);
            public pokemon_size: POGOProtos.Rpc.HoloPokemonSize[];
            public static encode(message: POGOProtos.Rpc.IWithPokemonSizeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonSizeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonSizeProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonSizeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPokemonTypeProto {
            pokemon_type?: (POGOProtos.Rpc.HoloPokemonType[]|null);
        }

        class WithPokemonTypeProto implements IWithPokemonTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithPokemonTypeProto);
            public pokemon_type: POGOProtos.Rpc.HoloPokemonType[];
            public static encode(message: POGOProtos.Rpc.IWithPokemonTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPokemonTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPokemonTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithPokemonTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithPvpCombatProto {
            requires_win?: (boolean|null);
            combat_league_template_id?: (string[]|null);
            combat_league_badge?: (POGOProtos.Rpc.HoloBadgeType|null);
        }

        class WithPvpCombatProto implements IWithPvpCombatProto {
            constructor(properties?: POGOProtos.Rpc.IWithPvpCombatProto);
            public requires_win: boolean;
            public combat_league_template_id: string[];
            public combat_league_badge: POGOProtos.Rpc.HoloBadgeType;
            public static encode(message: POGOProtos.Rpc.IWithPvpCombatProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithPvpCombatProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithPvpCombatProto;
            public static toObject(message: POGOProtos.Rpc.WithPvpCombatProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithQuestContextProto {
            context?: (POGOProtos.Rpc.QuestProto.Context|null);
        }

        class WithQuestContextProto implements IWithQuestContextProto {
            constructor(properties?: POGOProtos.Rpc.IWithQuestContextProto);
            public context: POGOProtos.Rpc.QuestProto.Context;
            public static encode(message: POGOProtos.Rpc.IWithQuestContextProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithQuestContextProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithQuestContextProto;
            public static toObject(message: POGOProtos.Rpc.WithQuestContextProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithRaidLevelProto {
            raid_level?: (POGOProtos.Rpc.RaidLevel[]|null);
        }

        class WithRaidLevelProto implements IWithRaidLevelProto {
            constructor(properties?: POGOProtos.Rpc.IWithRaidLevelProto);
            public raid_level: POGOProtos.Rpc.RaidLevel[];
            public static encode(message: POGOProtos.Rpc.IWithRaidLevelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithRaidLevelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithRaidLevelProto;
            public static toObject(message: POGOProtos.Rpc.WithRaidLevelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithRaidLocationProto {
            location?: (POGOProtos.Rpc.RaidLocationRequirement|null);
        }

        class WithRaidLocationProto implements IWithRaidLocationProto {
            constructor(properties?: POGOProtos.Rpc.IWithRaidLocationProto);
            public location: POGOProtos.Rpc.RaidLocationRequirement;
            public static encode(message: POGOProtos.Rpc.IWithRaidLocationProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithRaidLocationProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithRaidLocationProto;
            public static toObject(message: POGOProtos.Rpc.WithRaidLocationProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithRouteTravelProto {
        }

        class WithRouteTravelProto implements IWithRouteTravelProto {
            constructor(properties?: POGOProtos.Rpc.IWithRouteTravelProto);
            public static encode(message: POGOProtos.Rpc.IWithRouteTravelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithRouteTravelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithRouteTravelProto;
            public static toObject(message: POGOProtos.Rpc.WithRouteTravelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithSingleDayProto {
            last_window?: (number|Long|null);
        }

        class WithSingleDayProto implements IWithSingleDayProto {
            constructor(properties?: POGOProtos.Rpc.IWithSingleDayProto);
            public last_window: (number|Long);
            public static encode(message: POGOProtos.Rpc.IWithSingleDayProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithSingleDayProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithSingleDayProto;
            public static toObject(message: POGOProtos.Rpc.WithSingleDayProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithSuperEffectiveChargeMoveProto {
        }

        class WithSuperEffectiveChargeMoveProto implements IWithSuperEffectiveChargeMoveProto {
            constructor(properties?: POGOProtos.Rpc.IWithSuperEffectiveChargeMoveProto);
            public static encode(message: POGOProtos.Rpc.IWithSuperEffectiveChargeMoveProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithSuperEffectiveChargeMoveProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithSuperEffectiveChargeMoveProto;
            public static toObject(message: POGOProtos.Rpc.WithSuperEffectiveChargeMoveProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithTappableTypeProto {
            tappable_type?: (POGOProtos.Rpc.Tappable.TappableType|null);
            tappable_type_id?: (string|null);
        }

        class WithTappableTypeProto implements IWithTappableTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithTappableTypeProto);
            public tappable_type: POGOProtos.Rpc.Tappable.TappableType;
            public tappable_type_id: string;
            public static encode(message: POGOProtos.Rpc.IWithTappableTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithTappableTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithTappableTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithTappableTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithTempEvoIdProto {
            mega_form?: (POGOProtos.Rpc.HoloTemporaryEvolutionId[]|null);
        }

        class WithTempEvoIdProto implements IWithTempEvoIdProto {
            constructor(properties?: POGOProtos.Rpc.IWithTempEvoIdProto);
            public mega_form: POGOProtos.Rpc.HoloTemporaryEvolutionId[];
            public static encode(message: POGOProtos.Rpc.IWithTempEvoIdProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithTempEvoIdProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithTempEvoIdProto;
            public static toObject(message: POGOProtos.Rpc.WithTempEvoIdProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithThrowTypeProto {
            throw_type?: (POGOProtos.Rpc.HoloActivityType|null);
            hit?: (boolean|null);
        }

        class WithThrowTypeProto implements IWithThrowTypeProto {
            constructor(properties?: POGOProtos.Rpc.IWithThrowTypeProto);
            public throw_type?: (POGOProtos.Rpc.HoloActivityType|null);
            public hit?: (boolean|null);
            public Throw?: ("throw_type"|"hit");
            public static encode(message: POGOProtos.Rpc.IWithThrowTypeProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithThrowTypeProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithThrowTypeProto;
            public static toObject(message: POGOProtos.Rpc.WithThrowTypeProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithTotalDaysProto {
            last_window?: (number|null);
        }

        class WithTotalDaysProto implements IWithTotalDaysProto {
            constructor(properties?: POGOProtos.Rpc.IWithTotalDaysProto);
            public last_window: number;
            public static encode(message: POGOProtos.Rpc.IWithTotalDaysProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithTotalDaysProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithTotalDaysProto;
            public static toObject(message: POGOProtos.Rpc.WithTotalDaysProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithTraineePokemonAttributesProto {
            trainee_attribute?: (POGOProtos.Rpc.WithTraineePokemonAttributesProto.TraineeAttribute[]|null);
        }

        class WithTraineePokemonAttributesProto implements IWithTraineePokemonAttributesProto {
            constructor(properties?: POGOProtos.Rpc.IWithTraineePokemonAttributesProto);
            public trainee_attribute: POGOProtos.Rpc.WithTraineePokemonAttributesProto.TraineeAttribute[];
            public static encode(message: POGOProtos.Rpc.IWithTraineePokemonAttributesProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithTraineePokemonAttributesProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithTraineePokemonAttributesProto;
            public static toObject(message: POGOProtos.Rpc.WithTraineePokemonAttributesProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WithTraineePokemonAttributesProto {

            enum TraineeAttribute {
                UNSET = 0,
                POKEMON_TYPES = 1,
                UNIQUE_POKEMON_ID = 2
            }
        }

        interface IWithUniquePokemonProto {
        }

        class WithUniquePokemonProto implements IWithUniquePokemonProto {
            constructor(properties?: POGOProtos.Rpc.IWithUniquePokemonProto);
            public static encode(message: POGOProtos.Rpc.IWithUniquePokemonProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithUniquePokemonProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithUniquePokemonProto;
            public static toObject(message: POGOProtos.Rpc.WithUniquePokemonProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithUniquePokestopProto {
            context?: (POGOProtos.Rpc.WithUniquePokestopProto.Context|null);
        }

        class WithUniquePokestopProto implements IWithUniquePokestopProto {
            constructor(properties?: POGOProtos.Rpc.IWithUniquePokestopProto);
            public context: POGOProtos.Rpc.WithUniquePokestopProto.Context;
            public static encode(message: POGOProtos.Rpc.IWithUniquePokestopProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithUniquePokestopProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithUniquePokestopProto;
            public static toObject(message: POGOProtos.Rpc.WithUniquePokestopProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace WithUniquePokestopProto {

            enum Context {
                UNSET = 0,
                QUEST = 1
            }
        }

        interface IWithUniqueRouteTravelProto {
        }

        class WithUniqueRouteTravelProto implements IWithUniqueRouteTravelProto {
            constructor(properties?: POGOProtos.Rpc.IWithUniqueRouteTravelProto);
            public static encode(message: POGOProtos.Rpc.IWithUniqueRouteTravelProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithUniqueRouteTravelProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithUniqueRouteTravelProto;
            public static toObject(message: POGOProtos.Rpc.WithUniqueRouteTravelProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithWeatherBoostProto {
        }

        class WithWeatherBoostProto implements IWithWeatherBoostProto {
            constructor(properties?: POGOProtos.Rpc.IWithWeatherBoostProto);
            public static encode(message: POGOProtos.Rpc.IWithWeatherBoostProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithWeatherBoostProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithWeatherBoostProto;
            public static toObject(message: POGOProtos.Rpc.WithWeatherBoostProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithWinBattleStatusProto {
        }

        class WithWinBattleStatusProto implements IWithWinBattleStatusProto {
            constructor(properties?: POGOProtos.Rpc.IWithWinBattleStatusProto);
            public static encode(message: POGOProtos.Rpc.IWithWinBattleStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithWinBattleStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithWinBattleStatusProto;
            public static toObject(message: POGOProtos.Rpc.WithWinBattleStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithWinGymBattleStatusProto {
        }

        class WithWinGymBattleStatusProto implements IWithWinGymBattleStatusProto {
            constructor(properties?: POGOProtos.Rpc.IWithWinGymBattleStatusProto);
            public static encode(message: POGOProtos.Rpc.IWithWinGymBattleStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithWinGymBattleStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithWinGymBattleStatusProto;
            public static toObject(message: POGOProtos.Rpc.WithWinGymBattleStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWithWinRaidStatusProto {
        }

        class WithWinRaidStatusProto implements IWithWinRaidStatusProto {
            constructor(properties?: POGOProtos.Rpc.IWithWinRaidStatusProto);
            public static encode(message: POGOProtos.Rpc.IWithWinRaidStatusProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WithWinRaidStatusProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WithWinRaidStatusProto;
            public static toObject(message: POGOProtos.Rpc.WithWinRaidStatusProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWpsAvailableEvent {
            wps_session_id?: (string|null);
            time_to_available_ms?: (number|Long|null);
            distance_to_available_m?: (number|null);
        }

        class WpsAvailableEvent implements IWpsAvailableEvent {
            constructor(properties?: POGOProtos.Rpc.IWpsAvailableEvent);
            public wps_session_id: string;
            public time_to_available_ms: (number|Long);
            public distance_to_available_m: number;
            public static encode(message: POGOProtos.Rpc.IWpsAvailableEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WpsAvailableEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WpsAvailableEvent;
            public static toObject(message: POGOProtos.Rpc.WpsAvailableEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWpsStartEvent {
            wps_session_id?: (string|null);
        }

        class WpsStartEvent implements IWpsStartEvent {
            constructor(properties?: POGOProtos.Rpc.IWpsStartEvent);
            public wps_session_id: string;
            public static encode(message: POGOProtos.Rpc.IWpsStartEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WpsStartEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WpsStartEvent;
            public static toObject(message: POGOProtos.Rpc.WpsStartEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IWpsStopEvent {
            wps_session_id?: (string|null);
            session_time_ms?: (number|Long|null);
            session_distance_m?: (number|null);
        }

        class WpsStopEvent implements IWpsStopEvent {
            constructor(properties?: POGOProtos.Rpc.IWpsStopEvent);
            public wps_session_id: string;
            public session_time_ms: (number|Long);
            public session_distance_m: number;
            public static encode(message: POGOProtos.Rpc.IWpsStopEvent, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.WpsStopEvent;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.WpsStopEvent;
            public static toObject(message: POGOProtos.Rpc.WpsStopEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IYesNoSelectorProto {
            yes_key?: (string|null);
            no_key?: (string|null);
            yes_next_step?: (string|null);
            no_next_step?: (string|null);
        }

        class YesNoSelectorProto implements IYesNoSelectorProto {
            constructor(properties?: POGOProtos.Rpc.IYesNoSelectorProto);
            public yes_key: string;
            public no_key: string;
            public yes_next_step: string;
            public no_next_step: string;
            public static encode(message: POGOProtos.Rpc.IYesNoSelectorProto, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Rpc.YesNoSelectorProto;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Rpc.YesNoSelectorProto;
            public static toObject(message: POGOProtos.Rpc.YesNoSelectorProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }
    }
}
