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

    namespace Data {

        namespace Analytics {

            interface IClientTelemetryBatch {
                telemetry_scope_id?: (POGOProtos.Data.Analytics.ClientTelemetryBatch.TelemetryScopeId|null);
                events?: (POGOProtos.Data.Analytics.IClientTelemetryRecord[]|null);
                api_version?: (string|null);
                message_version?: (string|null);
            }

            class ClientTelemetryBatch implements IClientTelemetryBatch {
                constructor(properties?: POGOProtos.Data.Analytics.IClientTelemetryBatch);
                public telemetry_scope_id: POGOProtos.Data.Analytics.ClientTelemetryBatch.TelemetryScopeId;
                public events: POGOProtos.Data.Analytics.IClientTelemetryRecord[];
                public api_version: string;
                public message_version: string;
                public static encode(message: POGOProtos.Data.Analytics.IClientTelemetryBatch, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Analytics.ClientTelemetryBatch;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Analytics.ClientTelemetryBatch;
                public static toObject(message: POGOProtos.Data.Analytics.ClientTelemetryBatch, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ClientTelemetryBatch {

                enum TelemetryScopeId {
                    UNSET = 0,
                    DITTO = 1,
                    GAME = 2
                }
            }

            interface IClientTelemetryClientSettings {
                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);
            }

            class ClientTelemetryClientSettings implements IClientTelemetryClientSettings {
                constructor(properties?: POGOProtos.Data.Analytics.IClientTelemetryClientSettings);
                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 static encode(message: POGOProtos.Data.Analytics.IClientTelemetryClientSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Analytics.ClientTelemetryClientSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Analytics.ClientTelemetryClientSettings;
                public static toObject(message: POGOProtos.Data.Analytics.ClientTelemetryClientSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IClientTelemetryRecord {
                record_id?: (string|null);
                encoded_message?: (Uint8Array|null);
                client_timestamp_ms?: (number|Long|null);
                metric_id?: (number|Long|null);
            }

            class ClientTelemetryRecord implements IClientTelemetryRecord {
                constructor(properties?: POGOProtos.Data.Analytics.IClientTelemetryRecord);
                public record_id: string;
                public encoded_message: Uint8Array;
                public client_timestamp_ms: (number|Long);
                public metric_id: (number|Long);
                public static encode(message: POGOProtos.Data.Analytics.IClientTelemetryRecord, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Analytics.ClientTelemetryRecord;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Analytics.ClientTelemetryRecord;
                public static toObject(message: POGOProtos.Data.Analytics.ClientTelemetryRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IClientTelemetrySettingsRequest {
            }

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

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

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

        namespace AssetCache {

            interface IHashedKey {
                hashed_key_raw?: (string|null);
            }

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

            interface IJournalAddEntry {
                hashed_key?: (POGOProtos.Data.AssetCache.IHashedKey|null);
                entry_size?: (number|Long|null);
            }

            class JournalAddEntry implements IJournalAddEntry {
                constructor(properties?: POGOProtos.Data.AssetCache.IJournalAddEntry);
                public hashed_key?: (POGOProtos.Data.AssetCache.IHashedKey|null);
                public entry_size: (number|Long);
                public static encode(message: POGOProtos.Data.AssetCache.IJournalAddEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.AssetCache.JournalAddEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.AssetCache.JournalAddEntry;
                public static toObject(message: POGOProtos.Data.AssetCache.JournalAddEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IJournalEntry {
                add_entry?: (POGOProtos.Data.AssetCache.IJournalAddEntry|null);
                read_entry?: (POGOProtos.Data.AssetCache.IJournalReadEntry|null);
                remove_entry?: (POGOProtos.Data.AssetCache.IJournalRemoveEntry|null);
            }

            class JournalEntry implements IJournalEntry {
                constructor(properties?: POGOProtos.Data.AssetCache.IJournalEntry);
                public add_entry?: (POGOProtos.Data.AssetCache.IJournalAddEntry|null);
                public read_entry?: (POGOProtos.Data.AssetCache.IJournalReadEntry|null);
                public remove_entry?: (POGOProtos.Data.AssetCache.IJournalRemoveEntry|null);
                public Subentry?: ("add_entry"|"read_entry"|"remove_entry");
                public static encode(message: POGOProtos.Data.AssetCache.IJournalEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.AssetCache.JournalEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.AssetCache.JournalEntry;
                public static toObject(message: POGOProtos.Data.AssetCache.JournalEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IJournalReadEntry {
                hashed_key?: (POGOProtos.Data.AssetCache.IHashedKey|null);
            }

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

            interface IJournalRemoveEntry {
                hashed_key?: (POGOProtos.Data.AssetCache.IHashedKey|null);
            }

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

            interface IJournalVersion {
                version?: (number|null);
            }

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

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

        class AssetDigestEntry implements IAssetDigestEntry {
            constructor(properties?: POGOProtos.Data.IAssetDigestEntry);
            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.Data.IAssetDigestEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.AssetDigestEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.AssetDigestEntry;
            public static toObject(message: POGOProtos.Data.AssetDigestEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Avatar {

            interface IAvatarCustomization {
                enabled?: (boolean|null);
                avatar_type?: (POGOProtos.Data.Player.PlayerAvatarType|null);
                slot?: (POGOProtos.Data.Avatar.AvatarCustomization.Slot[]|null);
                bundle_name?: (string|null);
                asset_name?: (string|null);
                group_name?: (string|null);
                sort_order?: (number|null);
                unlock_type?: (POGOProtos.Data.Avatar.AvatarCustomization.AvatarCustomizationUnlockType|null);
                promo_type?: (POGOProtos.Data.Avatar.AvatarCustomization.AvatarCustomizationPromoType[]|null);
                unlock_badge_type?: (POGOProtos.Enums.BadgeType|null);
                iap_sku?: (string|null);
                unlock_badge_level?: (number|null);
                icon_name?: (string|null);
                unlock_player_level?: (number|null);
            }

            class AvatarCustomization implements IAvatarCustomization {
                constructor(properties?: POGOProtos.Data.Avatar.IAvatarCustomization);
                public enabled: boolean;
                public avatar_type: POGOProtos.Data.Player.PlayerAvatarType;
                public slot: POGOProtos.Data.Avatar.AvatarCustomization.Slot[];
                public bundle_name: string;
                public asset_name: string;
                public group_name: string;
                public sort_order: number;
                public unlock_type: POGOProtos.Data.Avatar.AvatarCustomization.AvatarCustomizationUnlockType;
                public promo_type: POGOProtos.Data.Avatar.AvatarCustomization.AvatarCustomizationPromoType[];
                public unlock_badge_type: POGOProtos.Enums.BadgeType;
                public iap_sku: string;
                public unlock_badge_level: number;
                public icon_name: string;
                public unlock_player_level: number;
                public static encode(message: POGOProtos.Data.Avatar.IAvatarCustomization, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Avatar.AvatarCustomization;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Avatar.AvatarCustomization;
                public static toObject(message: POGOProtos.Data.Avatar.AvatarCustomization, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AvatarCustomization {

                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
                }

                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
                }
            }

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

            class AvatarItem implements IAvatarItem {
                constructor(properties?: POGOProtos.Data.Avatar.IAvatarItem);
                public avatar_template_id: string;
                public new_timestamp_ms: (number|Long);
                public viewed: boolean;
                public static encode(message: POGOProtos.Data.Avatar.IAvatarItem, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Avatar.AvatarItem;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Avatar.AvatarItem;
                public static toObject(message: POGOProtos.Data.Avatar.AvatarItem, 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.Data.IBackgroundToken);
            public token: Uint8Array;
            public expiration_time: (number|Long);
            public iv: Uint8Array;
            public static encode(message: POGOProtos.Data.IBackgroundToken, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.BackgroundToken;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.BackgroundToken;
            public static toObject(message: POGOProtos.Data.BackgroundToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Badge {

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

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

            interface IBadgeCaptureReward {
                capture_reward_multiplier?: (number|null);
                avatar_template_ids?: (string[]|null);
            }

            class BadgeCaptureReward implements IBadgeCaptureReward {
                constructor(properties?: POGOProtos.Data.Badge.IBadgeCaptureReward);
                public capture_reward_multiplier: number;
                public avatar_template_ids: string[];
                public static encode(message: POGOProtos.Data.Badge.IBadgeCaptureReward, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Badge.BadgeCaptureReward;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Badge.BadgeCaptureReward;
                public static toObject(message: POGOProtos.Data.Badge.BadgeCaptureReward, 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_battles_lost?: (number|null);
                num_berries_fed?: (number|null);
                num_deploys?: (number|null);
                gym_battles?: (POGOProtos.Data.Gym.IGymBattle[]|null);
            }

            class GymBadgeStats implements IGymBadgeStats {
                constructor(properties?: POGOProtos.Data.Badge.IGymBadgeStats);
                public total_time_defended_ms: (number|Long);
                public num_battles_won: number;
                public num_battles_lost: number;
                public num_berries_fed: number;
                public num_deploys: number;
                public gym_battles: POGOProtos.Data.Gym.IGymBattle[];
                public static encode(message: POGOProtos.Data.Badge.IGymBadgeStats, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Badge.GymBadgeStats;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Badge.GymBadgeStats;
                public static toObject(message: POGOProtos.Data.Badge.GymBadgeStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Battle {

            interface IBattle {
                battle_start_ms?: (number|Long|null);
                battle_end_ms?: (number|Long|null);
                battle_id?: (string|null);
                defender?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                attacker?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                weather_condition?: (POGOProtos.Enums.WeatherCondition|null);
                highest_friendship_milestone?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
            }

            class Battle implements IBattle {
                constructor(properties?: POGOProtos.Data.Battle.IBattle);
                public battle_start_ms: (number|Long);
                public battle_end_ms: (number|Long);
                public battle_id: string;
                public defender?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                public battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                public attacker?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                public weather_condition: POGOProtos.Enums.WeatherCondition;
                public highest_friendship_milestone: POGOProtos.Enums.FriendshipLevelMilestone;
                public static encode(message: POGOProtos.Data.Battle.IBattle, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.Battle;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.Battle;
                public static toObject(message: POGOProtos.Data.Battle.Battle, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattleAction {
                type?: (POGOProtos.Data.Battle.BattleActionType|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);
                player_joined?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                battle_results?: (POGOProtos.Data.Battle.IBattleResults|null);
                damage_windows_start_timestamp_ms?: (number|Long|null);
                damage_windows_end_timestamp_ms?: (number|Long|null);
                player_left?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                target_pokemon_id?: (number|Long|null);
                leveled_up_friends?: (POGOProtos.Data.Friends.ILeveledUpFriends|null);
            }

            class BattleAction implements IBattleAction {
                constructor(properties?: POGOProtos.Data.Battle.IBattleAction);
                public type: POGOProtos.Data.Battle.BattleActionType;
                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 player_joined?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                public battle_results?: (POGOProtos.Data.Battle.IBattleResults|null);
                public damage_windows_start_timestamp_ms: (number|Long);
                public damage_windows_end_timestamp_ms: (number|Long);
                public player_left?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                public target_pokemon_id: (number|Long);
                public leveled_up_friends?: (POGOProtos.Data.Friends.ILeveledUpFriends|null);
                public static encode(message: POGOProtos.Data.Battle.IBattleAction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattleAction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattleAction;
                public static toObject(message: POGOProtos.Data.Battle.BattleAction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum BattleActionType {
                ACTION_UNSET = 0,
                ACTION_ATTACK = 1,
                ACTION_DODGE = 2,
                ACTION_SPECIAL_ATTACK = 3,
                ACTION_SWAP_POKEMON = 4,
                ACTION_FAINT = 5,
                ACTION_PLAYER_JOIN = 6,
                ACTION_PLAYER_QUIT = 7,
                ACTION_VICTORY = 8,
                ACTION_DEFEAT = 9,
                ACTION_TIMED_OUT = 10,
                ACTION_SPECIAL_ATTACK_2 = 11
            }

            interface IBattleLog {
                state?: (POGOProtos.Data.Battle.BattleState|null);
                battle_type?: (POGOProtos.Data.Battle.BattleType|null);
                server_ms?: (number|Long|null);
                battle_actions?: (POGOProtos.Data.Battle.IBattleAction[]|null);
                battle_start_timestamp_ms?: (number|Long|null);
                battle_end_timestamp_ms?: (number|Long|null);
            }

            class BattleLog implements IBattleLog {
                constructor(properties?: POGOProtos.Data.Battle.IBattleLog);
                public state: POGOProtos.Data.Battle.BattleState;
                public battle_type: POGOProtos.Data.Battle.BattleType;
                public server_ms: (number|Long);
                public battle_actions: POGOProtos.Data.Battle.IBattleAction[];
                public battle_start_timestamp_ms: (number|Long);
                public battle_end_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Data.Battle.IBattleLog, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattleLog;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattleLog;
                public static toObject(message: POGOProtos.Data.Battle.BattleLog, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattleParticipant {
                active_pokemon?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                trainer_public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                reverse_pokemon?: (POGOProtos.Data.Battle.IBattlePokemonInfo[]|null);
                defeated_pokemon?: (POGOProtos.Data.Battle.IBattlePokemonInfo[]|null);
                lobby_pokemon?: (POGOProtos.Map.Pokemon.ILobbyPokemon[]|null);
                damage_dealt?: (number|null);
                super_effective_charge_move?: (boolean|null);
                weather_boosted?: (boolean|null);
                highest_friendship_milestone?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
                friend_codename?: (string[]|null);
            }

            class BattleParticipant implements IBattleParticipant {
                constructor(properties?: POGOProtos.Data.Battle.IBattleParticipant);
                public active_pokemon?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                public trainer_public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public reverse_pokemon: POGOProtos.Data.Battle.IBattlePokemonInfo[];
                public defeated_pokemon: POGOProtos.Data.Battle.IBattlePokemonInfo[];
                public lobby_pokemon: POGOProtos.Map.Pokemon.ILobbyPokemon[];
                public damage_dealt: number;
                public super_effective_charge_move: boolean;
                public weather_boosted: boolean;
                public highest_friendship_milestone: POGOProtos.Enums.FriendshipLevelMilestone;
                public friend_codename: string[];
                public static encode(message: POGOProtos.Data.Battle.IBattleParticipant, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattleParticipant;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattleParticipant;
                public static toObject(message: POGOProtos.Data.Battle.BattleParticipant, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattleParties {
                battle_parties?: (POGOProtos.Data.Battle.IBattleParty[]|null);
            }

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

            interface IBattleParty {
                name?: (string|null);
                team_number?: (number|null);
                ids?: ((number|Long)[]|null);
                combat_league_id?: (string|null);
            }

            class BattleParty implements IBattleParty {
                constructor(properties?: POGOProtos.Data.Battle.IBattleParty);
                public name: string;
                public team_number: number;
                public ids: (number|Long)[];
                public combat_league_id: string;
                public static encode(message: POGOProtos.Data.Battle.IBattleParty, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattleParty;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattleParty;
                public static toObject(message: POGOProtos.Data.Battle.BattleParty, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattlePokemonInfo {
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                current_health?: (number|null);
                current_energy?: (number|null);
            }

            class BattlePokemonInfo implements IBattlePokemonInfo {
                constructor(properties?: POGOProtos.Data.Battle.IBattlePokemonInfo);
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public current_health: number;
                public current_energy: number;
                public static encode(message: POGOProtos.Data.Battle.IBattlePokemonInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattlePokemonInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattlePokemonInfo;
                public static toObject(message: POGOProtos.Data.Battle.BattlePokemonInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattleResults {
                gym_state?: (POGOProtos.Data.Gym.IGymState|null);
                attackers?: (POGOProtos.Data.Battle.IBattleParticipant[]|null);
                player_xp_awarded?: (number[]|null);
                next_defender_pokemon_id?: (number|Long|null);
                gym_points_delta?: (number|null);
                gym_status?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                participation?: (POGOProtos.Data.Raid.IParticipation[]|null);
                raid_item_rewards?: (POGOProtos.Inventory.ILoot[]|null);
                post_raid_encounter?: (POGOProtos.Data.Raid.IRaidEncounter[]|null);
                gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge[]|null);
                default_raid_item_rewards?: (POGOProtos.Inventory.ILoot[]|null);
            }

            class BattleResults implements IBattleResults {
                constructor(properties?: POGOProtos.Data.Battle.IBattleResults);
                public gym_state?: (POGOProtos.Data.Gym.IGymState|null);
                public attackers: POGOProtos.Data.Battle.IBattleParticipant[];
                public player_xp_awarded: number[];
                public next_defender_pokemon_id: (number|Long);
                public gym_points_delta: number;
                public gym_status?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                public participation: POGOProtos.Data.Raid.IParticipation[];
                public raid_item_rewards: POGOProtos.Inventory.ILoot[];
                public post_raid_encounter: POGOProtos.Data.Raid.IRaidEncounter[];
                public gym_badge: POGOProtos.Data.Badge.IAwardedGymBadge[];
                public default_raid_item_rewards: POGOProtos.Inventory.ILoot[];
                public static encode(message: POGOProtos.Data.Battle.IBattleResults, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattleResults;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattleResults;
                public static toObject(message: POGOProtos.Data.Battle.BattleResults, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum BattleState {
                STATE_UNSET = 0,
                ACTIVE = 1,
                VICTORY = 2,
                DEFEATED = 3,
                TIMED_OUT = 4
            }

            enum BattleType {
                BATTLE_TYPE_UNSET = 0,
                BATTLE_TYPE_NORMAL = 1,
                BATTLE_TYPE_TRAINING = 2,
                BATTLE_TYPE_RAID = 3
            }

            interface IBattleUpdate {
                battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                battle_id?: (string|null);
                active_defender?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                active_attacker?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                highest_friendship_milestone?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
            }

            class BattleUpdate implements IBattleUpdate {
                constructor(properties?: POGOProtos.Data.Battle.IBattleUpdate);
                public battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                public battle_id: string;
                public active_defender?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                public active_attacker?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                public highest_friendship_milestone: POGOProtos.Enums.FriendshipLevelMilestone;
                public static encode(message: POGOProtos.Data.Battle.IBattleUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Battle.BattleUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Battle.BattleUpdate;
                public static toObject(message: POGOProtos.Data.Battle.BattleUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Beluga {

            interface IBelugaBleCompleteTransferRequest {
                transaction_id?: (number|Long|null);
                beluga_requested_item_id?: (number|null);
                nonce?: (string|null);
            }

            class BelugaBleCompleteTransferRequest implements IBelugaBleCompleteTransferRequest {
                constructor(properties?: POGOProtos.Data.Beluga.IBelugaBleCompleteTransferRequest);
                public transaction_id: (number|Long);
                public beluga_requested_item_id: number;
                public nonce: string;
                public static encode(message: POGOProtos.Data.Beluga.IBelugaBleCompleteTransferRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Beluga.BelugaBleCompleteTransferRequest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Beluga.BelugaBleCompleteTransferRequest;
                public static toObject(message: POGOProtos.Data.Beluga.BelugaBleCompleteTransferRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaBleFinalizeTransfer {
                beluga_transfer_complete?: (POGOProtos.Data.Beluga.IBelugaBleTransferComplete|null);
                server_signature?: (Uint8Array|null);
            }

            class BelugaBleFinalizeTransfer implements IBelugaBleFinalizeTransfer {
                constructor(properties?: POGOProtos.Data.Beluga.IBelugaBleFinalizeTransfer);
                public beluga_transfer_complete?: (POGOProtos.Data.Beluga.IBelugaBleTransferComplete|null);
                public server_signature: Uint8Array;
                public static encode(message: POGOProtos.Data.Beluga.IBelugaBleFinalizeTransfer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Beluga.BelugaBleFinalizeTransfer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Beluga.BelugaBleFinalizeTransfer;
                public static toObject(message: POGOProtos.Data.Beluga.BelugaBleFinalizeTransfer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaBleTransferProto {
                server_response?: (POGOProtos.Data.Beluga.IBelugaBleTransferPrep|null);
                server_signature?: (Uint8Array|null);
                localized_origins?: (string[]|null);
                language?: (string|null);
            }

            class BelugaBleTransferProto implements IBelugaBleTransferProto {
                constructor(properties?: POGOProtos.Data.Beluga.IBelugaBleTransferProto);
                public server_response?: (POGOProtos.Data.Beluga.IBelugaBleTransferPrep|null);
                public server_signature: Uint8Array;
                public localized_origins: string[];
                public language: string;
                public static encode(message: POGOProtos.Data.Beluga.IBelugaBleTransferProto, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Beluga.BelugaBleTransferProto;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Beluga.BelugaBleTransferProto;
                public static toObject(message: POGOProtos.Data.Beluga.BelugaBleTransferProto, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaBleTransferComplete {
                nonce?: (string|null);
                beluga_id?: (string|null);
            }

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

            interface IBelugaBleTransferPrep {
                pokemon_list?: (POGOProtos.Data.Beluga.IBelugaPokemon[]|null);
                eligble_for_item?: (boolean|null);
                transaction_id?: (number|Long|null);
                beluga_id?: (string|null);
                nonce?: (string|null);
            }

            class BelugaBleTransferPrep implements IBelugaBleTransferPrep {
                constructor(properties?: POGOProtos.Data.Beluga.IBelugaBleTransferPrep);
                public pokemon_list: POGOProtos.Data.Beluga.IBelugaPokemon[];
                public eligble_for_item: boolean;
                public transaction_id: (number|Long);
                public beluga_id: string;
                public nonce: string;
                public static encode(message: POGOProtos.Data.Beluga.IBelugaBleTransferPrep, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Beluga.BelugaBleTransferPrep;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Beluga.BelugaBleTransferPrep;
                public static toObject(message: POGOProtos.Data.Beluga.BelugaBleTransferPrep, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaIncenseBox {
                is_usable?: (boolean|null);
                cool_down_finished_timestamp_ms?: (number|Long|null);
            }

            class BelugaIncenseBox implements IBelugaIncenseBox {
                constructor(properties?: POGOProtos.Data.Beluga.IBelugaIncenseBox);
                public is_usable: boolean;
                public cool_down_finished_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Data.Beluga.IBelugaIncenseBox, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Beluga.BelugaIncenseBox;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Beluga.BelugaIncenseBox;
                public static toObject(message: POGOProtos.Data.Beluga.BelugaIncenseBox, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaPokemon {
                trainer_name?: (string|null);
                trainer_gender?: (POGOProtos.Data.Beluga.BelugaPokemon.TrainerGender|null);
                trainer_team?: (POGOProtos.Enums.TeamColor|null);
                trainer_level?: (number|null);
                pokedex_id?: (number|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.Enums.Gender|null);
                costume?: (POGOProtos.Enums.Costume|null);
                form?: (POGOProtos.Data.Beluga.BelugaPokemon.PokemonForm|null);
                shiny?: (boolean|null);
                move1?: (POGOProtos.Enums.PokemonMove|null);
                move2?: (POGOProtos.Enums.PokemonMove|null);
            }

            class BelugaPokemon implements IBelugaPokemon {
                constructor(properties?: POGOProtos.Data.Beluga.IBelugaPokemon);
                public trainer_name: string;
                public trainer_gender: POGOProtos.Data.Beluga.BelugaPokemon.TrainerGender;
                public trainer_team: POGOProtos.Enums.TeamColor;
                public trainer_level: number;
                public pokedex_id: number;
                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.Enums.Gender;
                public costume: POGOProtos.Enums.Costume;
                public form: POGOProtos.Data.Beluga.BelugaPokemon.PokemonForm;
                public shiny: boolean;
                public move1: POGOProtos.Enums.PokemonMove;
                public move2: POGOProtos.Enums.PokemonMove;
                public static encode(message: POGOProtos.Data.Beluga.IBelugaPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Beluga.BelugaPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Beluga.BelugaPokemon;
                public static toObject(message: POGOProtos.Data.Beluga.BelugaPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BelugaPokemon {

                enum PokemonForm {
                    FORM_UNSET = 0,
                    ALOLA = 1
                }

                enum TrainerGender {
                    TRAINER_MALE = 0,
                    TRAINER_FEMALE = 1
                }
            }
        }

        interface IBuddyPokemon {
            id?: (number|Long|null);
            start_km_walked?: (number|null);
            last_km_awarded?: (number|null);
        }

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

        namespace Capture {

            interface ICaptureAward {
                activity_type?: (POGOProtos.Enums.ActivityType[]|null);
                xp?: (number[]|null);
                candy?: (number[]|null);
                stardust?: (number[]|null);
            }

            class CaptureAward implements ICaptureAward {
                constructor(properties?: POGOProtos.Data.Capture.ICaptureAward);
                public activity_type: POGOProtos.Enums.ActivityType[];
                public xp: number[];
                public candy: number[];
                public stardust: number[];
                public static encode(message: POGOProtos.Data.Capture.ICaptureAward, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Capture.CaptureAward;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Capture.CaptureAward;
                public static toObject(message: POGOProtos.Data.Capture.CaptureAward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICaptureProbability {
                pokeball_type?: (POGOProtos.Inventory.Item.ItemId[]|null);
                capture_probability?: (number[]|null);
                reticle_difficulty_scale?: (number|null);
            }

            class CaptureProbability implements ICaptureProbability {
                constructor(properties?: POGOProtos.Data.Capture.ICaptureProbability);
                public pokeball_type: POGOProtos.Inventory.Item.ItemId[];
                public capture_probability: number[];
                public reticle_difficulty_scale: number;
                public static encode(message: POGOProtos.Data.Capture.ICaptureProbability, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Capture.CaptureProbability;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Capture.CaptureProbability;
                public static toObject(message: POGOProtos.Data.Capture.CaptureProbability, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICaptureScore {
                activity_type?: (POGOProtos.Enums.ActivityType[]|null);
                exp?: (number[]|null);
                candy?: (number[]|null);
                stardust?: (number[]|null);
            }

            class CaptureScore implements ICaptureScore {
                constructor(properties?: POGOProtos.Data.Capture.ICaptureScore);
                public activity_type: POGOProtos.Enums.ActivityType[];
                public exp: number[];
                public candy: number[];
                public stardust: number[];
                public static encode(message: POGOProtos.Data.Capture.ICaptureScore, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Capture.CaptureScore;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Capture.CaptureScore;
                public static toObject(message: POGOProtos.Data.Capture.CaptureScore, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IClientVersion {
            min_version?: (string|null);
        }

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

        namespace Combat {

            interface IChallengePlayer {
                player_id?: (string|null);
                player_avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
                combat_player_s2_cell_id?: (number|Long|null);
                attacking_pokemon_id?: ((number|Long)[]|null);
            }

            class ChallengePlayer implements IChallengePlayer {
                constructor(properties?: POGOProtos.Data.Combat.IChallengePlayer);
                public player_id: string;
                public player_avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
                public combat_player_s2_cell_id: (number|Long);
                public attacking_pokemon_id: (number|Long)[];
                public static encode(message: POGOProtos.Data.Combat.IChallengePlayer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.ChallengePlayer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.ChallengePlayer;
                public static toObject(message: POGOProtos.Data.Combat.ChallengePlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombat {
                combat_state?: (POGOProtos.Data.Combat.Combat.CombatState|null);
                combat_id?: (string|null);
                player?: (POGOProtos.Data.Combat.ICombatPlayer|null);
                opponent?: (POGOProtos.Data.Combat.ICombatPlayer|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);
            }

            class Combat implements ICombat {
                constructor(properties?: POGOProtos.Data.Combat.ICombat);
                public combat_state: POGOProtos.Data.Combat.Combat.CombatState;
                public combat_id: string;
                public player?: (POGOProtos.Data.Combat.ICombatPlayer|null);
                public opponent?: (POGOProtos.Data.Combat.ICombatPlayer|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 static encode(message: POGOProtos.Data.Combat.ICombat, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.Combat;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.Combat;
                public static toObject(message: POGOProtos.Data.Combat.Combat, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Combat {

                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
                }
            }

            interface ICombatAction {
                type?: (POGOProtos.Data.Combat.CombatAction.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?: (number|null);
            }

            class CombatAction implements ICombatAction {
                constructor(properties?: POGOProtos.Data.Combat.ICombatAction);
                public type: POGOProtos.Data.Combat.CombatAction.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: number;
                public static encode(message: POGOProtos.Data.Combat.ICombatAction, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.CombatAction;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.CombatAction;
                public static toObject(message: POGOProtos.Data.Combat.CombatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CombatAction {

                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 ICombatChallenge {
                challenge_id?: (string|null);
                type?: (POGOProtos.Enums.CombatType|null);
                combat_league_template_id?: (string|null);
                challenger?: (POGOProtos.Data.Combat.IChallengePlayer|null);
                opponent?: (POGOProtos.Data.Combat.IChallengePlayer|null);
                state?: (POGOProtos.Data.Combat.CombatChallenge.CombatChallengeState|null);
                created_timestamp_ms?: (number|Long|null);
                expiration_timestamp_ms?: (number|Long|null);
                combat_id?: (string|null);
            }

            class CombatChallenge implements ICombatChallenge {
                constructor(properties?: POGOProtos.Data.Combat.ICombatChallenge);
                public challenge_id: string;
                public type: POGOProtos.Enums.CombatType;
                public combat_league_template_id: string;
                public challenger?: (POGOProtos.Data.Combat.IChallengePlayer|null);
                public opponent?: (POGOProtos.Data.Combat.IChallengePlayer|null);
                public state: POGOProtos.Data.Combat.CombatChallenge.CombatChallengeState;
                public created_timestamp_ms: (number|Long);
                public expiration_timestamp_ms: (number|Long);
                public combat_id: string;
                public static encode(message: POGOProtos.Data.Combat.ICombatChallenge, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.CombatChallenge;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.CombatChallenge;
                public static toObject(message: POGOProtos.Data.Combat.CombatChallenge, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CombatChallenge {

                enum CombatChallengeState {
                    UNSET = 0,
                    CREATED = 1,
                    OPENED = 2,
                    CANCELLED = 3,
                    ACCEPTED = 4,
                    DECLINED = 5,
                    READY = 6,
                    TIMEOUT = 7
                }
            }

            interface ICombatMoveBuffs {
                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 CombatMoveBuffs implements ICombatMoveBuffs {
                constructor(properties?: POGOProtos.Data.Combat.ICombatMoveBuffs);
                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.Data.Combat.ICombatMoveBuffs, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.CombatMoveBuffs;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.CombatMoveBuffs;
                public static toObject(message: POGOProtos.Data.Combat.CombatMoveBuffs, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPlayer {
                public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                active_pokemon?: (POGOProtos.Data.Combat.ICombatPokemon|null);
                reserve_pokemon?: (POGOProtos.Data.Combat.ICombatPokemon[]|null);
                fainted_pokemon?: (POGOProtos.Data.Combat.ICombatPokemon[]|null);
                current_action?: (POGOProtos.Data.Combat.ICombatAction|null);
                lockstep_ack?: (boolean|null);
                last_updated_turn?: (number|null);
                minigame_action?: (POGOProtos.Data.Combat.ICombatAction|null);
                quick_swap_available_ms?: (number|Long|null);
                minigame_defense_chances_left?: (number|null);
            }

            class CombatPlayer implements ICombatPlayer {
                constructor(properties?: POGOProtos.Data.Combat.ICombatPlayer);
                public public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public active_pokemon?: (POGOProtos.Data.Combat.ICombatPokemon|null);
                public reserve_pokemon: POGOProtos.Data.Combat.ICombatPokemon[];
                public fainted_pokemon: POGOProtos.Data.Combat.ICombatPokemon[];
                public current_action?: (POGOProtos.Data.Combat.ICombatAction|null);
                public lockstep_ack: boolean;
                public last_updated_turn: number;
                public minigame_action?: (POGOProtos.Data.Combat.ICombatAction|null);
                public quick_swap_available_ms: (number|Long);
                public minigame_defense_chances_left: number;
                public static encode(message: POGOProtos.Data.Combat.ICombatPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.CombatPlayer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.CombatPlayer;
                public static toObject(message: POGOProtos.Data.Combat.CombatPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPlayerPreferences {
                friends_combat_opt_out?: (boolean|null);
                nearby_combat_opt_in?: (boolean|null);
            }

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

            interface ICombatPlayerProfile {
                player_id?: (string|null);
                public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                combat_league_template_id?: (string[]|null);
                buddy_pokemon_id?: (number|Long|null);
                location?: (POGOProtos.Data.ILocation|null);
                combat_player_preferences?: (POGOProtos.Data.Combat.ICombatPlayerPreferences|null);
            }

            class CombatPlayerProfile implements ICombatPlayerProfile {
                constructor(properties?: POGOProtos.Data.Combat.ICombatPlayerProfile);
                public player_id: string;
                public public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public combat_league_template_id: string[];
                public buddy_pokemon_id: (number|Long);
                public location?: (POGOProtos.Data.ILocation|null);
                public combat_player_preferences?: (POGOProtos.Data.Combat.ICombatPlayerPreferences|null);
                public static encode(message: POGOProtos.Data.Combat.ICombatPlayerProfile, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.CombatPlayerProfile;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.CombatPlayerProfile;
                public static toObject(message: POGOProtos.Data.Combat.CombatPlayerProfile, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatPokemon {
                pokemon_id?: (number|Long|null);
                pokedex_id?: (POGOProtos.Enums.PokemonId|null);
                cp?: (number|null);
                cp_multiplier?: (number|null);
                stamina?: (number|null);
                max_stamina?: (number|null);
                move1?: (POGOProtos.Enums.PokemonMove|null);
                move2?: (POGOProtos.Enums.PokemonMove|null);
                move3?: (POGOProtos.Enums.PokemonMove|null);
                energy?: (number|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|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.Inventory.Item.ItemId|null);
            }

            class CombatPokemon implements ICombatPokemon {
                constructor(properties?: POGOProtos.Data.Combat.ICombatPokemon);
                public pokemon_id: (number|Long);
                public pokedex_id: POGOProtos.Enums.PokemonId;
                public cp: number;
                public cp_multiplier: number;
                public stamina: number;
                public max_stamina: number;
                public move1: POGOProtos.Enums.PokemonMove;
                public move2: POGOProtos.Enums.PokemonMove;
                public move3: POGOProtos.Enums.PokemonMove;
                public energy: number;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|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.Inventory.Item.ItemId;
                public static encode(message: POGOProtos.Data.Combat.ICombatPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.CombatPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.CombatPokemon;
                public static toObject(message: POGOProtos.Data.Combat.CombatPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerCombatStats {
            }

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

            namespace PlayerCombatStats {

                interface IPlayerCombatBadgeStatsProto {
                    num_won?: (number|null);
                    num_total?: (number|null);
                }

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

            interface IPokemonCombatStats {
                num_won?: (number|null);
                num_total?: (number|null);
            }

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

            interface IPokemonCondition {
                type?: (POGOProtos.Enums.ConditionType|null);
                with_pokemon_cp_limit?: (POGOProtos.Data.Combat.IWithPokemonCpLimit|null);
                with_pokemon_type?: (POGOProtos.Data.Combat.IWithPokemonType|null);
                with_pokemon_category?: (POGOProtos.Data.Combat.IWithPokemonCategory|null);
            }

            class PokemonCondition implements IPokemonCondition {
                constructor(properties?: POGOProtos.Data.Combat.IPokemonCondition);
                public type: POGOProtos.Enums.ConditionType;
                public with_pokemon_cp_limit?: (POGOProtos.Data.Combat.IWithPokemonCpLimit|null);
                public with_pokemon_type?: (POGOProtos.Data.Combat.IWithPokemonType|null);
                public with_pokemon_category?: (POGOProtos.Data.Combat.IWithPokemonCategory|null);
                public static encode(message: POGOProtos.Data.Combat.IPokemonCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.PokemonCondition;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.PokemonCondition;
                public static toObject(message: POGOProtos.Data.Combat.PokemonCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IUnlockCondition {
                type?: (POGOProtos.Enums.ConditionType|null);
                min_pokemon_count?: (number|null);
                with_player_level?: (POGOProtos.Data.Combat.IWithPlayerLevel|null);
                with_pokemon_cp_limit?: (POGOProtos.Data.Combat.IWithPokemonCpLimit|null);
                with_pokemon_type?: (POGOProtos.Data.Combat.IWithPokemonType|null);
                with_pokemon_category?: (POGOProtos.Data.Combat.IWithPokemonCategory|null);
            }

            class UnlockCondition implements IUnlockCondition {
                constructor(properties?: POGOProtos.Data.Combat.IUnlockCondition);
                public type: POGOProtos.Enums.ConditionType;
                public min_pokemon_count: number;
                public with_player_level?: (POGOProtos.Data.Combat.IWithPlayerLevel|null);
                public with_pokemon_cp_limit?: (POGOProtos.Data.Combat.IWithPokemonCpLimit|null);
                public with_pokemon_type?: (POGOProtos.Data.Combat.IWithPokemonType|null);
                public with_pokemon_category?: (POGOProtos.Data.Combat.IWithPokemonCategory|null);
                public static encode(message: POGOProtos.Data.Combat.IUnlockCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.UnlockCondition;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.UnlockCondition;
                public static toObject(message: POGOProtos.Data.Combat.UnlockCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWithPlayerLevel {
                level?: (number|null);
            }

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

            interface IWithPokemonCategory {
                category_name?: (string|null);
                pokemon_ids?: (POGOProtos.Enums.PokemonType[]|null);
            }

            class WithPokemonCategory implements IWithPokemonCategory {
                constructor(properties?: POGOProtos.Data.Combat.IWithPokemonCategory);
                public category_name: string;
                public pokemon_ids: POGOProtos.Enums.PokemonType[];
                public static encode(message: POGOProtos.Data.Combat.IWithPokemonCategory, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Combat.WithPokemonCategory;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Combat.WithPokemonCategory;
                public static toObject(message: POGOProtos.Data.Combat.WithPokemonCategory, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWithPokemonCpLimit {
                min_cp?: (number|null);
                max_cp?: (number|null);
            }

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

            interface IWithPokemonType {
                pokemon_type?: (POGOProtos.Enums.PokemonType[]|null);
            }

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

        interface IDamageProperty {
            super_effective_charge_move?: (boolean|null);
            weather_boosted?: (boolean|null);
        }

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

        namespace Ditto {

            interface IChannelAuthEventParams {
                status?: (number|null);
            }

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

            interface IDownstreamActionEventParams {
                methods?: (number[]|null);
                payloads?: (Uint8Array[]|null);
                ids?: ((number|Long)[]|null);
            }

            class DownstreamActionEventParams implements IDownstreamActionEventParams {
                constructor(properties?: POGOProtos.Data.Ditto.IDownstreamActionEventParams);
                public methods: number[];
                public payloads: Uint8Array[];
                public ids: (number|Long)[];
                public static encode(message: POGOProtos.Data.Ditto.IDownstreamActionEventParams, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Ditto.DownstreamActionEventParams;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Ditto.DownstreamActionEventParams;
                public static toObject(message: POGOProtos.Data.Ditto.DownstreamActionEventParams, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGoogleAuthEventParams {
                payload?: (string|null);
                account_name?: (string|null);
            }

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

            interface ILocationUpdateEventParams {
                latitude_deg?: (number|null);
                longitude_deg?: (number|null);
                altitude_m?: (number|null);
                accuracy_m?: (number|null);
                timestamp_s?: (number|null);
                provider_status?: (number|null);
                location_type?: (number|null);
            }

            class LocationUpdateEventParams implements ILocationUpdateEventParams {
                constructor(properties?: POGOProtos.Data.Ditto.ILocationUpdateEventParams);
                public latitude_deg: number;
                public longitude_deg: number;
                public altitude_m: number;
                public accuracy_m: number;
                public timestamp_s: number;
                public provider_status: number;
                public location_type: number;
                public static encode(message: POGOProtos.Data.Ditto.ILocationUpdateEventParams, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Ditto.LocationUpdateEventParams;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Ditto.LocationUpdateEventParams;
                public static toObject(message: POGOProtos.Data.Ditto.LocationUpdateEventParams, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRpcResponseEventParams {
                rpc_id?: (number|null);
                status?: (number|null);
                payloads?: (Uint8Array[]|null);
            }

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

            interface ISyncRequestedEventParams {
            }

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

        interface IDownloadUrlEntry {
            asset_id?: (string|null);
            url?: (string|null);
            size?: (number|null);
            checksum?: (number|null);
        }

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

        namespace Fitness {

            interface IFitnessMetrics {
                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 FitnessMetrics implements IFitnessMetrics {
                constructor(properties?: POGOProtos.Data.Fitness.IFitnessMetrics);
                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.Data.Fitness.IFitnessMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessMetrics;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessMetrics;
                public static toObject(message: POGOProtos.Data.Fitness.FitnessMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFitnessMetricsReportHistory {
                weekly_history?: (POGOProtos.Data.Fitness.FitnessMetricsReportHistory.IMetricsHistory[]|null);
                daily_history?: (POGOProtos.Data.Fitness.FitnessMetricsReportHistory.IMetricsHistory[]|null);
            }

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

            namespace FitnessMetricsReportHistory {

                interface IMetricsHistory {
                    bucket?: (number|Long|null);
                    metrics?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                }

                class MetricsHistory implements IMetricsHistory {
                    constructor(properties?: POGOProtos.Data.Fitness.FitnessMetricsReportHistory.IMetricsHistory);
                    public bucket: (number|Long);
                    public metrics?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                    public static encode(message: POGOProtos.Data.Fitness.FitnessMetricsReportHistory.IMetricsHistory, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessMetricsReportHistory.MetricsHistory;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessMetricsReportHistory.MetricsHistory;
                    public static toObject(message: POGOProtos.Data.Fitness.FitnessMetricsReportHistory.MetricsHistory, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IFitnessRecord {
                hourly_reports?: (POGOProtos.Data.Fitness.FitnessRecord.IHourlyReportsEntry[]|null);
                raw_samples?: (POGOProtos.Data.Fitness.IFitnessSample[]|null);
                last_aggregation_timestamp_ms?: (number|Long|null);
                fitness_stats?: (POGOProtos.Data.Fitness.IFitnessStats|null);
                report_history?: (POGOProtos.Data.Fitness.IFitnessMetricsReportHistory|null);
            }

            class FitnessRecord implements IFitnessRecord {
                constructor(properties?: POGOProtos.Data.Fitness.IFitnessRecord);
                public hourly_reports: POGOProtos.Data.Fitness.FitnessRecord.IHourlyReportsEntry[];
                public raw_samples: POGOProtos.Data.Fitness.IFitnessSample[];
                public last_aggregation_timestamp_ms: (number|Long);
                public fitness_stats?: (POGOProtos.Data.Fitness.IFitnessStats|null);
                public report_history?: (POGOProtos.Data.Fitness.IFitnessMetricsReportHistory|null);
                public static encode(message: POGOProtos.Data.Fitness.IFitnessRecord, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessRecord;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessRecord;
                public static toObject(message: POGOProtos.Data.Fitness.FitnessRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FitnessRecord {

                interface IHourlyReportsEntry {
                    key?: (number|Long|null);
                    value?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                }

                class HourlyReportsEntry implements IHourlyReportsEntry {
                    constructor(properties?: POGOProtos.Data.Fitness.FitnessRecord.IHourlyReportsEntry);
                    public key: (number|Long);
                    public value?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                    public static encode(message: POGOProtos.Data.Fitness.FitnessRecord.IHourlyReportsEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessRecord.HourlyReportsEntry;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessRecord.HourlyReportsEntry;
                    public static toObject(message: POGOProtos.Data.Fitness.FitnessRecord.HourlyReportsEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IFitnessReport {
                day_offset_from_now?: (number|null);
                week_offset_from_now?: (number|null);
                metrics?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                game_data?: (Uint8Array|null);
            }

            class FitnessReport implements IFitnessReport {
                constructor(properties?: POGOProtos.Data.Fitness.IFitnessReport);
                public day_offset_from_now: number;
                public week_offset_from_now: number;
                public metrics?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                public game_data: Uint8Array;
                public Window?: ("day_offset_from_now"|"week_offset_from_now");
                public static encode(message: POGOProtos.Data.Fitness.IFitnessReport, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessReport;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessReport;
                public static toObject(message: POGOProtos.Data.Fitness.FitnessReport, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFitnessSample {
                sample_type?: (POGOProtos.Data.Fitness.FitnessSample.FitnessSampleType|null);
                sample_start_timestamp_ms?: (number|Long|null);
                sample_end_timestamp_ms?: (number|Long|null);
                value?: (number|null);
                source_type?: (POGOProtos.Data.Fitness.FitnessSample.FitnessSourceType|null);
            }

            class FitnessSample implements IFitnessSample {
                constructor(properties?: POGOProtos.Data.Fitness.IFitnessSample);
                public sample_type: POGOProtos.Data.Fitness.FitnessSample.FitnessSampleType;
                public sample_start_timestamp_ms: (number|Long);
                public sample_end_timestamp_ms: (number|Long);
                public value: number;
                public source_type: POGOProtos.Data.Fitness.FitnessSample.FitnessSourceType;
                public static encode(message: POGOProtos.Data.Fitness.IFitnessSample, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessSample;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessSample;
                public static toObject(message: POGOProtos.Data.Fitness.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
                }
            }

            interface IFitnessStats {
                last_accumulated_timestamp_ms?: (number|Long|null);
                accumulated?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                pending?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                player_initial_walk_km?: (number|null);
                player_total_walk_km?: (number|null);
            }

            class FitnessStats implements IFitnessStats {
                constructor(properties?: POGOProtos.Data.Fitness.IFitnessStats);
                public last_accumulated_timestamp_ms: (number|Long);
                public accumulated?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                public pending?: (POGOProtos.Data.Fitness.IFitnessMetrics|null);
                public player_initial_walk_km: number;
                public player_total_walk_km: number;
                public static encode(message: POGOProtos.Data.Fitness.IFitnessStats, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.FitnessStats;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.FitnessStats;
                public static toObject(message: POGOProtos.Data.Fitness.FitnessStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IHoloFitnessReport {
                num_eggs_hatched?: (number|null);
                num_buddy_candy_earned?: (number|null);
                distance_walked_km?: (number|null);
                week_bucket?: (number|Long|null);
            }

            class HoloFitnessReport implements IHoloFitnessReport {
                constructor(properties?: POGOProtos.Data.Fitness.IHoloFitnessReport);
                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.Data.Fitness.IHoloFitnessReport, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Fitness.HoloFitnessReport;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Fitness.HoloFitnessReport;
                public static toObject(message: POGOProtos.Data.Fitness.HoloFitnessReport, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IFoodValue {
            motivation_increase?: (number|null);
            cp_increase?: (number|null);
            food_item?: (POGOProtos.Inventory.Item.ItemId|null);
        }

        class FoodValue implements IFoodValue {
            constructor(properties?: POGOProtos.Data.IFoodValue);
            public motivation_increase: number;
            public cp_increase: number;
            public food_item: POGOProtos.Inventory.Item.ItemId;
            public static encode(message: POGOProtos.Data.IFoodValue, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.FoodValue;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.FoodValue;
            public static toObject(message: POGOProtos.Data.FoodValue, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Friends {

            interface IFriend {
                player_id?: (string|null);
                codename?: (string|null);
                team?: (string|null);
                score?: (number|null);
                data_with_me?: (Uint8Array|null);
                version?: (number|Long|null);
                created_ms?: (number|Long|null);
                fb_user_id?: (string|null);
                is_facebook_friendship?: (boolean|null);
            }

            class Friend implements IFriend {
                constructor(properties?: POGOProtos.Data.Friends.IFriend);
                public player_id: string;
                public codename: string;
                public team: string;
                public score: number;
                public data_with_me: Uint8Array;
                public version: (number|Long);
                public created_ms: (number|Long);
                public fb_user_id: string;
                public is_facebook_friendship: boolean;
                public static encode(message: POGOProtos.Data.Friends.IFriend, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.Friend;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.Friend;
                public static toObject(message: POGOProtos.Data.Friends.Friend, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFriendDetails {
                player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                friend_visible_data?: (Uint8Array|null);
                score?: (number|null);
                data_with_me?: (Uint8Array|null);
            }

            class FriendDetails implements IFriendDetails {
                constructor(properties?: POGOProtos.Data.Friends.IFriendDetails);
                public player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                public friend_visible_data: Uint8Array;
                public score: number;
                public data_with_me: Uint8Array;
                public static encode(message: POGOProtos.Data.Friends.IFriendDetails, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.FriendDetails;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.FriendDetails;
                public static toObject(message: POGOProtos.Data.Friends.FriendDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFriendshipData {
                friendship_level_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                giftbox_details?: (POGOProtos.Data.Gift.IGiftBoxDetails[]|null);
                codename?: (string|null);
                nickname?: (string|null);
                open_trade_expire_ms?: (number|Long|null);
            }

            class FriendshipData implements IFriendshipData {
                constructor(properties?: POGOProtos.Data.Friends.IFriendshipData);
                public friendship_level_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                public giftbox_details: POGOProtos.Data.Gift.IGiftBoxDetails[];
                public codename: string;
                public nickname: string;
                public open_trade_expire_ms: (number|Long);
                public static encode(message: POGOProtos.Data.Friends.IFriendshipData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.FriendshipData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.FriendshipData;
                public static toObject(message: POGOProtos.Data.Friends.FriendshipData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFriendshipLevelData {
                bucket?: (number|Long|null);
                points_earned_today?: (number|null);
                awarded_friendship_milestone?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
                current_friendship_milestone?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
                next_friendship_milestone_progress_percentage?: (number|null);
                points_toward_next_milestone?: (number|null);
            }

            class FriendshipLevelData implements IFriendshipLevelData {
                constructor(properties?: POGOProtos.Data.Friends.IFriendshipLevelData);
                public bucket: (number|Long);
                public points_earned_today: number;
                public awarded_friendship_milestone: POGOProtos.Enums.FriendshipLevelMilestone;
                public current_friendship_milestone: POGOProtos.Enums.FriendshipLevelMilestone;
                public next_friendship_milestone_progress_percentage: number;
                public points_toward_next_milestone: number;
                public static encode(message: POGOProtos.Data.Friends.IFriendshipLevelData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.FriendshipLevelData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.FriendshipLevelData;
                public static toObject(message: POGOProtos.Data.Friends.FriendshipLevelData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFriendshipMilestoneReward {
                friend_id?: (string|null);
                friendship_milestone?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
            }

            class FriendshipMilestoneReward implements IFriendshipMilestoneReward {
                constructor(properties?: POGOProtos.Data.Friends.IFriendshipMilestoneReward);
                public friend_id: string;
                public friendship_milestone: POGOProtos.Enums.FriendshipLevelMilestone;
                public static encode(message: POGOProtos.Data.Friends.IFriendshipMilestoneReward, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.FriendshipMilestoneReward;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.FriendshipMilestoneReward;
                public static toObject(message: POGOProtos.Data.Friends.FriendshipMilestoneReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFriendshipMilestoneRewardNotification {
                friend_id?: (string|null);
                friend_codename?: (string|null);
                friendship_milestone_level?: (number|null);
                xp_reward?: (number|Long|null);
            }

            class FriendshipMilestoneRewardNotification implements IFriendshipMilestoneRewardNotification {
                constructor(properties?: POGOProtos.Data.Friends.IFriendshipMilestoneRewardNotification);
                public friend_id: string;
                public friend_codename: string;
                public friendship_milestone_level: number;
                public xp_reward: (number|Long);
                public static encode(message: POGOProtos.Data.Friends.IFriendshipMilestoneRewardNotification, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.FriendshipMilestoneRewardNotification;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.FriendshipMilestoneRewardNotification;
                public static toObject(message: POGOProtos.Data.Friends.FriendshipMilestoneRewardNotification, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IIncomingFriendInvite {
                status?: (POGOProtos.Data.Friends.IncomingFriendInvite.Status|null);
                player_id?: (string|null);
                created_ms?: (number|Long|null);
                invitation_type?: (POGOProtos.Enums.InvitationType|null);
                full_name?: (string|null);
            }

            class IncomingFriendInvite implements IIncomingFriendInvite {
                constructor(properties?: POGOProtos.Data.Friends.IIncomingFriendInvite);
                public status: POGOProtos.Data.Friends.IncomingFriendInvite.Status;
                public player_id: string;
                public created_ms: (number|Long);
                public invitation_type: POGOProtos.Enums.InvitationType;
                public full_name: string;
                public static encode(message: POGOProtos.Data.Friends.IIncomingFriendInvite, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.IncomingFriendInvite;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.IncomingFriendInvite;
                public static toObject(message: POGOProtos.Data.Friends.IncomingFriendInvite, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace IncomingFriendInvite {

                enum Status {
                    UNSET = 0,
                    PENDING = 1,
                    DECLINED = 2,
                    CANCELLED = 3
                }
            }

            interface IIncomingFriendInviteDisplay {
                invite?: (POGOProtos.Data.Friends.IIncomingFriendInvite|null);
                player?: (POGOProtos.Data.Player.IPlayerSummary|null);
            }

            class IncomingFriendInviteDisplay implements IIncomingFriendInviteDisplay {
                constructor(properties?: POGOProtos.Data.Friends.IIncomingFriendInviteDisplay);
                public invite?: (POGOProtos.Data.Friends.IIncomingFriendInvite|null);
                public player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                public static encode(message: POGOProtos.Data.Friends.IIncomingFriendInviteDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.IncomingFriendInviteDisplay;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.IncomingFriendInviteDisplay;
                public static toObject(message: POGOProtos.Data.Friends.IncomingFriendInviteDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ILeveledUpFriends {
                friend_profiles?: (POGOProtos.Data.Player.IPlayerPublicProfile[]|null);
                friend_milestone_levels?: (POGOProtos.Data.Friends.IFriendshipLevelData[]|null);
            }

            class LeveledUpFriends implements ILeveledUpFriends {
                constructor(properties?: POGOProtos.Data.Friends.ILeveledUpFriends);
                public friend_profiles: POGOProtos.Data.Player.IPlayerPublicProfile[];
                public friend_milestone_levels: POGOProtos.Data.Friends.IFriendshipLevelData[];
                public static encode(message: POGOProtos.Data.Friends.ILeveledUpFriends, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.LeveledUpFriends;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.LeveledUpFriends;
                public static toObject(message: POGOProtos.Data.Friends.LeveledUpFriends, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOutgoingFriendInvite {
                status?: (POGOProtos.Data.Friends.OutgoingFriendInvite.Status|null);
                player_id?: (string|null);
                created_ms?: (number|Long|null);
                invitation_type?: (POGOProtos.Enums.InvitationType|null);
                full_name?: (string|null);
            }

            class OutgoingFriendInvite implements IOutgoingFriendInvite {
                constructor(properties?: POGOProtos.Data.Friends.IOutgoingFriendInvite);
                public status: POGOProtos.Data.Friends.OutgoingFriendInvite.Status;
                public player_id: string;
                public created_ms: (number|Long);
                public invitation_type: POGOProtos.Enums.InvitationType;
                public full_name: string;
                public static encode(message: POGOProtos.Data.Friends.IOutgoingFriendInvite, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.OutgoingFriendInvite;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.OutgoingFriendInvite;
                public static toObject(message: POGOProtos.Data.Friends.OutgoingFriendInvite, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace OutgoingFriendInvite {

                enum Status {
                    UNSET = 0,
                    PENDING = 1,
                    CANCELLED = 2,
                    DECLINED = 3
                }
            }

            interface IOutgoingFriendInviteDisplay {
                invite?: (POGOProtos.Data.Friends.IOutgoingFriendInvite|null);
                player?: (POGOProtos.Data.Player.IPlayerSummary|null);
            }

            class OutgoingFriendInviteDisplay implements IOutgoingFriendInviteDisplay {
                constructor(properties?: POGOProtos.Data.Friends.IOutgoingFriendInviteDisplay);
                public invite?: (POGOProtos.Data.Friends.IOutgoingFriendInvite|null);
                public player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                public static encode(message: POGOProtos.Data.Friends.IOutgoingFriendInviteDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.OutgoingFriendInviteDisplay;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.OutgoingFriendInviteDisplay;
                public static toObject(message: POGOProtos.Data.Friends.OutgoingFriendInviteDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerFriendDisplay {
                buddy?: (POGOProtos.Data.IPokemonDisplay|null);
                buddy_display_pokemon_id?: (number|null);
                buddy_pokemon_nickname?: (string|null);
                last_pokemon_caught?: (POGOProtos.Data.IPokemonDisplay|null);
                last_pokemon_caught_display_id?: (number|null);
                last_pokemon_caught_timestamp?: (number|Long|null);
                buddy_candy_awarded?: (number|null);
            }

            class PlayerFriendDisplay implements IPlayerFriendDisplay {
                constructor(properties?: POGOProtos.Data.Friends.IPlayerFriendDisplay);
                public buddy?: (POGOProtos.Data.IPokemonDisplay|null);
                public buddy_display_pokemon_id: number;
                public buddy_pokemon_nickname: string;
                public last_pokemon_caught?: (POGOProtos.Data.IPokemonDisplay|null);
                public last_pokemon_caught_display_id: number;
                public last_pokemon_caught_timestamp: (number|Long);
                public buddy_candy_awarded: number;
                public static encode(message: POGOProtos.Data.Friends.IPlayerFriendDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Friends.PlayerFriendDisplay;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Friends.PlayerFriendDisplay;
                public static toObject(message: POGOProtos.Data.Friends.PlayerFriendDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Geofence {

            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.Data.Geofence.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.Data.Geofence.IGeofenceMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Geofence.GeofenceMetadata;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Geofence.GeofenceMetadata;
                public static toObject(message: POGOProtos.Data.Geofence.GeofenceMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IGetActionLogRequest {
        }

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

        namespace Gift {

            interface IGiftBox {
                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);
            }

            class GiftBox implements IGiftBox {
                constructor(properties?: POGOProtos.Data.Gift.IGiftBox);
                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 static encode(message: POGOProtos.Data.Gift.IGiftBox, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gift.GiftBox;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gift.GiftBox;
                public static toObject(message: POGOProtos.Data.Gift.GiftBox, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGiftBoxDetails {
                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);
            }

            class GiftBoxDetails implements IGiftBoxDetails {
                constructor(properties?: POGOProtos.Data.Gift.IGiftBoxDetails);
                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 static encode(message: POGOProtos.Data.Gift.IGiftBoxDetails, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gift.GiftBoxDetails;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gift.GiftBoxDetails;
                public static toObject(message: POGOProtos.Data.Gift.GiftBoxDetails, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGiftBoxes {
                gifts?: (POGOProtos.Data.Gift.IGiftBox[]|null);
            }

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

        namespace Gym {

            interface IGymBattle {
                battle_id?: (string|null);
                completed_ms?: (number|Long|null);
                incremented_gym_battle_friends?: (boolean|null);
            }

            class GymBattle implements IGymBattle {
                constructor(properties?: POGOProtos.Data.Gym.IGymBattle);
                public battle_id: string;
                public completed_ms: (number|Long);
                public incremented_gym_battle_friends: boolean;
                public static encode(message: POGOProtos.Data.Gym.IGymBattle, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gym.GymBattle;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gym.GymBattle;
                public static toObject(message: POGOProtos.Data.Gym.GymBattle, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymDefender {
                motivated_pokemon?: (POGOProtos.Map.Pokemon.IMotivatedPokemon|null);
                deployment_totals?: (POGOProtos.Data.Gym.GymDefender.IDeploymentTotals|null);
                trainer_public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
            }

            class GymDefender implements IGymDefender {
                constructor(properties?: POGOProtos.Data.Gym.IGymDefender);
                public motivated_pokemon?: (POGOProtos.Map.Pokemon.IMotivatedPokemon|null);
                public deployment_totals?: (POGOProtos.Data.Gym.GymDefender.IDeploymentTotals|null);
                public trainer_public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public static encode(message: POGOProtos.Data.Gym.IGymDefender, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gym.GymDefender;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gym.GymDefender;
                public static toObject(message: POGOProtos.Data.Gym.GymDefender, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymDefender {

                interface IDeploymentTotals {
                    times_fed?: (number|null);
                    battles_won?: (number|null);
                    battles_lost?: (number|null);
                    deployment_duration_ms?: (number|Long|null);
                }

                class DeploymentTotals implements IDeploymentTotals {
                    constructor(properties?: POGOProtos.Data.Gym.GymDefender.IDeploymentTotals);
                    public times_fed: number;
                    public battles_won: number;
                    public battles_lost: number;
                    public deployment_duration_ms: (number|Long);
                    public static encode(message: POGOProtos.Data.Gym.GymDefender.IDeploymentTotals, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gym.GymDefender.DeploymentTotals;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gym.GymDefender.DeploymentTotals;
                    public static toObject(message: POGOProtos.Data.Gym.GymDefender.DeploymentTotals, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IGymMembership {
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                trainer_public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                training_pokemon?: (POGOProtos.Data.IPokemonData|null);
            }

            class GymMembership implements IGymMembership {
                constructor(properties?: POGOProtos.Data.Gym.IGymMembership);
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public trainer_public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public training_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public static encode(message: POGOProtos.Data.Gym.IGymMembership, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gym.GymMembership;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gym.GymMembership;
                public static toObject(message: POGOProtos.Data.Gym.GymMembership, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymState {
                fort_data?: (POGOProtos.Map.Fort.IFortData|null);
                memberships?: (POGOProtos.Data.Gym.IGymMembership[]|null);
                deploy_lockout?: (boolean|null);
            }

            class GymState implements IGymState {
                constructor(properties?: POGOProtos.Data.Gym.IGymState);
                public fort_data?: (POGOProtos.Map.Fort.IFortData|null);
                public memberships: POGOProtos.Data.Gym.IGymMembership[];
                public deploy_lockout: boolean;
                public static encode(message: POGOProtos.Data.Gym.IGymState, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gym.GymState;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gym.GymState;
                public static toObject(message: POGOProtos.Data.Gym.GymState, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymStatusAndDefenders {
                pokemon_fort_proto?: (POGOProtos.Map.Fort.IFortData|null);
                gym_defender?: (POGOProtos.Data.Gym.IGymDefender[]|null);
            }

            class GymStatusAndDefenders implements IGymStatusAndDefenders {
                constructor(properties?: POGOProtos.Data.Gym.IGymStatusAndDefenders);
                public pokemon_fort_proto?: (POGOProtos.Map.Fort.IFortData|null);
                public gym_defender: POGOProtos.Data.Gym.IGymDefender[];
                public static encode(message: POGOProtos.Data.Gym.IGymStatusAndDefenders, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Gym.GymStatusAndDefenders;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Gym.GymStatusAndDefenders;
                public static toObject(message: POGOProtos.Data.Gym.GymStatusAndDefenders, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Inbox {

            interface IClientInbox {
                notifications?: (POGOProtos.Data.Inbox.ClientInbox.INotification[]|null);
                builtin_variables?: (POGOProtos.Data.Inbox.ClientInbox.ITemplateVariable[]|null);
            }

            class ClientInbox implements IClientInbox {
                constructor(properties?: POGOProtos.Data.Inbox.IClientInbox);
                public notifications: POGOProtos.Data.Inbox.ClientInbox.INotification[];
                public builtin_variables: POGOProtos.Data.Inbox.ClientInbox.ITemplateVariable[];
                public static encode(message: POGOProtos.Data.Inbox.IClientInbox, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Inbox.ClientInbox;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Inbox.ClientInbox;
                public static toObject(message: POGOProtos.Data.Inbox.ClientInbox, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ClientInbox {

                interface INotification {
                    notification_id?: (string|null);
                    title_key?: (string|null);
                    category?: (string|null);
                    create_timestamp_ms?: (number|Long|null);
                    variables?: (POGOProtos.Data.Inbox.ClientInbox.ITemplateVariable[]|null);
                    labels?: (POGOProtos.Data.Inbox.ClientInbox.Notification.Label[]|null);
                    expire_time_ms?: (number|Long|null);
                }

                class Notification implements INotification {
                    constructor(properties?: POGOProtos.Data.Inbox.ClientInbox.INotification);
                    public notification_id: string;
                    public title_key: string;
                    public category: string;
                    public create_timestamp_ms: (number|Long);
                    public variables: POGOProtos.Data.Inbox.ClientInbox.ITemplateVariable[];
                    public labels: POGOProtos.Data.Inbox.ClientInbox.Notification.Label[];
                    public expire_time_ms: (number|Long);
                    public static encode(message: POGOProtos.Data.Inbox.ClientInbox.INotification, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Inbox.ClientInbox.Notification;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Inbox.ClientInbox.Notification;
                    public static toObject(message: POGOProtos.Data.Inbox.ClientInbox.Notification, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace Notification {

                    enum Label {
                        UNSET_LABEL = 0,
                        UNREAD = 1,
                        NEW = 2,
                        IMMEDIATE = 3
                    }
                }

                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.Data.Inbox.ClientInbox.ITemplateVariable);
                    public name: string;
                    public literal: string;
                    public key: string;
                    public lookup_table: string;
                    public byte_value: Uint8Array;
                    public static encode(message: POGOProtos.Data.Inbox.ClientInbox.ITemplateVariable, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Inbox.ClientInbox.TemplateVariable;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Inbox.ClientInbox.TemplateVariable;
                    public static toObject(message: POGOProtos.Data.Inbox.ClientInbox.TemplateVariable, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        interface ILocation {
            lat_degree?: (number|null);
            lng_degree?: (number|null);
        }

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

        namespace Login {

            interface ILoginDetail {
                identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                email?: (string|null);
            }

            class LoginDetail implements ILoginDetail {
                constructor(properties?: POGOProtos.Data.Login.ILoginDetail);
                public identity_provider: POGOProtos.Enums.IdentityProvider;
                public email: string;
                public static encode(message: POGOProtos.Data.Login.ILoginDetail, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Login.LoginDetail;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Login.LoginDetail;
                public static toObject(message: POGOProtos.Data.Login.LoginDetail, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Logs {

            interface IActionLogEntry {
                timestamp_ms?: (number|Long|null);
                sfida?: (boolean|null);
                catch_pokemon?: (POGOProtos.Data.Logs.ICatchPokemonLogEntry|null);
                fort_search?: (POGOProtos.Data.Logs.IFortSearchLogEntry|null);
                buddy_pokemon?: (POGOProtos.Data.Logs.IBuddyPokemonLogEntry|null);
                raid_rewards?: (POGOProtos.Data.Logs.IRaidRewardsLogEntry|null);
                passcode_rewards?: (POGOProtos.Data.Logs.IPasscodeRewardsLogEntry|null);
                complete_quest?: (POGOProtos.Data.Logs.ICompleteQuestLogEntry|null);
                complete_quest_stamp_card?: (POGOProtos.Data.Logs.ICompleteQuestStampCardLogEntry|null);
                complete_quest_pokemon_encounter?: (POGOProtos.Data.Logs.ICompleteQuestPokemonEncounterLogEntry|null);
                beluga_transfer?: (POGOProtos.Data.Logs.IBelugaDailyTransferLogEntry|null);
                open_gift?: (POGOProtos.Data.Logs.IOpenGiftLogEntry|null);
                send_gift?: (POGOProtos.Data.Logs.ISendGiftLogEntry|null);
                trading?: (POGOProtos.Data.Logs.ITradingLogEntry|null);
                share_ex_raid_pass?: (POGOProtos.Data.Logs.IShareExRaidPassLogEntry|null);
                decline_ex_raid_pass?: (POGOProtos.Data.Logs.IDeclineExRaidPassLogEntry|null);
                fitness_rewards?: (POGOProtos.Data.Logs.IFitnessRewardsLogEntry|null);
                combat?: (POGOProtos.Data.Logs.ICombatLogEntry|null);
            }

            class ActionLogEntry implements IActionLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IActionLogEntry);
                public timestamp_ms: (number|Long);
                public sfida: boolean;
                public catch_pokemon?: (POGOProtos.Data.Logs.ICatchPokemonLogEntry|null);
                public fort_search?: (POGOProtos.Data.Logs.IFortSearchLogEntry|null);
                public buddy_pokemon?: (POGOProtos.Data.Logs.IBuddyPokemonLogEntry|null);
                public raid_rewards?: (POGOProtos.Data.Logs.IRaidRewardsLogEntry|null);
                public passcode_rewards?: (POGOProtos.Data.Logs.IPasscodeRewardsLogEntry|null);
                public complete_quest?: (POGOProtos.Data.Logs.ICompleteQuestLogEntry|null);
                public complete_quest_stamp_card?: (POGOProtos.Data.Logs.ICompleteQuestStampCardLogEntry|null);
                public complete_quest_pokemon_encounter?: (POGOProtos.Data.Logs.ICompleteQuestPokemonEncounterLogEntry|null);
                public beluga_transfer?: (POGOProtos.Data.Logs.IBelugaDailyTransferLogEntry|null);
                public open_gift?: (POGOProtos.Data.Logs.IOpenGiftLogEntry|null);
                public send_gift?: (POGOProtos.Data.Logs.ISendGiftLogEntry|null);
                public trading?: (POGOProtos.Data.Logs.ITradingLogEntry|null);
                public share_ex_raid_pass?: (POGOProtos.Data.Logs.IShareExRaidPassLogEntry|null);
                public decline_ex_raid_pass?: (POGOProtos.Data.Logs.IDeclineExRaidPassLogEntry|null);
                public fitness_rewards?: (POGOProtos.Data.Logs.IFitnessRewardsLogEntry|null);
                public combat?: (POGOProtos.Data.Logs.ICombatLogEntry|null);
                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"|"share_ex_raid_pass"|"decline_ex_raid_pass"|"fitness_rewards"|"combat");
                public static encode(message: POGOProtos.Data.Logs.IActionLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.ActionLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.ActionLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.ActionLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaDailyTransferLogEntry {
                result?: (POGOProtos.Data.Logs.BelugaDailyTransferLogEntry.Result|null);
                includes_weekly_bonus?: (boolean|null);
                items_awarded?: (POGOProtos.Inventory.ILoot|null);
            }

            class BelugaDailyTransferLogEntry implements IBelugaDailyTransferLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IBelugaDailyTransferLogEntry);
                public result: POGOProtos.Data.Logs.BelugaDailyTransferLogEntry.Result;
                public includes_weekly_bonus: boolean;
                public items_awarded?: (POGOProtos.Inventory.ILoot|null);
                public static encode(message: POGOProtos.Data.Logs.IBelugaDailyTransferLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.BelugaDailyTransferLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.BelugaDailyTransferLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.BelugaDailyTransferLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BelugaDailyTransferLogEntry {

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

            interface IBuddyPokemonLogEntry {
                result?: (POGOProtos.Data.Logs.BuddyPokemonLogEntry.Result|null);
                pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                amount?: (number|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                pokemon?: (number|Long|null);
            }

            class BuddyPokemonLogEntry implements IBuddyPokemonLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IBuddyPokemonLogEntry);
                public result: POGOProtos.Data.Logs.BuddyPokemonLogEntry.Result;
                public pokemon_id: POGOProtos.Enums.PokemonId;
                public amount: number;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public pokemon: (number|Long);
                public static encode(message: POGOProtos.Data.Logs.IBuddyPokemonLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.BuddyPokemonLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.BuddyPokemonLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.BuddyPokemonLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BuddyPokemonLogEntry {

                enum Result {
                    UNSET = 0,
                    CANDY_FOUND = 1
                }
            }

            interface ICatchPokemonLogEntry {
                result?: (POGOProtos.Data.Logs.CatchPokemonLogEntry.Result|null);
                pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                combat_points?: (number|null);
                pokemon_data_id?: (number|Long|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            }

            class CatchPokemonLogEntry implements ICatchPokemonLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.ICatchPokemonLogEntry);
                public result: POGOProtos.Data.Logs.CatchPokemonLogEntry.Result;
                public pokemon_id: POGOProtos.Enums.PokemonId;
                public combat_points: number;
                public pokemon_data_id: (number|Long);
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Data.Logs.ICatchPokemonLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.CatchPokemonLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.CatchPokemonLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.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 ICombatLogEntry {
                result?: (POGOProtos.Data.Logs.CombatLogEntry.Result|null);
                finish_state?: (POGOProtos.Enums.CombatPlayerFinishState|null);
                rewards?: (POGOProtos.Inventory.ILoot|null);
                opponent?: (string|null);
                combat_league_template_id?: (string|null);
                npc_template_id?: (string|null);
            }

            class CombatLogEntry implements ICombatLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.ICombatLogEntry);
                public result: POGOProtos.Data.Logs.CombatLogEntry.Result;
                public finish_state: POGOProtos.Enums.CombatPlayerFinishState;
                public rewards?: (POGOProtos.Inventory.ILoot|null);
                public opponent: string;
                public combat_league_template_id: string;
                public npc_template_id: string;
                public static encode(message: POGOProtos.Data.Logs.ICombatLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.CombatLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.CombatLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.CombatLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CombatLogEntry {

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

            interface ICompleteQuestLogEntry {
                result?: (POGOProtos.Data.Logs.CompleteQuestLogEntry.Result|null);
                quest?: (POGOProtos.Data.Quests.IClientQuest|null);
                stamp?: (POGOProtos.Data.Quests.IQuestStamp[]|null);
            }

            class CompleteQuestLogEntry implements ICompleteQuestLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.ICompleteQuestLogEntry);
                public result: POGOProtos.Data.Logs.CompleteQuestLogEntry.Result;
                public quest?: (POGOProtos.Data.Quests.IClientQuest|null);
                public stamp: POGOProtos.Data.Quests.IQuestStamp[];
                public static encode(message: POGOProtos.Data.Logs.ICompleteQuestLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.CompleteQuestLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.CompleteQuestLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.CompleteQuestLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CompleteQuestLogEntry {

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

            interface ICompleteQuestPokemonEncounterLogEntry {
                result?: (POGOProtos.Data.Logs.CompleteQuestPokemonEncounterLogEntry.Result|null);
                pokedex_number?: (number|null);
                combat_points?: (number|null);
                pokemon_id?: (number|Long|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                encounter_type?: (POGOProtos.Enums.EncounterType|null);
            }

            class CompleteQuestPokemonEncounterLogEntry implements ICompleteQuestPokemonEncounterLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.ICompleteQuestPokemonEncounterLogEntry);
                public result: POGOProtos.Data.Logs.CompleteQuestPokemonEncounterLogEntry.Result;
                public pokedex_number: number;
                public combat_points: number;
                public pokemon_id: (number|Long);
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public encounter_type: POGOProtos.Enums.EncounterType;
                public static encode(message: POGOProtos.Data.Logs.ICompleteQuestPokemonEncounterLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.CompleteQuestPokemonEncounterLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.CompleteQuestPokemonEncounterLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.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 ICompleteQuestStampCardLogEntry {
                result?: (POGOProtos.Data.Logs.CompleteQuestStampCardLogEntry.Result|null);
                reward?: (POGOProtos.Data.Quests.IQuestReward[]|null);
            }

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

            namespace CompleteQuestStampCardLogEntry {

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

            interface IDeclineExRaidPassLogEntry {
                result?: (POGOProtos.Data.Logs.DeclineExRaidPassLogEntry.Result|null);
                friend_codename?: (string|null);
            }

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

            namespace DeclineExRaidPassLogEntry {

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

            interface IFitnessRewardsLogEntry {
                result?: (POGOProtos.Data.Logs.FitnessRewardsLogEntry.Result|null);
                rewards?: (POGOProtos.Inventory.ILoot|null);
                distance_walked_km?: (number|null);
            }

            class FitnessRewardsLogEntry implements IFitnessRewardsLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IFitnessRewardsLogEntry);
                public result: POGOProtos.Data.Logs.FitnessRewardsLogEntry.Result;
                public rewards?: (POGOProtos.Inventory.ILoot|null);
                public distance_walked_km: number;
                public static encode(message: POGOProtos.Data.Logs.IFitnessRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.FitnessRewardsLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.FitnessRewardsLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.FitnessRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FitnessRewardsLogEntry {

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

            interface IFortSearchLogEntry {
                result?: (POGOProtos.Data.Logs.FortSearchLogEntry.Result|null);
                fort_id?: (string|null);
                items?: (POGOProtos.Inventory.Item.IItemData[]|null);
                eggs?: (number|null);
                pokemon_eggs?: (POGOProtos.Data.IPokemonData[]|null);
                fort_type?: (POGOProtos.Map.Fort.FortType|null);
                awarded_items?: (POGOProtos.Inventory.Item.IItemData[]|null);
                bonus_items?: (POGOProtos.Inventory.Item.IItemData[]|null);
                team_bonus_items?: (POGOProtos.Inventory.Item.IItemData[]|null);
                gift_boxes?: (POGOProtos.Data.Gift.IGiftBox[]|null);
            }

            class FortSearchLogEntry implements IFortSearchLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IFortSearchLogEntry);
                public result: POGOProtos.Data.Logs.FortSearchLogEntry.Result;
                public fort_id: string;
                public items: POGOProtos.Inventory.Item.IItemData[];
                public eggs: number;
                public pokemon_eggs: POGOProtos.Data.IPokemonData[];
                public fort_type: POGOProtos.Map.Fort.FortType;
                public awarded_items: POGOProtos.Inventory.Item.IItemData[];
                public bonus_items: POGOProtos.Inventory.Item.IItemData[];
                public team_bonus_items: POGOProtos.Inventory.Item.IItemData[];
                public gift_boxes: POGOProtos.Data.Gift.IGiftBox[];
                public static encode(message: POGOProtos.Data.Logs.IFortSearchLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.FortSearchLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.FortSearchLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.FortSearchLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FortSearchLogEntry {

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

            interface IOpenGiftLogEntry {
                result?: (POGOProtos.Data.Logs.OpenGiftLogEntry.Result|null);
                friend_codename?: (string|null);
                items?: (POGOProtos.Inventory.ILoot|null);
                pokemon_eggs?: (POGOProtos.Data.IPokemonData[]|null);
            }

            class OpenGiftLogEntry implements IOpenGiftLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IOpenGiftLogEntry);
                public result: POGOProtos.Data.Logs.OpenGiftLogEntry.Result;
                public friend_codename: string;
                public items?: (POGOProtos.Inventory.ILoot|null);
                public pokemon_eggs: POGOProtos.Data.IPokemonData[];
                public static encode(message: POGOProtos.Data.Logs.IOpenGiftLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.OpenGiftLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.OpenGiftLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.OpenGiftLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace OpenGiftLogEntry {

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

            interface IPasscodeRewardsLogEntry {
                result?: (POGOProtos.Data.Logs.PasscodeRewardsLogEntry.Result|null);
                passcode?: (string|null);
                rewards?: (POGOProtos.Data.Redeem.IRedeemPasscodeReward|null);
            }

            class PasscodeRewardsLogEntry implements IPasscodeRewardsLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IPasscodeRewardsLogEntry);
                public result: POGOProtos.Data.Logs.PasscodeRewardsLogEntry.Result;
                public passcode: string;
                public rewards?: (POGOProtos.Data.Redeem.IRedeemPasscodeReward|null);
                public static encode(message: POGOProtos.Data.Logs.IPasscodeRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.PasscodeRewardsLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.PasscodeRewardsLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.PasscodeRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PasscodeRewardsLogEntry {

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

            interface IRaidRewardsLogEntry {
                result?: (POGOProtos.Data.Logs.RaidRewardsLogEntry.Result|null);
                is_exclusive?: (boolean|null);
                items?: (POGOProtos.Inventory.Item.IItemData[]|null);
                default_rewards?: (POGOProtos.Inventory.Item.IItemData[]|null);
                stardust?: (number|null);
            }

            class RaidRewardsLogEntry implements IRaidRewardsLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.IRaidRewardsLogEntry);
                public result: POGOProtos.Data.Logs.RaidRewardsLogEntry.Result;
                public is_exclusive: boolean;
                public items: POGOProtos.Inventory.Item.IItemData[];
                public default_rewards: POGOProtos.Inventory.Item.IItemData[];
                public stardust: number;
                public static encode(message: POGOProtos.Data.Logs.IRaidRewardsLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.RaidRewardsLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.RaidRewardsLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.RaidRewardsLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace RaidRewardsLogEntry {

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

            interface ISendGiftLogEntry {
                result?: (POGOProtos.Data.Logs.SendGiftLogEntry.Result|null);
                friend_codename?: (string|null);
            }

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

            namespace SendGiftLogEntry {

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

            interface IShareExRaidPassLogEntry {
                result?: (POGOProtos.Data.Logs.ShareExRaidPassLogEntry.Result|null);
                friend_codename?: (string|null);
            }

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

            namespace ShareExRaidPassLogEntry {

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

            interface ITradingLogEntry {
                result?: (POGOProtos.Data.Logs.TradingLogEntry.Result|null);
                friend_codename?: (string|null);
                trade_out_pokemon?: (POGOProtos.Data.IPokemonData|null);
                trade_in_pokemon?: (POGOProtos.Data.IPokemonData|null);
                rewards?: (POGOProtos.Inventory.ILoot|null);
                price?: (POGOProtos.Inventory.ILoot|null);
            }

            class TradingLogEntry implements ITradingLogEntry {
                constructor(properties?: POGOProtos.Data.Logs.ITradingLogEntry);
                public result: POGOProtos.Data.Logs.TradingLogEntry.Result;
                public friend_codename: string;
                public trade_out_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public trade_in_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public rewards?: (POGOProtos.Inventory.ILoot|null);
                public price?: (POGOProtos.Inventory.ILoot|null);
                public static encode(message: POGOProtos.Data.Logs.ITradingLogEntry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Logs.TradingLogEntry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Logs.TradingLogEntry;
                public static toObject(message: POGOProtos.Data.Logs.TradingLogEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace TradingLogEntry {

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

        namespace News {

            interface ICurrentNews {
                news_articles?: (POGOProtos.Data.News.INewsArticle[]|null);
                news_strings_url?: (string|null);
                last_updated_timestamp?: (number|Long|null);
            }

            class CurrentNews implements ICurrentNews {
                constructor(properties?: POGOProtos.Data.News.ICurrentNews);
                public news_articles: POGOProtos.Data.News.INewsArticle[];
                public news_strings_url: string;
                public last_updated_timestamp: (number|Long);
                public static encode(message: POGOProtos.Data.News.ICurrentNews, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.News.CurrentNews;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.News.CurrentNews;
                public static toObject(message: POGOProtos.Data.News.CurrentNews, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface INewsArticle {
                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.Data.News.NewsArticle.NewsTemplate|null);
                enabled?: (boolean|null);
                article_read?: (boolean|null);
            }

            class NewsArticle implements INewsArticle {
                constructor(properties?: POGOProtos.Data.News.INewsArticle);
                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.Data.News.NewsArticle.NewsTemplate;
                public enabled: boolean;
                public article_read: boolean;
                public static encode(message: POGOProtos.Data.News.INewsArticle, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.News.NewsArticle;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.News.NewsArticle;
                public static toObject(message: POGOProtos.Data.News.NewsArticle, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace NewsArticle {

                enum NewsTemplate {
                    UNSET = 0,
                    DEFAULT_TEMPLATE = 1
                }
            }
        }

        interface INpcPokemon {
            pokemon_type?: (POGOProtos.Enums.PokemonId|null);
            pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
        }

        class NpcPokemon implements INpcPokemon {
            constructor(properties?: POGOProtos.Data.INpcPokemon);
            public pokemon_type: POGOProtos.Enums.PokemonId;
            public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            public static encode(message: POGOProtos.Data.INpcPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.NpcPokemon;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.NpcPokemon;
            public static toObject(message: POGOProtos.Data.NpcPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Player {

            interface IContactSettings {
                send_marketing_emails?: (boolean|null);
                send_push_notifications?: (boolean|null);
            }

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

            interface ICurrency {
                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 Currency implements ICurrency {
                constructor(properties?: POGOProtos.Data.Player.ICurrency);
                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.Data.Player.ICurrency, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.Currency;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.Currency;
                public static toObject(message: POGOProtos.Data.Player.Currency, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDailyBonus {
                next_collected_timestamp_ms?: (number|Long|null);
                next_defender_bonus_collect_timestamp_ms?: (number|Long|null);
            }

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

            interface IEquippedBadge {
                badge_type?: (POGOProtos.Enums.BadgeType|null);
                level?: (number|null);
                next_equip_change_allowed_timestamp_ms?: (number|Long|null);
            }

            class EquippedBadge implements IEquippedBadge {
                constructor(properties?: POGOProtos.Data.Player.IEquippedBadge);
                public badge_type: POGOProtos.Enums.BadgeType;
                public level: number;
                public next_equip_change_allowed_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Data.Player.IEquippedBadge, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.EquippedBadge;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.EquippedBadge;
                public static toObject(message: POGOProtos.Data.Player.EquippedBadge, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerAvatar {
                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);
            }

            class PlayerAvatar implements IPlayerAvatar {
                constructor(properties?: POGOProtos.Data.Player.IPlayerAvatar);
                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 static encode(message: POGOProtos.Data.Player.IPlayerAvatar, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerAvatar;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerAvatar;
                public static toObject(message: POGOProtos.Data.Player.PlayerAvatar, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum PlayerAvatarType {
                PLAYER_AVATAR_MALE = 0,
                PLAYER_AVATAR_FEMALE = 1
            }

            interface IPlayerBadge {
                badge_type?: (POGOProtos.Enums.BadgeType|null);
                rank?: (number|null);
                start_value?: (number|null);
                end_value?: (number|null);
                current_value?: (number|null);
            }

            class PlayerBadge implements IPlayerBadge {
                constructor(properties?: POGOProtos.Data.Player.IPlayerBadge);
                public badge_type: POGOProtos.Enums.BadgeType;
                public rank: number;
                public start_value: number;
                public end_value: number;
                public current_value: number;
                public static encode(message: POGOProtos.Data.Player.IPlayerBadge, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerBadge;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerBadge;
                public static toObject(message: POGOProtos.Data.Player.PlayerBadge, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerCamera {
                is_default_camera?: (boolean|null);
            }

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

            interface IPlayerChurnParameters {
                account_id?: (string|null);
                code_name?: (string|null);
                team?: (string|null);
                country?: (string|null);
                level?: (number|null);
                total_pokemon_caught?: (number|null);
                gifts_opened_daily?: (number|null);
                total_big_karps?: (number|null);
                stardust_balance?: (number|null);
                total_raids?: (number|null);
                total_pokemon_evolved?: (number|null);
                total_legendary_raids?: (number|null);
                total_eggs_hatched?: (number|null);
                total_battle_attack_won?: (number|null);
                total_battle_defended_won?: (number|null);
                total_quests_completed?: (number|null);
                poke_coin_balance?: (number|null);
                pokemon_caught_active_day?: (number|null);
                total_km_walked?: (number|null);
                num_pokedex_entries?: (number|null);
                km_walked_past_active_day?: (number|null);
                days_since_last_logon?: (number|Long|null);
                days_since_creation?: (number|Long|null);
                days_since_last_pokemon_caught?: (number|Long|null);
            }

            class PlayerChurnParameters implements IPlayerChurnParameters {
                constructor(properties?: POGOProtos.Data.Player.IPlayerChurnParameters);
                public account_id: string;
                public code_name: string;
                public team: string;
                public country: string;
                public level: number;
                public total_pokemon_caught: number;
                public gifts_opened_daily: number;
                public total_big_karps: number;
                public stardust_balance: number;
                public total_raids: number;
                public total_pokemon_evolved: number;
                public total_legendary_raids: number;
                public total_eggs_hatched: number;
                public total_battle_attack_won: number;
                public total_battle_defended_won: number;
                public total_quests_completed: number;
                public poke_coin_balance: number;
                public pokemon_caught_active_day: number;
                public total_km_walked: number;
                public num_pokedex_entries: number;
                public km_walked_past_active_day: number;
                public days_since_last_logon: (number|Long);
                public days_since_creation: (number|Long);
                public days_since_last_pokemon_caught: (number|Long);
                public static encode(message: POGOProtos.Data.Player.IPlayerChurnParameters, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerChurnParameters;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerChurnParameters;
                public static toObject(message: POGOProtos.Data.Player.PlayerChurnParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerCurrency {
                gems?: (number|null);
            }

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

            interface IPlayerPublicProfile {
                name?: (string|null);
                level?: (number|null);
                avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
                team_color?: (POGOProtos.Enums.TeamColor|null);
                battles_won?: (number|null);
                km_walked?: (number|null);
                caught_pokemon?: (number|null);
                gym_badge_type?: (POGOProtos.Enums.GymBadgeType|null);
                badges?: (POGOProtos.Data.Player.IPlayerBadge[]|null);
                experience?: (number|Long|null);
                has_shared_ex_pass?: (boolean|null);
            }

            class PlayerPublicProfile implements IPlayerPublicProfile {
                constructor(properties?: POGOProtos.Data.Player.IPlayerPublicProfile);
                public name: string;
                public level: number;
                public avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
                public team_color: POGOProtos.Enums.TeamColor;
                public battles_won: number;
                public km_walked: number;
                public caught_pokemon: number;
                public gym_badge_type: POGOProtos.Enums.GymBadgeType;
                public badges: POGOProtos.Data.Player.IPlayerBadge[];
                public experience: (number|Long);
                public has_shared_ex_pass: boolean;
                public static encode(message: POGOProtos.Data.Player.IPlayerPublicProfile, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerPublicProfile;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerPublicProfile;
                public static toObject(message: POGOProtos.Data.Player.PlayerPublicProfile, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerReputation {
                account_age_ms?: (number|Long|null);
                player_level?: (number|Long|null);
                cheat_reputation?: (POGOProtos.Data.Player.PlayerReputation.CheatReputation[]|null);
                is_minor?: (boolean|null);
            }

            class PlayerReputation implements IPlayerReputation {
                constructor(properties?: POGOProtos.Data.Player.IPlayerReputation);
                public account_age_ms: (number|Long);
                public player_level: (number|Long);
                public cheat_reputation: POGOProtos.Data.Player.PlayerReputation.CheatReputation[];
                public is_minor: boolean;
                public static encode(message: POGOProtos.Data.Player.IPlayerReputation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerReputation;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerReputation;
                public static toObject(message: POGOProtos.Data.Player.PlayerReputation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PlayerReputation {

                enum CheatReputation {
                    UNSET = 0,
                    BOT = 1,
                    SPOOFER = 2
                }
            }

            interface IPlayerStats {
                level?: (number|null);
                experience?: (number|Long|null);
                prev_level_xp?: (number|Long|null);
                next_level_xp?: (number|Long|null);
                km_walked?: (number|null);
                pokemons_encountered?: (number|null);
                unique_pokedex_entries?: (number|null);
                pokemons_captured?: (number|null);
                evolutions?: (number|null);
                poke_stop_visits?: (number|null);
                pokeballs_thrown?: (number|null);
                eggs_hatched?: (number|null);
                big_magikarp_caught?: (number|null);
                battle_attack_won?: (number|null);
                battle_attack_total?: (number|null);
                battle_defended_won?: (number|null);
                battle_training_won?: (number|null);
                battle_training_total?: (number|null);
                prestige_raised_total?: (number|null);
                prestige_dropped_total?: (number|null);
                pokemon_deployed?: (number|null);
                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.Enums.GymBadgeType[]|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.Data.Combat.IPlayerCombatStats|null);
                num_npc_combats_won?: (number|null);
                num_npc_combats_total?: (number|null);
                num_photobomb_seen?: (number|null);
            }

            class PlayerStats implements IPlayerStats {
                constructor(properties?: POGOProtos.Data.Player.IPlayerStats);
                public level: number;
                public experience: (number|Long);
                public prev_level_xp: (number|Long);
                public next_level_xp: (number|Long);
                public km_walked: number;
                public pokemons_encountered: number;
                public unique_pokedex_entries: number;
                public pokemons_captured: number;
                public evolutions: number;
                public poke_stop_visits: number;
                public pokeballs_thrown: number;
                public eggs_hatched: number;
                public big_magikarp_caught: number;
                public battle_attack_won: number;
                public battle_attack_total: number;
                public battle_defended_won: number;
                public battle_training_won: number;
                public battle_training_total: number;
                public prestige_raised_total: number;
                public prestige_dropped_total: number;
                public pokemon_deployed: number;
                public 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.Enums.GymBadgeType[];
                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.Data.Combat.IPlayerCombatStats|null);
                public num_npc_combats_won: number;
                public num_npc_combats_total: number;
                public num_photobomb_seen: number;
                public static encode(message: POGOProtos.Data.Player.IPlayerStats, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerStats;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerStats;
                public static toObject(message: POGOProtos.Data.Player.PlayerStats, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerSummary {
                player_id?: (string|null);
                codename?: (string|null);
                public_data?: (Uint8Array|null);
                team?: (string|null);
                fb_user_id?: (string|null);
            }

            class PlayerSummary implements IPlayerSummary {
                constructor(properties?: POGOProtos.Data.Player.IPlayerSummary);
                public player_id: string;
                public codename: string;
                public public_data: Uint8Array;
                public team: string;
                public fb_user_id: string;
                public static encode(message: POGOProtos.Data.Player.IPlayerSummary, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.PlayerSummary;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.PlayerSummary;
                public static toObject(message: POGOProtos.Data.Player.PlayerSummary, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISocialPlayerSettings {
                disable_last_pokemon_caught?: (boolean|null);
            }

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

            interface ITeamChangeInfo {
                last_acquired_time?: (number|Long|null);
                num_items_acquired?: (number|null);
            }

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

            interface IUserAttributes {
                level?: (number|null);
                xp_percentage?: (number|Long|null);
                pokecoin_count?: (number|Long|null);
                team?: (number|null);
                catch_streak?: (number|null);
                spin_streak?: (number|null);
            }

            class UserAttributes implements IUserAttributes {
                constructor(properties?: POGOProtos.Data.Player.IUserAttributes);
                public level: number;
                public xp_percentage: (number|Long);
                public pokecoin_count: (number|Long);
                public team: number;
                public catch_streak: number;
                public spin_streak: number;
                public static encode(message: POGOProtos.Data.Player.IUserAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.UserAttributes;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.UserAttributes;
                public static toObject(message: POGOProtos.Data.Player.UserAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IUserIssueWeatherReport {
                gameplayer_weather?: (string|null);
                alert_active?: (boolean|null);
                severity?: (number|null);
                user_report?: (number|null);
            }

            class UserIssueWeatherReport implements IUserIssueWeatherReport {
                constructor(properties?: POGOProtos.Data.Player.IUserIssueWeatherReport);
                public gameplayer_weather: string;
                public alert_active: boolean;
                public severity: number;
                public user_report: number;
                public static encode(message: POGOProtos.Data.Player.IUserIssueWeatherReport, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Player.UserIssueWeatherReport;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Player.UserIssueWeatherReport;
                public static toObject(message: POGOProtos.Data.Player.UserIssueWeatherReport, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface IPlayerBadge {
            badge_type?: (POGOProtos.Enums.BadgeType|null);
            rank?: (number|null);
            start_value?: (number|null);
            end_value?: (number|null);
            current_value?: (number|null);
        }

        class PlayerBadge implements IPlayerBadge {
            constructor(properties?: POGOProtos.Data.IPlayerBadge);
            public badge_type: POGOProtos.Enums.BadgeType;
            public rank: number;
            public start_value: number;
            public end_value: number;
            public current_value: number;
            public static encode(message: POGOProtos.Data.IPlayerBadge, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.PlayerBadge;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.PlayerBadge;
            public static toObject(message: POGOProtos.Data.PlayerBadge, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPlayerData {
            creation_timestamp_ms?: (number|Long|null);
            username?: (string|null);
            team?: (POGOProtos.Enums.TeamColor|null);
            tutorial_state?: (POGOProtos.Enums.TutorialState[]|null);
            avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
            max_pokemon_storage?: (number|null);
            max_item_storage?: (number|null);
            daily_bonus?: (POGOProtos.Data.Player.IDailyBonus|null);
            equipped_badge?: (POGOProtos.Data.Player.IEquippedBadge|null);
            contact_settings?: (POGOProtos.Data.Player.IContactSettings|null);
            currency_balance?: (POGOProtos.Data.Store.ICurrencyQuantity[]|null);
            remaining_codename_claims?: (number|null);
            buddy_pokemon?: (POGOProtos.Data.IBuddyPokemon|null);
            battle_lockout_end_ms?: (number|Long|null);
            secondary_player_avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
            name_is_blacklisted?: (boolean|null);
            social_player_settings?: (POGOProtos.Data.Player.ISocialPlayerSettings|null);
            combat_player_preferences?: (POGOProtos.Data.Combat.ICombatPlayerPreferences|null);
            player_support_id?: (string|null);
            team_change_info?: (POGOProtos.Data.Player.ITeamChangeInfo|null);
        }

        class PlayerData implements IPlayerData {
            constructor(properties?: POGOProtos.Data.IPlayerData);
            public creation_timestamp_ms: (number|Long);
            public username: string;
            public team: POGOProtos.Enums.TeamColor;
            public tutorial_state: POGOProtos.Enums.TutorialState[];
            public avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
            public max_pokemon_storage: number;
            public max_item_storage: number;
            public daily_bonus?: (POGOProtos.Data.Player.IDailyBonus|null);
            public equipped_badge?: (POGOProtos.Data.Player.IEquippedBadge|null);
            public contact_settings?: (POGOProtos.Data.Player.IContactSettings|null);
            public currency_balance: POGOProtos.Data.Store.ICurrencyQuantity[];
            public remaining_codename_claims: number;
            public buddy_pokemon?: (POGOProtos.Data.IBuddyPokemon|null);
            public battle_lockout_end_ms: (number|Long);
            public secondary_player_avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
            public name_is_blacklisted: boolean;
            public social_player_settings?: (POGOProtos.Data.Player.ISocialPlayerSettings|null);
            public combat_player_preferences?: (POGOProtos.Data.Combat.ICombatPlayerPreferences|null);
            public player_support_id: string;
            public team_change_info?: (POGOProtos.Data.Player.ITeamChangeInfo|null);
            public static encode(message: POGOProtos.Data.IPlayerData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.PlayerData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.PlayerData;
            public static toObject(message: POGOProtos.Data.PlayerData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokedexEntry {
            pokemon_id?: (POGOProtos.Enums.PokemonId|null);
            times_encountered?: (number|null);
            times_captured?: (number|null);
            evolution_stone_pieces?: (number|null);
            evolution_stones?: (number|null);
            captured_costumes?: (POGOProtos.Enums.Costume[]|null);
            captured_forms?: (POGOProtos.Enums.Form[]|null);
            captured_genders?: (POGOProtos.Enums.Gender[]|null);
            captured_shiny?: (boolean|null);
            encountered_costumes?: (POGOProtos.Enums.Costume[]|null);
            encountered_forms?: (POGOProtos.Enums.Form[]|null);
            encountered_genders?: (POGOProtos.Enums.Gender[]|null);
            encountered_shiny?: (boolean|null);
            times_lucky_received?: (number|null);
        }

        class PokedexEntry implements IPokedexEntry {
            constructor(properties?: POGOProtos.Data.IPokedexEntry);
            public pokemon_id: POGOProtos.Enums.PokemonId;
            public times_encountered: number;
            public times_captured: number;
            public evolution_stone_pieces: number;
            public evolution_stones: number;
            public captured_costumes: POGOProtos.Enums.Costume[];
            public captured_forms: POGOProtos.Enums.Form[];
            public captured_genders: POGOProtos.Enums.Gender[];
            public captured_shiny: boolean;
            public encountered_costumes: POGOProtos.Enums.Costume[];
            public encountered_forms: POGOProtos.Enums.Form[];
            public encountered_genders: POGOProtos.Enums.Gender[];
            public encountered_shiny: boolean;
            public times_lucky_received: number;
            public static encode(message: POGOProtos.Data.IPokedexEntry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.PokedexEntry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.PokedexEntry;
            public static toObject(message: POGOProtos.Data.PokedexEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonData {
            id?: (number|Long|null);
            pokemon_id?: (POGOProtos.Enums.PokemonId|null);
            cp?: (number|null);
            stamina?: (number|null);
            stamina_max?: (number|null);
            move_1?: (POGOProtos.Enums.PokemonMove|null);
            move_2?: (POGOProtos.Enums.PokemonMove|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);
            origin?: (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.Inventory.Item.ItemId|null);
            captured_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?: (number|null);
            nickname?: (string|null);
            from_fort?: (number|null);
            buddy_candy_awarded?: (number|null);
            buddy_total_km_walked?: (number|null);
            display_pokemon_id?: (number|null);
            display_cp?: (number|null);
            pokemon_display?: (POGOProtos.Data.IPokemonDisplay|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);
            move_3?: (POGOProtos.Enums.PokemonMove|null);
            pvp_combat_stats?: (POGOProtos.Data.Combat.IPokemonCombatStats|null);
            npc_combat_stats?: (POGOProtos.Data.Combat.IPokemonCombatStats|null);
        }

        class PokemonData implements IPokemonData {
            constructor(properties?: POGOProtos.Data.IPokemonData);
            public id: (number|Long);
            public pokemon_id: POGOProtos.Enums.PokemonId;
            public cp: number;
            public stamina: number;
            public stamina_max: number;
            public move_1: POGOProtos.Enums.PokemonMove;
            public move_2: POGOProtos.Enums.PokemonMove;
            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 origin: 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.Inventory.Item.ItemId;
            public captured_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: number;
            public nickname: string;
            public from_fort: number;
            public buddy_candy_awarded: number;
            public buddy_total_km_walked: number;
            public display_pokemon_id: number;
            public display_cp: number;
            public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|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 move_3: POGOProtos.Enums.PokemonMove;
            public pvp_combat_stats?: (POGOProtos.Data.Combat.IPokemonCombatStats|null);
            public npc_combat_stats?: (POGOProtos.Data.Combat.IPokemonCombatStats|null);
            public static encode(message: POGOProtos.Data.IPokemonData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.PokemonData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.PokemonData;
            public static toObject(message: POGOProtos.Data.PokemonData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IPokemonDisplay {
            costume?: (POGOProtos.Enums.Costume|null);
            gender?: (POGOProtos.Enums.Gender|null);
            shiny?: (boolean|null);
            form?: (POGOProtos.Enums.Form|null);
            weather_boosted_condition?: (POGOProtos.Enums.WeatherCondition|null);
        }

        class PokemonDisplay implements IPokemonDisplay {
            constructor(properties?: POGOProtos.Data.IPokemonDisplay);
            public costume: POGOProtos.Enums.Costume;
            public gender: POGOProtos.Enums.Gender;
            public shiny: boolean;
            public form: POGOProtos.Enums.Form;
            public weather_boosted_condition: POGOProtos.Enums.WeatherCondition;
            public static encode(message: POGOProtos.Data.IPokemonDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.PokemonDisplay;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Data.PokemonDisplay;
            public static toObject(message: POGOProtos.Data.PokemonDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Quests {

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

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

            interface ICatchPokemonQuest {
            }

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

            interface IClientQuest {
                quest?: (POGOProtos.Data.Quests.IQuest|null);
                quest_display?: (POGOProtos.Data.Quests.ClientQuest.IQuestDisplay|null);
            }

            class ClientQuest implements IClientQuest {
                constructor(properties?: POGOProtos.Data.Quests.IClientQuest);
                public quest?: (POGOProtos.Data.Quests.IQuest|null);
                public quest_display?: (POGOProtos.Data.Quests.ClientQuest.IQuestDisplay|null);
                public static encode(message: POGOProtos.Data.Quests.IClientQuest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.ClientQuest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.ClientQuest;
                public static toObject(message: POGOProtos.Data.Quests.ClientQuest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ClientQuest {

                interface IQuestDisplay {
                    quest_id?: (string|null);
                    dialog?: (POGOProtos.Data.Quests.IQuestDialog[]|null);
                    description?: (string|null);
                    title?: (string|null);
                    slot?: (number|null);
                    subdisplay?: (POGOProtos.Data.Quests.ClientQuest.IQuestDisplay[]|null);
                    story_ending_quest?: (boolean|null);
                    story_ending_description?: (string|null);
                }

                class QuestDisplay implements IQuestDisplay {
                    constructor(properties?: POGOProtos.Data.Quests.ClientQuest.IQuestDisplay);
                    public quest_id: string;
                    public dialog: POGOProtos.Data.Quests.IQuestDialog[];
                    public description: string;
                    public title: string;
                    public slot: number;
                    public subdisplay: POGOProtos.Data.Quests.ClientQuest.IQuestDisplay[];
                    public story_ending_quest: boolean;
                    public story_ending_description: string;
                    public static encode(message: POGOProtos.Data.Quests.ClientQuest.IQuestDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.ClientQuest.QuestDisplay;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.ClientQuest.QuestDisplay;
                    public static toObject(message: POGOProtos.Data.Quests.ClientQuest.QuestDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IQuest {
                quest_type?: (POGOProtos.Enums.QuestType|null);
                daily_quest?: (POGOProtos.Data.Quests.Quest.IDailyQuest|null);
                multi_part?: (POGOProtos.Data.Quests.Quest.IMultiPartQuest|null);
                catch_pokemon?: (POGOProtos.Data.Quests.ICatchPokemonQuest|null);
                add_friend?: (POGOProtos.Data.Quests.IAddFriendQuest|null);
                trade_pokemon?: (POGOProtos.Data.Quests.ITradePokemonQuest|null);
                quest_id?: (string|null);
                quest_seed?: (number|Long|null);
                quest_context?: (POGOProtos.Data.Quests.Quest.Context|null);
                template_id?: (string|null);
                progress?: (number|null);
                goal?: (POGOProtos.Data.Quests.IQuestGoal|null);
                status?: (POGOProtos.Data.Quests.Quest.Status|null);
                quest_rewards?: (POGOProtos.Data.Quests.IQuestReward[]|null);
                creation_timestamp_ms?: (number|Long|null);
                last_update_timestamp_ms?: (number|Long|null);
                compeletion_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.Data.Quests.Quest.IDailyCounter|null);
                reward_pokemon_icon_url?: (string|null);
            }

            class Quest implements IQuest {
                constructor(properties?: POGOProtos.Data.Quests.IQuest);
                public quest_type: POGOProtos.Enums.QuestType;
                public daily_quest?: (POGOProtos.Data.Quests.Quest.IDailyQuest|null);
                public multi_part?: (POGOProtos.Data.Quests.Quest.IMultiPartQuest|null);
                public catch_pokemon?: (POGOProtos.Data.Quests.ICatchPokemonQuest|null);
                public add_friend?: (POGOProtos.Data.Quests.IAddFriendQuest|null);
                public trade_pokemon?: (POGOProtos.Data.Quests.ITradePokemonQuest|null);
                public quest_id: string;
                public quest_seed: (number|Long);
                public quest_context: POGOProtos.Data.Quests.Quest.Context;
                public template_id: string;
                public progress: number;
                public goal?: (POGOProtos.Data.Quests.IQuestGoal|null);
                public status: POGOProtos.Data.Quests.Quest.Status;
                public quest_rewards: POGOProtos.Data.Quests.IQuestReward[];
                public creation_timestamp_ms: (number|Long);
                public last_update_timestamp_ms: (number|Long);
                public compeletion_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.Data.Quests.Quest.IDailyCounter|null);
                public reward_pokemon_icon_url: string;
                public Quest?: ("daily_quest"|"multi_part"|"catch_pokemon"|"add_friend"|"trade_pokemon");
                public static encode(message: POGOProtos.Data.Quests.IQuest, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.Quest;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.Quest;
                public static toObject(message: POGOProtos.Data.Quests.Quest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Quest {

                interface IMultiPartQuest {
                    sub_quests?: (POGOProtos.Data.Quests.IQuest[]|null);
                }

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

                interface IDailyQuest {
                    current_period_bucket?: (number|null);
                    current_streak_count?: (number|null);
                }

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

                interface IDailyCounter {
                    window?: (number|Long|null);
                    count?: (number|null);
                }

                class DailyCounter implements IDailyCounter {
                    constructor(properties?: POGOProtos.Data.Quests.Quest.IDailyCounter);
                    public window: (number|Long);
                    public count: number;
                    public static encode(message: POGOProtos.Data.Quests.Quest.IDailyCounter, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.Quest.DailyCounter;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.Quest.DailyCounter;
                    public static toObject(message: POGOProtos.Data.Quests.Quest.DailyCounter, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                enum Context {
                    UNSET = 0,
                    STORY_QUEST = 1,
                    CHALLENGE_QUEST = 2
                }

                enum Status {
                    STATUS_UNDEFINED = 0,
                    STATUS_ACTIVE = 1,
                    STATUS_COMPLETED = 2
                }
            }

            interface IQuestCondition {
                type?: (POGOProtos.Data.Quests.QuestCondition.ConditionType|null);
                with_pokemon_type?: (POGOProtos.Data.Quests.QuestCondition.IWithPokemonType|null);
                with_pokemon_category?: (POGOProtos.Data.Quests.QuestCondition.IWithPokemonCategory|null);
                with_weather_boost?: (POGOProtos.Data.Quests.QuestCondition.IWithWeatherBoost|null);
                with_daily_capture_bonus?: (POGOProtos.Data.Quests.QuestCondition.IWithDailyCaptureBonus|null);
                with_daily_spin_bonus?: (POGOProtos.Data.Quests.QuestCondition.IWithDailySpinBonus|null);
                with_win_raid_status?: (POGOProtos.Data.Quests.QuestCondition.IWithWinRaidStatus|null);
                with_raid_level?: (POGOProtos.Data.Quests.QuestCondition.IWithRaidLevel|null);
                with_throw_type?: (POGOProtos.Data.Quests.QuestCondition.IWithThrowType|null);
                with_win_gym_battle_status?: (POGOProtos.Data.Quests.QuestCondition.IWithWinGymBattleStatus|null);
                with_super_effective_charge_move?: (POGOProtos.Data.Quests.QuestCondition.IWithSuperEffectiveChargeMove|null);
                with_item?: (POGOProtos.Data.Quests.QuestCondition.IWithItem|null);
                with_unique_pokestop?: (POGOProtos.Data.Quests.QuestCondition.IWithUniquePokestop|null);
                with_quest_context?: (POGOProtos.Data.Quests.QuestCondition.IWithQuestContext|null);
                with_badge_type?: (POGOProtos.Data.Quests.QuestCondition.IWithBadgeType|null);
                with_player_level?: (POGOProtos.Data.Quests.QuestCondition.IWithPlayerLevel|null);
                with_win_battle_status?: (POGOProtos.Data.Quests.QuestCondition.IWithWinBattleStatus|null);
            }

            class QuestCondition implements IQuestCondition {
                constructor(properties?: POGOProtos.Data.Quests.IQuestCondition);
                public type: POGOProtos.Data.Quests.QuestCondition.ConditionType;
                public with_pokemon_type?: (POGOProtos.Data.Quests.QuestCondition.IWithPokemonType|null);
                public with_pokemon_category?: (POGOProtos.Data.Quests.QuestCondition.IWithPokemonCategory|null);
                public with_weather_boost?: (POGOProtos.Data.Quests.QuestCondition.IWithWeatherBoost|null);
                public with_daily_capture_bonus?: (POGOProtos.Data.Quests.QuestCondition.IWithDailyCaptureBonus|null);
                public with_daily_spin_bonus?: (POGOProtos.Data.Quests.QuestCondition.IWithDailySpinBonus|null);
                public with_win_raid_status?: (POGOProtos.Data.Quests.QuestCondition.IWithWinRaidStatus|null);
                public with_raid_level?: (POGOProtos.Data.Quests.QuestCondition.IWithRaidLevel|null);
                public with_throw_type?: (POGOProtos.Data.Quests.QuestCondition.IWithThrowType|null);
                public with_win_gym_battle_status?: (POGOProtos.Data.Quests.QuestCondition.IWithWinGymBattleStatus|null);
                public with_super_effective_charge_move?: (POGOProtos.Data.Quests.QuestCondition.IWithSuperEffectiveChargeMove|null);
                public with_item?: (POGOProtos.Data.Quests.QuestCondition.IWithItem|null);
                public with_unique_pokestop?: (POGOProtos.Data.Quests.QuestCondition.IWithUniquePokestop|null);
                public with_quest_context?: (POGOProtos.Data.Quests.QuestCondition.IWithQuestContext|null);
                public with_badge_type?: (POGOProtos.Data.Quests.QuestCondition.IWithBadgeType|null);
                public with_player_level?: (POGOProtos.Data.Quests.QuestCondition.IWithPlayerLevel|null);
                public with_win_battle_status?: (POGOProtos.Data.Quests.QuestCondition.IWithWinBattleStatus|null);
                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");
                public static encode(message: POGOProtos.Data.Quests.IQuestCondition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition;
                public static toObject(message: POGOProtos.Data.Quests.QuestCondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace QuestCondition {

                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
                }

                interface IWithPokemonType {
                    pokemon_type?: (POGOProtos.Enums.PokemonType[]|null);
                }

                class WithPokemonType implements IWithPokemonType {
                    constructor(properties?: POGOProtos.Data.Quests.QuestCondition.IWithPokemonType);
                    public pokemon_type: POGOProtos.Enums.PokemonType[];
                    public static encode(message: POGOProtos.Data.Quests.QuestCondition.IWithPokemonType, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition.WithPokemonType;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition.WithPokemonType;
                    public static toObject(message: POGOProtos.Data.Quests.QuestCondition.WithPokemonType, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWithWeatherBoost {
                }

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

                interface IWithPokemonCategory {
                    category_name?: (string|null);
                    pokemon_ids?: (POGOProtos.Enums.PokemonId[]|null);
                }

                class WithPokemonCategory implements IWithPokemonCategory {
                    constructor(properties?: POGOProtos.Data.Quests.QuestCondition.IWithPokemonCategory);
                    public category_name: string;
                    public pokemon_ids: POGOProtos.Enums.PokemonId[];
                    public static encode(message: POGOProtos.Data.Quests.QuestCondition.IWithPokemonCategory, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition.WithPokemonCategory;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition.WithPokemonCategory;
                    public static toObject(message: POGOProtos.Data.Quests.QuestCondition.WithPokemonCategory, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWithDailyCaptureBonus {
                }

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

                interface IWithDailySpinBonus {
                }

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

                interface IWithWinRaidStatus {
                }

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

                interface IWithRaidLevel {
                    raid_level?: (POGOProtos.Enums.RaidLevel[]|null);
                }

                class WithRaidLevel implements IWithRaidLevel {
                    constructor(properties?: POGOProtos.Data.Quests.QuestCondition.IWithRaidLevel);
                    public raid_level: POGOProtos.Enums.RaidLevel[];
                    public static encode(message: POGOProtos.Data.Quests.QuestCondition.IWithRaidLevel, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition.WithRaidLevel;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition.WithRaidLevel;
                    public static toObject(message: POGOProtos.Data.Quests.QuestCondition.WithRaidLevel, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWithThrowType {
                    throw_type?: (POGOProtos.Enums.ActivityType|null);
                    hit?: (boolean|null);
                }

                class WithThrowType implements IWithThrowType {
                    constructor(properties?: POGOProtos.Data.Quests.QuestCondition.IWithThrowType);
                    public throw_type: POGOProtos.Enums.ActivityType;
                    public hit: boolean;
                    public Throw?: ("throw_type"|"hit");
                    public static encode(message: POGOProtos.Data.Quests.QuestCondition.IWithThrowType, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition.WithThrowType;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition.WithThrowType;
                    public static toObject(message: POGOProtos.Data.Quests.QuestCondition.WithThrowType, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWithCurveBall {
                }

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

                interface IWithWinGymBattleStatus {
                }

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

                interface IWithSuperEffectiveChargeMove {
                }

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

                interface IWithItem {
                    item?: (POGOProtos.Inventory.Item.ItemId|null);
                }

                class WithItem implements IWithItem {
                    constructor(properties?: POGOProtos.Data.Quests.QuestCondition.IWithItem);
                    public item: POGOProtos.Inventory.Item.ItemId;
                    public static encode(message: POGOProtos.Data.Quests.QuestCondition.IWithItem, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition.WithItem;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition.WithItem;
                    public static toObject(message: POGOProtos.Data.Quests.QuestCondition.WithItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWithUniquePokestop {
                }

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

                interface IWithQuestContext {
                    context?: (POGOProtos.Data.Quests.QuestCondition.WithQuestContext.Context|null);
                }

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

                namespace WithQuestContext {

                    enum Context {
                        UNSET = 0,
                        STORY_QUEST = 1,
                        CHALLENGE_QUEST = 2
                    }
                }

                interface IWithBadgeType {
                    badge_type?: (POGOProtos.Enums.BadgeType[]|null);
                    badge_rank?: (number|null);
                    amount?: (number|null);
                }

                class WithBadgeType implements IWithBadgeType {
                    constructor(properties?: POGOProtos.Data.Quests.QuestCondition.IWithBadgeType);
                    public badge_type: POGOProtos.Enums.BadgeType[];
                    public badge_rank: number;
                    public amount: number;
                    public static encode(message: POGOProtos.Data.Quests.QuestCondition.IWithBadgeType, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestCondition.WithBadgeType;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestCondition.WithBadgeType;
                    public static toObject(message: POGOProtos.Data.Quests.QuestCondition.WithBadgeType, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IWithPlayerLevel {
                    level?: (number|null);
                }

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

                interface IWithWinBattleStatus {
                }

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

            interface IQuestDialog {
                text?: (string|null);
                expression?: (POGOProtos.Data.Quests.QuestDialog.CharacterExpression|null);
                image_uri?: (string|null);
                character?: (POGOProtos.Data.Quests.QuestDialog.Character|null);
            }

            class QuestDialog implements IQuestDialog {
                constructor(properties?: POGOProtos.Data.Quests.IQuestDialog);
                public text: string;
                public expression: POGOProtos.Data.Quests.QuestDialog.CharacterExpression;
                public image_uri: string;
                public character: POGOProtos.Data.Quests.QuestDialog.Character;
                public static encode(message: POGOProtos.Data.Quests.IQuestDialog, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestDialog;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestDialog;
                public static toObject(message: POGOProtos.Data.Quests.QuestDialog, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace QuestDialog {

                enum CharacterExpression {
                    EXPRESSION_UNSET = 0,
                    HAPPY = 1,
                    SYMPATHETIC = 2,
                    ENERGETIC = 3,
                    PUSHY = 4,
                    IMPATIENT = 5,
                    ADMIRATION = 6
                }

                enum Character {
                    CHARACTER_UNSET = 0,
                    PROFESSOR_WILLOW = 1
                }
            }

            interface IQuestGoal {
                condition?: (POGOProtos.Data.Quests.IQuestCondition[]|null);
                target?: (number|null);
            }

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

            interface IQuestPokemonEncounter {
                quest_id?: (string|null);
                pokemon?: (POGOProtos.Data.IPokemonData|null);
                encounter_type?: (POGOProtos.Enums.EncounterType|null);
                is_hidden_ditto?: (boolean|null);
                ditto?: (POGOProtos.Data.IPokemonData|null);
            }

            class QuestPokemonEncounter implements IQuestPokemonEncounter {
                constructor(properties?: POGOProtos.Data.Quests.IQuestPokemonEncounter);
                public quest_id: string;
                public pokemon?: (POGOProtos.Data.IPokemonData|null);
                public encounter_type: POGOProtos.Enums.EncounterType;
                public is_hidden_ditto: boolean;
                public ditto?: (POGOProtos.Data.IPokemonData|null);
                public static encode(message: POGOProtos.Data.Quests.IQuestPokemonEncounter, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestPokemonEncounter;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestPokemonEncounter;
                public static toObject(message: POGOProtos.Data.Quests.QuestPokemonEncounter, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IQuestPrecondition {
                type?: (POGOProtos.Data.Quests.QuestPrecondition.QuestPreconditionType|null);
                quest_template_id?: (string|null);
                level?: (POGOProtos.Data.Quests.QuestPrecondition.ILevel|null);
                medal?: (POGOProtos.Data.Quests.QuestPrecondition.IMedal|null);
                quests?: (POGOProtos.Data.Quests.QuestPrecondition.IQuests|null);
            }

            class QuestPrecondition implements IQuestPrecondition {
                constructor(properties?: POGOProtos.Data.Quests.IQuestPrecondition);
                public type: POGOProtos.Data.Quests.QuestPrecondition.QuestPreconditionType;
                public quest_template_id: string;
                public level?: (POGOProtos.Data.Quests.QuestPrecondition.ILevel|null);
                public medal?: (POGOProtos.Data.Quests.QuestPrecondition.IMedal|null);
                public quests?: (POGOProtos.Data.Quests.QuestPrecondition.IQuests|null);
                public Condition?: ("quest_template_id"|"level"|"medal"|"quests");
                public static encode(message: POGOProtos.Data.Quests.IQuestPrecondition, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestPrecondition;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestPrecondition;
                public static toObject(message: POGOProtos.Data.Quests.QuestPrecondition, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace QuestPrecondition {

                enum Operator {
                    UNSET = 0,
                    EQUALS = 1,
                    GREATER_THAN = 2,
                    LESS_THAN = 3
                }

                enum QuestPreconditionType {
                    QUEST_PRECONDITION_UNSET = 0,
                    QUEST_PRECONDITION_QUEST = 1,
                    QUEST_PRECONDITION_LEVEL = 2,
                    QUEST_PRECONDITION_MEDAL = 3,
                    QUEST_PRECONDITION_IS_MINOR = 4,
                    QUEST_PRECONDITION_EXCLUSIVE_QUESTS = 5
                }

                interface IQuests {
                    quest_template_ids?: (string[]|null);
                }

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

                interface ILevel {
                    operator?: (POGOProtos.Data.Quests.QuestPrecondition.Operator|null);
                    level?: (number|null);
                }

                class Level implements ILevel {
                    constructor(properties?: POGOProtos.Data.Quests.QuestPrecondition.ILevel);
                    public operator: POGOProtos.Data.Quests.QuestPrecondition.Operator;
                    public level: number;
                    public static encode(message: POGOProtos.Data.Quests.QuestPrecondition.ILevel, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestPrecondition.Level;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestPrecondition.Level;
                    public static toObject(message: POGOProtos.Data.Quests.QuestPrecondition.Level, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IMedal {
                    type?: (POGOProtos.Enums.BadgeType|null);
                    operator?: (POGOProtos.Data.Quests.QuestPrecondition.Operator|null);
                    badge_rank?: (number|null);
                }

                class Medal implements IMedal {
                    constructor(properties?: POGOProtos.Data.Quests.QuestPrecondition.IMedal);
                    public type: POGOProtos.Enums.BadgeType;
                    public operator: POGOProtos.Data.Quests.QuestPrecondition.Operator;
                    public badge_rank: number;
                    public static encode(message: POGOProtos.Data.Quests.QuestPrecondition.IMedal, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestPrecondition.Medal;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestPrecondition.Medal;
                    public static toObject(message: POGOProtos.Data.Quests.QuestPrecondition.Medal, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IQuestReward {
                type?: (POGOProtos.Data.Quests.QuestReward.Type|null);
                exp?: (number|null);
                item?: (POGOProtos.Data.Quests.QuestReward.IItemReward|null);
                stardust?: (number|null);
                candy?: (POGOProtos.Data.Quests.QuestReward.IPokemonCandyReward|null);
                avatar_template_id?: (string|null);
                quest_template_id?: (string|null);
                pokemon_encounter?: (POGOProtos.Data.Quests.QuestReward.IPokemonEncounterReward|null);
            }

            class QuestReward implements IQuestReward {
                constructor(properties?: POGOProtos.Data.Quests.IQuestReward);
                public type: POGOProtos.Data.Quests.QuestReward.Type;
                public exp: number;
                public item?: (POGOProtos.Data.Quests.QuestReward.IItemReward|null);
                public stardust: number;
                public candy?: (POGOProtos.Data.Quests.QuestReward.IPokemonCandyReward|null);
                public avatar_template_id: string;
                public quest_template_id: string;
                public pokemon_encounter?: (POGOProtos.Data.Quests.QuestReward.IPokemonEncounterReward|null);
                public Reward?: ("exp"|"item"|"stardust"|"candy"|"avatar_template_id"|"quest_template_id"|"pokemon_encounter");
                public static encode(message: POGOProtos.Data.Quests.IQuestReward, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestReward;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestReward;
                public static toObject(message: POGOProtos.Data.Quests.QuestReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace QuestReward {

                enum Type {
                    UNSET = 0,
                    EXPERIENCE = 1,
                    ITEM = 2,
                    STARDUST = 3,
                    CANDY = 4,
                    AVATAR_CLOTHING = 5,
                    QUEST = 6,
                    POKEMON_ENCOUNTER = 7
                }

                interface IItemReward {
                    item?: (POGOProtos.Inventory.Item.ItemId|null);
                    amount?: (number|null);
                }

                class ItemReward implements IItemReward {
                    constructor(properties?: POGOProtos.Data.Quests.QuestReward.IItemReward);
                    public item: POGOProtos.Inventory.Item.ItemId;
                    public amount: number;
                    public static encode(message: POGOProtos.Data.Quests.QuestReward.IItemReward, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestReward.ItemReward;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestReward.ItemReward;
                    public static toObject(message: POGOProtos.Data.Quests.QuestReward.ItemReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IPokemonCandyReward {
                    pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                    amount?: (number|null);
                }

                class PokemonCandyReward implements IPokemonCandyReward {
                    constructor(properties?: POGOProtos.Data.Quests.QuestReward.IPokemonCandyReward);
                    public pokemon_id: POGOProtos.Enums.PokemonId;
                    public amount: number;
                    public static encode(message: POGOProtos.Data.Quests.QuestReward.IPokemonCandyReward, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestReward.PokemonCandyReward;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestReward.PokemonCandyReward;
                    public static toObject(message: POGOProtos.Data.Quests.QuestReward.PokemonCandyReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IPokemonEncounterReward {
                    pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                    use_quest_pokemon_encounter_distribuition?: (boolean|null);
                    pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                    is_hidden_ditto?: (boolean|null);
                    ditto_display?: (POGOProtos.Data.IPokemonDisplay|null);
                }

                class PokemonEncounterReward implements IPokemonEncounterReward {
                    constructor(properties?: POGOProtos.Data.Quests.QuestReward.IPokemonEncounterReward);
                    public pokemon_id: POGOProtos.Enums.PokemonId;
                    public use_quest_pokemon_encounter_distribuition: boolean;
                    public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                    public is_hidden_ditto: boolean;
                    public ditto_display?: (POGOProtos.Data.IPokemonDisplay|null);
                    public Type?: ("pokemon_id"|"use_quest_pokemon_encounter_distribuition");
                    public static encode(message: POGOProtos.Data.Quests.QuestReward.IPokemonEncounterReward, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestReward.PokemonEncounterReward;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestReward.PokemonEncounterReward;
                    public static toObject(message: POGOProtos.Data.Quests.QuestReward.PokemonEncounterReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IQuests {
                quest?: (POGOProtos.Data.Quests.IQuest[]|null);
                completed_story_quest?: (string[]|null);
                quest_pokemon_encounter?: (POGOProtos.Data.Quests.IQuestPokemonEncounter[]|null);
                stamp_card?: (POGOProtos.Data.Quests.IQuestStampCard|null);
            }

            class Quests implements IQuests {
                constructor(properties?: POGOProtos.Data.Quests.IQuests);
                public quest: POGOProtos.Data.Quests.IQuest[];
                public completed_story_quest: string[];
                public quest_pokemon_encounter: POGOProtos.Data.Quests.IQuestPokemonEncounter[];
                public stamp_card?: (POGOProtos.Data.Quests.IQuestStampCard|null);
                public static encode(message: POGOProtos.Data.Quests.IQuests, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.Quests;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.Quests;
                public static toObject(message: POGOProtos.Data.Quests.Quests, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IQuestStamp {
                context?: (POGOProtos.Data.Quests.QuestStamp.Context|null);
                timestamp_ms?: (number|Long|null);
            }

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

            namespace QuestStamp {

                enum Context {
                    UNSET = 0,
                    STORY_QUEST = 1,
                    CHALLENGE_QUEST = 2
                }
            }

            interface IQuestStampCard {
                stamp?: (POGOProtos.Data.Quests.IQuestStamp[]|null);
                target?: (number|null);
                remaining_daily_stamps?: (number|null);
                id?: (string|null);
                icon_url?: (string|null);
            }

            class QuestStampCard implements IQuestStampCard {
                constructor(properties?: POGOProtos.Data.Quests.IQuestStampCard);
                public stamp: POGOProtos.Data.Quests.IQuestStamp[];
                public target: number;
                public remaining_daily_stamps: number;
                public id: string;
                public icon_url: string;
                public static encode(message: POGOProtos.Data.Quests.IQuestStampCard, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Quests.QuestStampCard;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Quests.QuestStampCard;
                public static toObject(message: POGOProtos.Data.Quests.QuestStampCard, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITradePokemonQuest {
                friend_id?: (string[]|null);
            }

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

        namespace Raid {

            interface IEventInfo {
                image_url?: (string|null);
                icon_url?: (string|null);
                name_key?: (string|null);
            }

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

            interface IExclusiveRaidCancellation {
                fort_id?: (string|null);
                start_time_ms?: (number|Long|null);
                end_time_ms?: (number|Long|null);
                image_url?: (string|null);
                latitude?: (number|null);
                longitude?: (number|null);
                gym_name?: (string|null);
                rewards?: (POGOProtos.Inventory.ILootItem[]|null);
            }

            class ExclusiveRaidCancellation implements IExclusiveRaidCancellation {
                constructor(properties?: POGOProtos.Data.Raid.IExclusiveRaidCancellation);
                public fort_id: string;
                public start_time_ms: (number|Long);
                public end_time_ms: (number|Long);
                public image_url: string;
                public latitude: number;
                public longitude: number;
                public gym_name: string;
                public rewards: POGOProtos.Inventory.ILootItem[];
                public static encode(message: POGOProtos.Data.Raid.IExclusiveRaidCancellation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.ExclusiveRaidCancellation;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.ExclusiveRaidCancellation;
                public static toObject(message: POGOProtos.Data.Raid.ExclusiveRaidCancellation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IExclusiveTicketInfo {
                raid_seed?: (number|Long|null);
                fort_id?: (string|null);
                start_time_ms?: (number|Long|null);
                end_time_ms?: (number|Long|null);
                image_url?: (string|null);
                latitude?: (number|null);
                longitude?: (number|null);
                gym_name?: (string|null);
                spawn_time_ms?: (number|Long|null);
                is_cancelled?: (boolean|null);
                raid_pokemon?: (POGOProtos.Data.IPokemonData|null);
                inviter?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
                invitee?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
            }

            class ExclusiveTicketInfo implements IExclusiveTicketInfo {
                constructor(properties?: POGOProtos.Data.Raid.IExclusiveTicketInfo);
                public raid_seed: (number|Long);
                public fort_id: string;
                public start_time_ms: (number|Long);
                public end_time_ms: (number|Long);
                public image_url: string;
                public latitude: number;
                public longitude: number;
                public gym_name: string;
                public spawn_time_ms: (number|Long);
                public is_cancelled: boolean;
                public raid_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public inviter?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
                public invitee?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
                public static encode(message: POGOProtos.Data.Raid.IExclusiveTicketInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.ExclusiveTicketInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.ExclusiveTicketInfo;
                public static toObject(message: POGOProtos.Data.Raid.ExclusiveTicketInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ILobby {
                lobby_id?: (number[]|null);
                players?: (POGOProtos.Data.Battle.IBattleParticipant[]|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.Enums.WeatherCondition|null);
            }

            class Lobby implements ILobby {
                constructor(properties?: POGOProtos.Data.Raid.ILobby);
                public lobby_id: number[];
                public players: POGOProtos.Data.Battle.IBattleParticipant[];
                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.Enums.WeatherCondition;
                public static encode(message: POGOProtos.Data.Raid.ILobby, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.Lobby;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.Lobby;
                public static toObject(message: POGOProtos.Data.Raid.Lobby, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IParticipation {
                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.Enums.FriendshipLevelMilestone|null);
                highest_friendship_pokeballs?: (number|null);
            }

            class Participation implements IParticipation {
                constructor(properties?: POGOProtos.Data.Raid.IParticipation);
                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.Enums.FriendshipLevelMilestone;
                public highest_friendship_pokeballs: number;
                public static encode(message: POGOProtos.Data.Raid.IParticipation, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.Participation;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.Participation;
                public static toObject(message: POGOProtos.Data.Raid.Participation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlayerRaidInfo {
                total_completed_raids?: (number|null);
                total_completed_legendary_raids?: (number|null);
                raids?: (POGOProtos.Data.Raid.IRaid[]|null);
            }

            class PlayerRaidInfo implements IPlayerRaidInfo {
                constructor(properties?: POGOProtos.Data.Raid.IPlayerRaidInfo);
                public total_completed_raids: number;
                public total_completed_legendary_raids: number;
                public raids: POGOProtos.Data.Raid.IRaid[];
                public static encode(message: POGOProtos.Data.Raid.IPlayerRaidInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.PlayerRaidInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.PlayerRaidInfo;
                public static toObject(message: POGOProtos.Data.Raid.PlayerRaidInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRaid {
                raid_seed?: (number|Long|null);
                started_ms?: (number|Long|null);
                completed_ms?: (number|Long|null);
                encounter_pokemon_id?: (POGOProtos.Enums.PokemonId|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);
            }

            class Raid implements IRaid {
                constructor(properties?: POGOProtos.Data.Raid.IRaid);
                public raid_seed: (number|Long);
                public started_ms: (number|Long);
                public completed_ms: (number|Long);
                public encounter_pokemon_id: POGOProtos.Enums.PokemonId;
                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 static encode(message: POGOProtos.Data.Raid.IRaid, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.Raid;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.Raid;
                public static toObject(message: POGOProtos.Data.Raid.Raid, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRaidEncounter {
                pokemon?: (POGOProtos.Data.IPokemonData|null);
                encounter_id?: (number|Long|null);
                spawnpoint_id?: (string|null);
                capture_probabilities?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                throws_remaining?: (number|null);
                raid_level?: (POGOProtos.Enums.RaidLevel|null);
                fort_id?: (string|null);
            }

            class RaidEncounter implements IRaidEncounter {
                constructor(properties?: POGOProtos.Data.Raid.IRaidEncounter);
                public pokemon?: (POGOProtos.Data.IPokemonData|null);
                public encounter_id: (number|Long);
                public spawnpoint_id: string;
                public capture_probabilities?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public throws_remaining: number;
                public raid_level: POGOProtos.Enums.RaidLevel;
                public fort_id: string;
                public static encode(message: POGOProtos.Data.Raid.IRaidEncounter, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.RaidEncounter;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.RaidEncounter;
                public static toObject(message: POGOProtos.Data.Raid.RaidEncounter, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRaidInfo {
                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.Data.IPokemonData|null);
                raid_level?: (POGOProtos.Enums.RaidLevel|null);
                complete?: (boolean|null);
                is_exclusive?: (boolean|null);
                is_raid_hidden?: (boolean|null);
            }

            class RaidInfo implements IRaidInfo {
                constructor(properties?: POGOProtos.Data.Raid.IRaidInfo);
                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.Data.IPokemonData|null);
                public raid_level: POGOProtos.Enums.RaidLevel;
                public complete: boolean;
                public is_exclusive: boolean;
                public is_raid_hidden: boolean;
                public static encode(message: POGOProtos.Data.Raid.IRaidInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Raid.RaidInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Raid.RaidInfo;
                public static toObject(message: POGOProtos.Data.Raid.RaidInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISharedExclusiveTicketTrainerInfo {
                codename?: (string|null);
                player_id?: (string|null);
            }

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

        namespace Redeem {

            interface IPokeCandy {
                pokemon_id?: (number|Long|null);
                candy_count?: (number|null);
            }

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

            interface IRedeemedAvatarItem {
                avatar_template_id?: (string|null);
                item_count?: (number|null);
            }

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

            interface IRedeemedItem {
                item?: (POGOProtos.Inventory.Item.ItemId|null);
                item_count?: (number|null);
            }

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

            interface IRedeemPasscodeReward {
                items?: (POGOProtos.Data.Redeem.IRedeemedItem[]|null);
                avatar_items?: (POGOProtos.Data.Redeem.IRedeemedAvatarItem[]|null);
                egg_pokemon?: (POGOProtos.Data.IPokemonData[]|null);
                pokemon?: (POGOProtos.Data.IPokemonData[]|null);
                poke_candy?: (POGOProtos.Data.Redeem.IPokeCandy[]|null);
                stardust?: (number|null);
                pokecoins?: (number|null);
                badges?: (POGOProtos.Enums.BadgeType[]|null);
            }

            class RedeemPasscodeReward implements IRedeemPasscodeReward {
                constructor(properties?: POGOProtos.Data.Redeem.IRedeemPasscodeReward);
                public items: POGOProtos.Data.Redeem.IRedeemedItem[];
                public avatar_items: POGOProtos.Data.Redeem.IRedeemedAvatarItem[];
                public egg_pokemon: POGOProtos.Data.IPokemonData[];
                public pokemon: POGOProtos.Data.IPokemonData[];
                public poke_candy: POGOProtos.Data.Redeem.IPokeCandy[];
                public stardust: number;
                public pokecoins: number;
                public badges: POGOProtos.Enums.BadgeType[];
                public static encode(message: POGOProtos.Data.Redeem.IRedeemPasscodeReward, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Redeem.RedeemPasscodeReward;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Redeem.RedeemPasscodeReward;
                public static toObject(message: POGOProtos.Data.Redeem.RedeemPasscodeReward, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Sfida {

            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.Data.Sfida.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.Data.Sfida.ISfidaMetrics, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Sfida.SfidaMetrics;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Sfida.SfidaMetrics;
                public static toObject(message: POGOProtos.Data.Sfida.SfidaMetrics, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISfidaMetricsUpdate {
                update_type?: (POGOProtos.Data.Sfida.SfidaMetricsUpdate.UpdateType|null);
                timestamp_ms?: (number|Long|null);
                metrics?: (POGOProtos.Data.Sfida.ISfidaMetrics|null);
            }

            class SfidaMetricsUpdate implements ISfidaMetricsUpdate {
                constructor(properties?: POGOProtos.Data.Sfida.ISfidaMetricsUpdate);
                public update_type: POGOProtos.Data.Sfida.SfidaMetricsUpdate.UpdateType;
                public timestamp_ms: (number|Long);
                public metrics?: (POGOProtos.Data.Sfida.ISfidaMetrics|null);
                public static encode(message: POGOProtos.Data.Sfida.ISfidaMetricsUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Sfida.SfidaMetricsUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Sfida.SfidaMetricsUpdate;
                public static toObject(message: POGOProtos.Data.Sfida.SfidaMetricsUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SfidaMetricsUpdate {

                enum UpdateType {
                    UNSET = 0,
                    INITIALIZATION = 1,
                    ACCUMULATION = 2
                }
            }

            interface ISfidaNearbyPokemon {
                pokedex_number?: (number|null);
                uncaught?: (boolean|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            }

            class SfidaNearbyPokemon implements ISfidaNearbyPokemon {
                constructor(properties?: POGOProtos.Data.Sfida.ISfidaNearbyPokemon);
                public pokedex_number: number;
                public uncaught: boolean;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Data.Sfida.ISfidaNearbyPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Sfida.SfidaNearbyPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Sfida.SfidaNearbyPokemon;
                public static toObject(message: POGOProtos.Data.Sfida.SfidaNearbyPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Store {

            interface ICurrencyQuantity {
                currency_type?: (string|null);
                quantity?: (number|null);
            }

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

            interface ICurrencyUpdate {
                currency_name?: (string|null);
                currency_delta?: (number|null);
                currency_balance?: (number|null);
                fiat_purchased_balance?: (number|null);
            }

            class CurrencyUpdate implements ICurrencyUpdate {
                constructor(properties?: POGOProtos.Data.Store.ICurrencyUpdate);
                public currency_name: string;
                public currency_delta: number;
                public currency_balance: number;
                public fiat_purchased_balance: number;
                public static encode(message: POGOProtos.Data.Store.ICurrencyUpdate, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Store.CurrencyUpdate;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Store.CurrencyUpdate;
                public static toObject(message: POGOProtos.Data.Store.CurrencyUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Telemetry {

            interface IArPhotoSession {
                ar_type?: (POGOProtos.Data.Telemetry.ArPhotoSession.ArType|null);
                furthest_step_completed?: (POGOProtos.Data.Telemetry.ArPhotoSession.Step|null);
                num_photos_taken?: (number|null);
                num_photos_shared?: (number|null);
            }

            class ArPhotoSession implements IArPhotoSession {
                constructor(properties?: POGOProtos.Data.Telemetry.IArPhotoSession);
                public ar_type: POGOProtos.Data.Telemetry.ArPhotoSession.ArType;
                public furthest_step_completed: POGOProtos.Data.Telemetry.ArPhotoSession.Step;
                public num_photos_taken: number;
                public num_photos_shared: number;
                public static encode(message: POGOProtos.Data.Telemetry.IArPhotoSession, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.ArPhotoSession;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.ArPhotoSession;
                public static toObject(message: POGOProtos.Data.Telemetry.ArPhotoSession, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ArPhotoSession {

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

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

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

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

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

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

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

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

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

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

            interface IAvatarCustomizationTelemetry {
                avatar_customization_click_id?: (POGOProtos.Enums.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.Data.Telemetry.IAvatarCustomizationTelemetry);
                public avatar_customization_click_id: POGOProtos.Enums.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.Data.Telemetry.IAvatarCustomizationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.AvatarCustomizationTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.AvatarCustomizationTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.AvatarCustomizationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBattlePartyTelemetry {
                battle_party_click_id?: (POGOProtos.Enums.BattlePartyTelemetryIds|null);
                battle_party_count?: (number|null);
                battle_party_number?: (number|null);
            }

            class BattlePartyTelemetry implements IBattlePartyTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IBattlePartyTelemetry);
                public battle_party_click_id: POGOProtos.Enums.BattlePartyTelemetryIds;
                public battle_party_count: number;
                public battle_party_number: number;
                public static encode(message: POGOProtos.Data.Telemetry.IBattlePartyTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.BattlePartyTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.BattlePartyTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.BattlePartyTelemetry, 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.Data.Telemetry.IBootTelemetry);
                public nearest_poi_distance: number;
                public poi_within_one_km_count: number;
                public static encode(message: POGOProtos.Data.Telemetry.IBootTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.BootTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.BootTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.BootTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBootTime {
                duration?: (POGOProtos.Data.Telemetry.IPlatformMetricData|null);
                boot_phase?: (POGOProtos.Data.Telemetry.BootTime.BootPhase|null);
            }

            class BootTime implements IBootTime {
                constructor(properties?: POGOProtos.Data.Telemetry.IBootTime);
                public duration?: (POGOProtos.Data.Telemetry.IPlatformMetricData|null);
                public boot_phase: POGOProtos.Data.Telemetry.BootTime.BootPhase;
                public static encode(message: POGOProtos.Data.Telemetry.IBootTime, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.BootTime;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.BootTime;
                public static toObject(message: POGOProtos.Data.Telemetry.BootTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BootTime {

                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
                }
            }

            interface ICatchPokemonTelemetry {
                status?: (string|null);
                encounter_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IEncounterPokemonTelemetry|null);
                balltype?: (number|null);
                hit_grade?: (number|null);
                curve_ball?: (boolean|null);
                miss_percent?: (number|null);
            }

            class CatchPokemonTelemetry implements ICatchPokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.ICatchPokemonTelemetry);
                public status: string;
                public encounter_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IEncounterPokemonTelemetry|null);
                public balltype: number;
                public hit_grade: number;
                public curve_ball: boolean;
                public miss_percent: number;
                public static encode(message: POGOProtos.Data.Telemetry.ICatchPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.CatchPokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.CatchPokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.CatchPokemonTelemetry, 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.Data.Telemetry.IChangeArTelemetry);
                public ar_enabled: boolean;
                public ar_plus_enabled: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.IChangeArTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.ChangeArTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.ChangeArTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.ChangeArTelemetry, 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.Data.Telemetry.ICheckEncounterTrayInfoTelemetry);
                public berry_tray_info: boolean;
                public ball_tray_info: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.ICheckEncounterTrayInfoTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.CheckEncounterTrayInfoTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.CheckEncounterTrayInfoTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.CheckEncounterTrayInfoTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IClientTelemetryOmni {
                boot_time?: (POGOProtos.Data.Telemetry.IBootTime|null);
                frame_rate?: (POGOProtos.Data.Telemetry.IFrameRate|null);
                generic_click_telemetry?: (POGOProtos.Data.Telemetry.IGenericClickTelemetry|null);
                map_events_telemetry?: (POGOProtos.Data.Telemetry.IMapEventsTelemetry|null);
                spin_pokestop_telemetry?: (POGOProtos.Data.Telemetry.ISpinPokestopTelemetry|null);
                profile_page_telemetry?: (POGOProtos.Data.Telemetry.IProfilePageTelemetry|null);
                shopping_page_telemetry?: (POGOProtos.Data.Telemetry.IShoppingPageTelemetry|null);
                encounter_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IEncounterPokemonTelemetry|null);
                catch_pokemon_telemetry?: (POGOProtos.Data.Telemetry.ICatchPokemonTelemetry|null);
                deploy_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IDeployPokemonTelemetry|null);
                feed_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IFeedPokemonTelemetry|null);
                evolve_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IEvolvePokemonTelemetry|null);
                release_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IReleasePokemonTelemetry|null);
                nickname_pokemon_telemetry?: (POGOProtos.Data.Telemetry.INicknamePokemonTelemetry|null);
                news_page_telemetry?: (POGOProtos.Data.Telemetry.INewsPageTelemetry|null);
                item_telemetry?: (POGOProtos.Data.Telemetry.IItemTelemetry|null);
                battle_party_telemetry?: (POGOProtos.Data.Telemetry.IBattlePartyTelemetry|null);
                passcode_redeem_telemetry?: (POGOProtos.Data.Telemetry.IPasscodeRedeemTelemetry|null);
                link_login_telemetry?: (POGOProtos.Data.Telemetry.ILinkLoginTelemetry|null);
                raid_telemetry?: (POGOProtos.Data.Telemetry.IRaidTelemetry|null);
                push_notification_telemetry?: (POGOProtos.Data.Telemetry.IPushNotificationTelemetry|null);
                avatar_customization_telemetry?: (POGOProtos.Data.Telemetry.IAvatarCustomizationTelemetry|null);
                read_point_of_interest_description_telemetry?: (POGOProtos.Data.Telemetry.IReadPointOfInterestDescriptionTelemetry|null);
                web_telemetry?: (POGOProtos.Data.Telemetry.IWebTelemetry|null);
                change_ar_telemetry?: (POGOProtos.Data.Telemetry.IChangeArTelemetry|null);
                weather_detail_click_telemetry?: (POGOProtos.Data.Telemetry.IWeatherDetailClickTelemetry|null);
                user_issue_weather_report?: (POGOProtos.Data.Player.IUserIssueWeatherReport|null);
                pokemon_inventory_telemetry?: (POGOProtos.Data.Telemetry.IPokemonInventoryTelemetry|null);
                social_telemetry?: (POGOProtos.Data.Telemetry.ISocialTelemetry|null);
                check_encounter_info_telemetry?: (POGOProtos.Data.Telemetry.ICheckEncounterTrayInfoTelemetry|null);
                pokemon_go_plus_telemetry?: (POGOProtos.Data.Telemetry.IPokemonGoPlusTelemetry|null);
                rpc_timing_telemetry?: (POGOProtos.Data.Telemetry.IRpcResponseTelemetry|null);
                social_gift_count_telemetry?: (POGOProtos.Settings.ISocialGiftCountTelemetry|null);
                asset_bundle_telemetry?: (POGOProtos.Data.Telemetry.IAssetBundleDownloadTelemetry|null);
                asset_poi_download_telemetry?: (POGOProtos.Data.Telemetry.IAssetPoiDownloadTelemetry|null);
                asset_stream_download_telemetry?: (POGOProtos.Data.Telemetry.IAssetStreamDownloadTelemetry|null);
                asset_stream_cache_culled_telemetry?: (POGOProtos.Data.Telemetry.IAssetStreamCacheCulledTelemetry|null);
                rpc_socket_timing_telemetry?: (POGOProtos.Data.Telemetry.IRpcSocketResponseTelemetry|null);
                permissions_flow?: (POGOProtos.Data.Telemetry.IPermissionsFlowTelemetry|null);
                device_service_toggle?: (POGOProtos.Data.Telemetry.IDeviceServiceToggleTelemetry|null);
                boot_telemetry?: (POGOProtos.Data.Telemetry.IBootTelemetry|null);
                user_attributes?: (POGOProtos.Data.Player.IUserAttributes|null);
                onboarding_telemetry?: (POGOProtos.Data.Telemetry.IOnboardingTelemetry|null);
                login_action_telemetry?: (POGOProtos.Data.Telemetry.ILoginActionTelemetry|null);
                ar_photo_session_telemetry?: (POGOProtos.Data.Telemetry.IArPhotoSession|null);
                server_data?: (POGOProtos.Data.Telemetry.IPlatformServerData|null);
            }

            class ClientTelemetryOmni implements IClientTelemetryOmni {
                constructor(properties?: POGOProtos.Data.Telemetry.IClientTelemetryOmni);
                public boot_time?: (POGOProtos.Data.Telemetry.IBootTime|null);
                public frame_rate?: (POGOProtos.Data.Telemetry.IFrameRate|null);
                public generic_click_telemetry?: (POGOProtos.Data.Telemetry.IGenericClickTelemetry|null);
                public map_events_telemetry?: (POGOProtos.Data.Telemetry.IMapEventsTelemetry|null);
                public spin_pokestop_telemetry?: (POGOProtos.Data.Telemetry.ISpinPokestopTelemetry|null);
                public profile_page_telemetry?: (POGOProtos.Data.Telemetry.IProfilePageTelemetry|null);
                public shopping_page_telemetry?: (POGOProtos.Data.Telemetry.IShoppingPageTelemetry|null);
                public encounter_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IEncounterPokemonTelemetry|null);
                public catch_pokemon_telemetry?: (POGOProtos.Data.Telemetry.ICatchPokemonTelemetry|null);
                public deploy_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IDeployPokemonTelemetry|null);
                public feed_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IFeedPokemonTelemetry|null);
                public evolve_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IEvolvePokemonTelemetry|null);
                public release_pokemon_telemetry?: (POGOProtos.Data.Telemetry.IReleasePokemonTelemetry|null);
                public nickname_pokemon_telemetry?: (POGOProtos.Data.Telemetry.INicknamePokemonTelemetry|null);
                public news_page_telemetry?: (POGOProtos.Data.Telemetry.INewsPageTelemetry|null);
                public item_telemetry?: (POGOProtos.Data.Telemetry.IItemTelemetry|null);
                public battle_party_telemetry?: (POGOProtos.Data.Telemetry.IBattlePartyTelemetry|null);
                public passcode_redeem_telemetry?: (POGOProtos.Data.Telemetry.IPasscodeRedeemTelemetry|null);
                public link_login_telemetry?: (POGOProtos.Data.Telemetry.ILinkLoginTelemetry|null);
                public raid_telemetry?: (POGOProtos.Data.Telemetry.IRaidTelemetry|null);
                public push_notification_telemetry?: (POGOProtos.Data.Telemetry.IPushNotificationTelemetry|null);
                public avatar_customization_telemetry?: (POGOProtos.Data.Telemetry.IAvatarCustomizationTelemetry|null);
                public read_point_of_interest_description_telemetry?: (POGOProtos.Data.Telemetry.IReadPointOfInterestDescriptionTelemetry|null);
                public web_telemetry?: (POGOProtos.Data.Telemetry.IWebTelemetry|null);
                public change_ar_telemetry?: (POGOProtos.Data.Telemetry.IChangeArTelemetry|null);
                public weather_detail_click_telemetry?: (POGOProtos.Data.Telemetry.IWeatherDetailClickTelemetry|null);
                public user_issue_weather_report?: (POGOProtos.Data.Player.IUserIssueWeatherReport|null);
                public pokemon_inventory_telemetry?: (POGOProtos.Data.Telemetry.IPokemonInventoryTelemetry|null);
                public social_telemetry?: (POGOProtos.Data.Telemetry.ISocialTelemetry|null);
                public check_encounter_info_telemetry?: (POGOProtos.Data.Telemetry.ICheckEncounterTrayInfoTelemetry|null);
                public pokemon_go_plus_telemetry?: (POGOProtos.Data.Telemetry.IPokemonGoPlusTelemetry|null);
                public rpc_timing_telemetry?: (POGOProtos.Data.Telemetry.IRpcResponseTelemetry|null);
                public social_gift_count_telemetry?: (POGOProtos.Settings.ISocialGiftCountTelemetry|null);
                public asset_bundle_telemetry?: (POGOProtos.Data.Telemetry.IAssetBundleDownloadTelemetry|null);
                public asset_poi_download_telemetry?: (POGOProtos.Data.Telemetry.IAssetPoiDownloadTelemetry|null);
                public asset_stream_download_telemetry?: (POGOProtos.Data.Telemetry.IAssetStreamDownloadTelemetry|null);
                public asset_stream_cache_culled_telemetry?: (POGOProtos.Data.Telemetry.IAssetStreamCacheCulledTelemetry|null);
                public rpc_socket_timing_telemetry?: (POGOProtos.Data.Telemetry.IRpcSocketResponseTelemetry|null);
                public permissions_flow?: (POGOProtos.Data.Telemetry.IPermissionsFlowTelemetry|null);
                public device_service_toggle?: (POGOProtos.Data.Telemetry.IDeviceServiceToggleTelemetry|null);
                public boot_telemetry?: (POGOProtos.Data.Telemetry.IBootTelemetry|null);
                public user_attributes?: (POGOProtos.Data.Player.IUserAttributes|null);
                public onboarding_telemetry?: (POGOProtos.Data.Telemetry.IOnboardingTelemetry|null);
                public login_action_telemetry?: (POGOProtos.Data.Telemetry.ILoginActionTelemetry|null);
                public ar_photo_session_telemetry?: (POGOProtos.Data.Telemetry.IArPhotoSession|null);
                public server_data?: (POGOProtos.Data.Telemetry.IPlatformServerData|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"|"server_data");
                public static encode(message: POGOProtos.Data.Telemetry.IClientTelemetryOmni, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.ClientTelemetryOmni;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.ClientTelemetryOmni;
                public static toObject(message: POGOProtos.Data.Telemetry.ClientTelemetryOmni, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDeployPokemonTelemetry {
                status?: (number|null);
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                gym_id?: (string|null);
                team?: (number|null);
                defender_count?: (number|null);
            }

            class DeployPokemonTelemetry implements IDeployPokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IDeployPokemonTelemetry);
                public status: number;
                public pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public gym_id: string;
                public team: number;
                public defender_count: number;
                public static encode(message: POGOProtos.Data.Telemetry.IDeployPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.DeployPokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.DeployPokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.DeployPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDeviceServiceToggleTelemetry {
                device_service_telemetry_id?: (POGOProtos.Enums.DeviceServiceTelemetryIds|null);
                was_enabled?: (boolean|null);
                was_subsequent?: (boolean|null);
            }

            class DeviceServiceToggleTelemetry implements IDeviceServiceToggleTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IDeviceServiceToggleTelemetry);
                public device_service_telemetry_id: POGOProtos.Enums.DeviceServiceTelemetryIds;
                public was_enabled: boolean;
                public was_subsequent: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.IDeviceServiceToggleTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.DeviceServiceToggleTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.DeviceServiceToggleTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.DeviceServiceToggleTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDistribution {
                count?: (number|Long|null);
                mean?: (number|null);
                sum_of_squared_deviation?: (number|null);
                range?: (POGOProtos.Data.Telemetry.Distribution.IRange|null);
                bucket_options?: (POGOProtos.Data.Telemetry.Distribution.IBucketOptions|null);
                bucket_counts?: ((number|Long)[]|null);
            }

            class Distribution implements IDistribution {
                constructor(properties?: POGOProtos.Data.Telemetry.IDistribution);
                public count: (number|Long);
                public mean: number;
                public sum_of_squared_deviation: number;
                public range?: (POGOProtos.Data.Telemetry.Distribution.IRange|null);
                public bucket_options?: (POGOProtos.Data.Telemetry.Distribution.IBucketOptions|null);
                public bucket_counts: (number|Long)[];
                public static encode(message: POGOProtos.Data.Telemetry.IDistribution, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution;
                public static toObject(message: POGOProtos.Data.Telemetry.Distribution, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Distribution {

                interface IBucketOptions {
                    linear_buckets?: (POGOProtos.Data.Telemetry.Distribution.ILinearBuckets|null);
                    exponential_buckets?: (POGOProtos.Data.Telemetry.Distribution.IExponentialBuckets|null);
                    explicit_buckets?: (POGOProtos.Data.Telemetry.Distribution.IExplicitBuckets|null);
                }

                class BucketOptions implements IBucketOptions {
                    constructor(properties?: POGOProtos.Data.Telemetry.Distribution.IBucketOptions);
                    public linear_buckets?: (POGOProtos.Data.Telemetry.Distribution.ILinearBuckets|null);
                    public exponential_buckets?: (POGOProtos.Data.Telemetry.Distribution.IExponentialBuckets|null);
                    public explicit_buckets?: (POGOProtos.Data.Telemetry.Distribution.IExplicitBuckets|null);
                    public BucketType?: ("linear_buckets"|"exponential_buckets"|"explicit_buckets");
                    public static encode(message: POGOProtos.Data.Telemetry.Distribution.IBucketOptions, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.BucketOptions;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.BucketOptions;
                    public static toObject(message: POGOProtos.Data.Telemetry.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.Data.Telemetry.Distribution.BucketOptions.IExplicitBuckets);
                        public bounds: (number|Long)[];
                        public static encode(message: POGOProtos.Data.Telemetry.Distribution.BucketOptions.IExplicitBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.BucketOptions.ExplicitBuckets;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.BucketOptions.ExplicitBuckets;
                        public static toObject(message: POGOProtos.Data.Telemetry.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.Data.Telemetry.Distribution.BucketOptions.IExponentialBuckets);
                        public num_finite_buckets: (number|Long);
                        public growth_factor: number;
                        public scale: number;
                        public static encode(message: POGOProtos.Data.Telemetry.Distribution.BucketOptions.IExponentialBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.BucketOptions.ExponentialBuckets;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.BucketOptions.ExponentialBuckets;
                        public static toObject(message: POGOProtos.Data.Telemetry.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.Data.Telemetry.Distribution.BucketOptions.ILinearBuckets);
                        public num_finite_buckets: (number|Long);
                        public width: (number|Long);
                        public offset: (number|Long);
                        public static encode(message: POGOProtos.Data.Telemetry.Distribution.BucketOptions.ILinearBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.BucketOptions.LinearBuckets;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.BucketOptions.LinearBuckets;
                        public static toObject(message: POGOProtos.Data.Telemetry.Distribution.BucketOptions.LinearBuckets, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }
                }

                interface IExplicitBuckets {
                    bounds?: ((number|Long)[]|null);
                }

                class ExplicitBuckets implements IExplicitBuckets {
                    constructor(properties?: POGOProtos.Data.Telemetry.Distribution.IExplicitBuckets);
                    public bounds: (number|Long)[];
                    public static encode(message: POGOProtos.Data.Telemetry.Distribution.IExplicitBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.ExplicitBuckets;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.ExplicitBuckets;
                    public static toObject(message: POGOProtos.Data.Telemetry.Distribution.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.Data.Telemetry.Distribution.IExponentialBuckets);
                    public num_finite_buckets: (number|Long);
                    public growth_factor: number;
                    public scale: number;
                    public static encode(message: POGOProtos.Data.Telemetry.Distribution.IExponentialBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.ExponentialBuckets;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.ExponentialBuckets;
                    public static toObject(message: POGOProtos.Data.Telemetry.Distribution.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.Data.Telemetry.Distribution.ILinearBuckets);
                    public num_finite_buckets: (number|Long);
                    public width: (number|Long);
                    public offset: (number|Long);
                    public static encode(message: POGOProtos.Data.Telemetry.Distribution.ILinearBuckets, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.LinearBuckets;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.LinearBuckets;
                    public static toObject(message: POGOProtos.Data.Telemetry.Distribution.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.Data.Telemetry.Distribution.IRange);
                    public min: (number|Long);
                    public max: (number|Long);
                    public static encode(message: POGOProtos.Data.Telemetry.Distribution.IRange, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.Distribution.Range;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.Distribution.Range;
                    public static toObject(message: POGOProtos.Data.Telemetry.Distribution.Range, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IEncounterPokemonTelemetry {
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                map_pokemon_type?: (string|null);
                ar_enabled?: (boolean|null);
                ar_plus_enabled?: (boolean|null);
            }

            class EncounterPokemonTelemetry implements IEncounterPokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IEncounterPokemonTelemetry);
                public pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public map_pokemon_type: string;
                public ar_enabled: boolean;
                public ar_plus_enabled: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.IEncounterPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.EncounterPokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.EncounterPokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.EncounterPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEvolvePokemonTelemetry {
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                evolved_pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
            }

            class EvolvePokemonTelemetry implements IEvolvePokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IEvolvePokemonTelemetry);
                public pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public evolved_pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public static encode(message: POGOProtos.Data.Telemetry.IEvolvePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.EvolvePokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.EvolvePokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.EvolvePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFavoritePokemonTelemetry {
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                favored?: (boolean|null);
            }

            class FavoritePokemonTelemetry implements IFavoritePokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IFavoritePokemonTelemetry);
                public pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public favored: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.IFavoritePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.FavoritePokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.FavoritePokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.FavoritePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFeedPokemonTelemetry {
                status?: (number|null);
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                gym_id?: (string|null);
                team?: (number|null);
                defender_count?: (number|null);
                motivation?: (number|null);
                cp_now?: (number|null);
            }

            class FeedPokemonTelemetry implements IFeedPokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IFeedPokemonTelemetry);
                public status: number;
                public pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public gym_id: string;
                public team: number;
                public defender_count: number;
                public motivation: number;
                public cp_now: number;
                public static encode(message: POGOProtos.Data.Telemetry.IFeedPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.FeedPokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.FeedPokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.FeedPokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFrameRate {
                sampled_frame_rate?: (POGOProtos.Data.Telemetry.IPlatformMetricData|null);
            }

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

            interface IGenericClickTelemetry {
                generic_click_id?: (POGOProtos.Enums.GenericClickTelemetryIds|null);
            }

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

            interface IItemTelemetry {
                item_use_click_id?: (POGOProtos.Enums.ItemUseTelemetryIds|null);
                item_id?: (number|null);
            }

            class ItemTelemetry implements IItemTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IItemTelemetry);
                public item_use_click_id: POGOProtos.Enums.ItemUseTelemetryIds;
                public item_id: number;
                public static encode(message: POGOProtos.Data.Telemetry.IItemTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.ItemTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.ItemTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.ItemTelemetry, 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.Data.Telemetry.ILinkLoginTelemetry);
                public linked: boolean;
                public success: string;
                public error: string;
                public active_auth_provider_id: string;
                public provider: string;
                public static encode(message: POGOProtos.Data.Telemetry.ILinkLoginTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.LinkLoginTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.LinkLoginTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.LinkLoginTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ILoginActionTelemetry {
                login_action_id?: (POGOProtos.Enums.LoginActionTelemetryIds|null);
                first_time?: (boolean|null);
                success?: (boolean|null);
                intent_existing?: (boolean|null);
                error?: (string|null);
                auth_status?: (string|null);
            }

            class LoginActionTelemetry implements ILoginActionTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.ILoginActionTelemetry);
                public login_action_id: POGOProtos.Enums.LoginActionTelemetryIds;
                public first_time: boolean;
                public success: boolean;
                public intent_existing: boolean;
                public error: string;
                public auth_status: string;
                public static encode(message: POGOProtos.Data.Telemetry.ILoginActionTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.LoginActionTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.LoginActionTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.LoginActionTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMapEventsTelemetry {
                map_event_click_id?: (POGOProtos.Enums.MapEventsTelemetryIds|null);
                fort_id?: (string|null);
                guard_pokemon_level?: (number[]|null);
                team?: (number|null);
                is_player_in_range?: (boolean|null);
            }

            class MapEventsTelemetry implements IMapEventsTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IMapEventsTelemetry);
                public map_event_click_id: POGOProtos.Enums.MapEventsTelemetryIds;
                public fort_id: string;
                public guard_pokemon_level: number[];
                public team: number;
                public is_player_in_range: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.IMapEventsTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.MapEventsTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.MapEventsTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.MapEventsTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface INewsPageTelemetry {
                news_page_click_id?: (POGOProtos.Enums.NewsPageTelemetryIds|null);
            }

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

            interface INicknamePokemonTelemetry {
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                nickname?: (string|null);
            }

            class NicknamePokemonTelemetry implements INicknamePokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.INicknamePokemonTelemetry);
                public pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
                public nickname: string;
                public static encode(message: POGOProtos.Data.Telemetry.INicknamePokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.NicknamePokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.NicknamePokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.NicknamePokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOnboardingTelemetry {
                onboarding_path?: (POGOProtos.Enums.OnboardingPathIds|null);
                event_id?: (POGOProtos.Enums.OnboardingEventIds|null);
                data?: (number|null);
                conversation?: (string|null);
                ar_status?: (POGOProtos.Enums.OnboardingArStatus|null);
            }

            class OnboardingTelemetry implements IOnboardingTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IOnboardingTelemetry);
                public onboarding_path: POGOProtos.Enums.OnboardingPathIds;
                public event_id: POGOProtos.Enums.OnboardingEventIds;
                public data: number;
                public conversation: string;
                public ar_status: POGOProtos.Enums.OnboardingArStatus;
                public static encode(message: POGOProtos.Data.Telemetry.IOnboardingTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.OnboardingTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.OnboardingTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.OnboardingTelemetry, 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.Data.Telemetry.IPasscodeRedeemTelemetry);
                public result: string;
                public passcode: string;
                public country_code: string;
                public language_code: string;
                public bundle_version: string;
                public static encode(message: POGOProtos.Data.Telemetry.IPasscodeRedeemTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PasscodeRedeemTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PasscodeRedeemTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.PasscodeRedeemTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPermissionsFlowTelemetry {
                permission_context_telemetry_ids?: (POGOProtos.Enums.PermissionContextTelemetryIds|null);
                device_service_telemetry_ids?: (POGOProtos.Enums.DeviceServiceTelemetryIds|null);
                permission_flow_step_telemetry_ids?: (POGOProtos.Enums.PermissionFlowStepTelemetryIds|null);
                success?: (boolean|null);
            }

            class PermissionsFlowTelemetry implements IPermissionsFlowTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IPermissionsFlowTelemetry);
                public permission_context_telemetry_ids: POGOProtos.Enums.PermissionContextTelemetryIds;
                public device_service_telemetry_ids: POGOProtos.Enums.DeviceServiceTelemetryIds;
                public permission_flow_step_telemetry_ids: POGOProtos.Enums.PermissionFlowStepTelemetryIds;
                public success: boolean;
                public static encode(message: POGOProtos.Data.Telemetry.IPermissionsFlowTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PermissionsFlowTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PermissionsFlowTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.PermissionsFlowTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPlatformMetricData {
                common_telemetry?: (POGOProtos.Data.Telemetry.ITelemetryCommon|null);
                long_value?: (number|Long|null);
                double_value?: (number|null);
                boolean_value?: (boolean|null);
                distribution?: (POGOProtos.Data.Telemetry.IDistribution|null);
                metric_kind?: (POGOProtos.Data.Telemetry.PlatformMetricData.Kind|null);
            }

            class PlatformMetricData implements IPlatformMetricData {
                constructor(properties?: POGOProtos.Data.Telemetry.IPlatformMetricData);
                public common_telemetry?: (POGOProtos.Data.Telemetry.ITelemetryCommon|null);
                public long_value: (number|Long);
                public double_value: number;
                public boolean_value: boolean;
                public distribution?: (POGOProtos.Data.Telemetry.IDistribution|null);
                public metric_kind: POGOProtos.Data.Telemetry.PlatformMetricData.Kind;
                public DatapointValue?: ("long_value"|"double_value"|"boolean_value"|"distribution");
                public static encode(message: POGOProtos.Data.Telemetry.IPlatformMetricData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PlatformMetricData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PlatformMetricData;
                public static toObject(message: POGOProtos.Data.Telemetry.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 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.Data.Telemetry.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.Data.Telemetry.IPlatformServerData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PlatformServerData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PlatformServerData;
                public static toObject(message: POGOProtos.Data.Telemetry.PlatformServerData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonGoPlusTelemetry {
                pgp_event_ids?: (POGOProtos.Enums.PokemonGoPlusIds|null);
                count?: (number|null);
                version?: (number|null);
            }

            class PokemonGoPlusTelemetry implements IPokemonGoPlusTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IPokemonGoPlusTelemetry);
                public pgp_event_ids: POGOProtos.Enums.PokemonGoPlusIds;
                public count: number;
                public version: number;
                public static encode(message: POGOProtos.Data.Telemetry.IPokemonGoPlusTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PokemonGoPlusTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PokemonGoPlusTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.PokemonGoPlusTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonInventoryTelemetry {
                pokemon_inventory_click_ids?: (POGOProtos.Enums.PokemonInventoryTelemetryIds|null);
                sort_id?: (string|null);
            }

            class PokemonInventoryTelemetry implements IPokemonInventoryTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IPokemonInventoryTelemetry);
                public pokemon_inventory_click_ids: POGOProtos.Enums.PokemonInventoryTelemetryIds;
                public sort_id: string;
                public static encode(message: POGOProtos.Data.Telemetry.IPokemonInventoryTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PokemonInventoryTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PokemonInventoryTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.PokemonInventoryTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokemonTelemetry {
                pokemon_id?: (number|null);
                cp?: (number|null);
                weight_kg?: (number|null);
                height_m?: (number|null);
                pokemon_level?: (number|null);
            }

            class PokemonTelemetry implements IPokemonTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IPokemonTelemetry);
                public pokemon_id: number;
                public cp: number;
                public weight_kg: number;
                public height_m: number;
                public pokemon_level: number;
                public static encode(message: POGOProtos.Data.Telemetry.IPokemonTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PokemonTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PokemonTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.PokemonTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPokestopReward {
                item_id?: (number|null);
                item_count?: (number|null);
            }

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

            interface IProfilePageTelemetry {
                profile_page_click_id?: (POGOProtos.Enums.ProfilePageTelemetryIds|null);
            }

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

            interface IPushNotificationTelemetry {
                notification_id?: (POGOProtos.Enums.PushNotificationTelemetryIds|null);
                category?: (string|null);
            }

            class PushNotificationTelemetry implements IPushNotificationTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IPushNotificationTelemetry);
                public notification_id: POGOProtos.Enums.PushNotificationTelemetryIds;
                public category: string;
                public static encode(message: POGOProtos.Data.Telemetry.IPushNotificationTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.PushNotificationTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.PushNotificationTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.PushNotificationTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRaidTelemetry {
                raid_telemetry_id?: (POGOProtos.Enums.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.Data.Telemetry.IRaidTelemetry);
                public raid_telemetry_id: POGOProtos.Enums.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.Data.Telemetry.IRaidTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.RaidTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.RaidTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.RaidTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IReadPointOfInterestDescriptionTelemetry {
                result?: (string|null);
                fort_id?: (string|null);
                fort_type?: (number|null);
            }

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

            interface IReleasePokemonTelemetry {
                pokemon?: (POGOProtos.Data.Telemetry.IPokemonTelemetry|null);
            }

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

            interface IRpcResponseTelemetry {
                window_duration?: (number|null);
                response_timings?: (POGOProtos.Data.Telemetry.IRpcResponseTime[]|null);
            }

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

            interface IRpcResponseTime {
                rpc_id?: (POGOProtos.Networking.Requests.RequestType|null);
                count_call?: (number|null);
                average_response_time?: (number|null);
            }

            class RpcResponseTime implements IRpcResponseTime {
                constructor(properties?: POGOProtos.Data.Telemetry.IRpcResponseTime);
                public rpc_id: POGOProtos.Networking.Requests.RequestType;
                public count_call: number;
                public average_response_time: number;
                public static encode(message: POGOProtos.Data.Telemetry.IRpcResponseTime, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.RpcResponseTime;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.RpcResponseTime;
                public static toObject(message: POGOProtos.Data.Telemetry.RpcResponseTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IRpcSocketResponseTelemetry {
                window_duration?: (number|null);
                response_timings?: (POGOProtos.Data.Telemetry.IRpcSocketResponseTime[]|null);
            }

            class RpcSocketResponseTelemetry implements IRpcSocketResponseTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IRpcSocketResponseTelemetry);
                public window_duration: number;
                public response_timings: POGOProtos.Data.Telemetry.IRpcSocketResponseTime[];
                public static encode(message: POGOProtos.Data.Telemetry.IRpcSocketResponseTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.RpcSocketResponseTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.RpcSocketResponseTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.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.Data.Telemetry.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.Data.Telemetry.IRpcSocketResponseTime, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.RpcSocketResponseTime;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.RpcSocketResponseTime;
                public static toObject(message: POGOProtos.Data.Telemetry.RpcSocketResponseTime, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IShoppingPageTelemetry {
                shopping_page_click_id?: (POGOProtos.Enums.ShoppingPageTelemetryIds|null);
            }

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

            interface ISocialTelemetry {
                social_click_id?: (POGOProtos.Enums.SocialTelemetryIds|null);
                pages_scrolled_in_friends_list?: (number|null);
            }

            class SocialTelemetry implements ISocialTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.ISocialTelemetry);
                public social_click_id: POGOProtos.Enums.SocialTelemetryIds;
                public pages_scrolled_in_friends_list: number;
                public static encode(message: POGOProtos.Data.Telemetry.ISocialTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.SocialTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.SocialTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.SocialTelemetry, 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.Data.Telemetry.IPokestopReward[]|null);
                total_rewards?: (number|null);
            }

            class SpinPokestopTelemetry implements ISpinPokestopTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.ISpinPokestopTelemetry);
                public result: string;
                public fort_id: string;
                public fort_type: number;
                public pokestop_rewards: POGOProtos.Data.Telemetry.IPokestopReward[];
                public total_rewards: number;
                public static encode(message: POGOProtos.Data.Telemetry.ISpinPokestopTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.SpinPokestopTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.SpinPokestopTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.SpinPokestopTelemetry, 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.Data.Telemetry.ITelemetryCommon);
                public timestamp: (number|Long);
                public correlation_vector: string;
                public event_id: string;
                public client_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Data.Telemetry.ITelemetryCommon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.TelemetryCommon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.TelemetryCommon;
                public static toObject(message: POGOProtos.Data.Telemetry.TelemetryCommon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWeatherDetailClickTelemetry {
                gameplay_weather_type?: (string|null);
                alert_active?: (boolean|null);
                severity?: (number|null);
            }

            class WeatherDetailClickTelemetry implements IWeatherDetailClickTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IWeatherDetailClickTelemetry);
                public gameplay_weather_type: string;
                public alert_active: boolean;
                public severity: number;
                public static encode(message: POGOProtos.Data.Telemetry.IWeatherDetailClickTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.WeatherDetailClickTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.WeatherDetailClickTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.WeatherDetailClickTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWebTelemetry {
                web_click_ids?: (POGOProtos.Enums.WebTelemetryIds|null);
                url?: (string|null);
                fort_id?: (string|null);
            }

            class WebTelemetry implements IWebTelemetry {
                constructor(properties?: POGOProtos.Data.Telemetry.IWebTelemetry);
                public web_click_ids: POGOProtos.Enums.WebTelemetryIds;
                public url: string;
                public fort_id: string;
                public static encode(message: POGOProtos.Data.Telemetry.IWebTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Telemetry.WebTelemetry;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Telemetry.WebTelemetry;
                public static toObject(message: POGOProtos.Data.Telemetry.WebTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Token {

            interface IFbToken {
                token?: (string|null);
            }

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

            interface IGoogleToken {
                id_token?: (string|null);
            }

            class GoogleToken implements IGoogleToken {
                constructor(properties?: POGOProtos.Data.Token.IGoogleToken);
                public id_token: string;
                public static encode(message: POGOProtos.Data.Token.IGoogleToken, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Token.GoogleToken;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Token.GoogleToken;
                public static toObject(message: POGOProtos.Data.Token.GoogleToken, 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.Data.Token.IPtcToken);
                public token: string;
                public expiration: number;
                public static encode(message: POGOProtos.Data.Token.IPtcToken, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Token.PtcToken;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Token.PtcToken;
                public static toObject(message: POGOProtos.Data.Token.PtcToken, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISfidaAuthToken {
                response_token?: (Uint8Array|null);
                sfida_id?: (string|null);
            }

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

            interface ISuperAwesomeToken {
                token?: (string|null);
            }

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

        namespace Trading {

            interface IExcludedPokemon {
                pokemon_id?: (number|Long|null);
                exclusion_reason?: (POGOProtos.Data.Trading.ExcludedPokemon.ExclusionReason|null);
            }

            class ExcludedPokemon implements IExcludedPokemon {
                constructor(properties?: POGOProtos.Data.Trading.IExcludedPokemon);
                public pokemon_id: (number|Long);
                public exclusion_reason: POGOProtos.Data.Trading.ExcludedPokemon.ExclusionReason;
                public static encode(message: POGOProtos.Data.Trading.IExcludedPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Trading.ExcludedPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Trading.ExcludedPokemon;
                public static toObject(message: POGOProtos.Data.Trading.ExcludedPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ExcludedPokemon {

                enum ExclusionReason {
                    UNSET = 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
                }
            }

            interface ITrading {
                state?: (POGOProtos.Data.Trading.Trading.TradingState|null);
                expiration_ms?: (number|Long|null);
                player?: (POGOProtos.Data.Trading.ITradingPlayer|null);
                friend?: (POGOProtos.Data.Trading.ITradingPlayer|null);
                trading_s2_cell_id?: (number|Long|null);
                transaction_log?: (string|null);
                friendship_level_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                is_special_trading?: (boolean|null);
                pre_trading_friendship_level?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
            }

            class Trading implements ITrading {
                constructor(properties?: POGOProtos.Data.Trading.ITrading);
                public state: POGOProtos.Data.Trading.Trading.TradingState;
                public expiration_ms: (number|Long);
                public player?: (POGOProtos.Data.Trading.ITradingPlayer|null);
                public friend?: (POGOProtos.Data.Trading.ITradingPlayer|null);
                public trading_s2_cell_id: (number|Long);
                public transaction_log: string;
                public friendship_level_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                public is_special_trading: boolean;
                public pre_trading_friendship_level?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                public static encode(message: POGOProtos.Data.Trading.ITrading, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Trading.Trading;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Trading.Trading;
                public static toObject(message: POGOProtos.Data.Trading.Trading, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Trading {

                enum TradingState {
                    UNSET = 0,
                    PRIMORDIAL = 1,
                    WAIT = 2,
                    ACTIVE = 3,
                    CONFIRMED = 4,
                    FINISHED = 5
                }
            }

            interface ITradingPlayer {
                player_id?: (string|null);
                public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                excluded_pokemon?: (POGOProtos.Data.Trading.IExcludedPokemon[]|null);
                trading_pokemon?: (POGOProtos.Data.Trading.ITradingPokemon|null);
                bonus?: (POGOProtos.Inventory.ILoot|null);
                price?: (POGOProtos.Inventory.ILoot|null);
                can_afford_trading?: (boolean|null);
                has_confirmed?: (boolean|null);
            }

            class TradingPlayer implements ITradingPlayer {
                constructor(properties?: POGOProtos.Data.Trading.ITradingPlayer);
                public player_id: string;
                public public_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public excluded_pokemon: POGOProtos.Data.Trading.IExcludedPokemon[];
                public trading_pokemon?: (POGOProtos.Data.Trading.ITradingPokemon|null);
                public bonus?: (POGOProtos.Inventory.ILoot|null);
                public price?: (POGOProtos.Inventory.ILoot|null);
                public can_afford_trading: boolean;
                public has_confirmed: boolean;
                public static encode(message: POGOProtos.Data.Trading.ITradingPlayer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Trading.TradingPlayer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Trading.TradingPlayer;
                public static toObject(message: POGOProtos.Data.Trading.TradingPlayer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITradingPokemon {
                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.Enums.PokemonMove|null);
                move2?: (POGOProtos.Enums.PokemonMove|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                captured_s2_cell_id?: (number|Long|null);
                traded_pokemon?: (POGOProtos.Data.IPokemonData|null);
                pokeball?: (POGOProtos.Inventory.Item.IItemData|null);
                individual_attack?: (number|null);
                individual_defense?: (number|null);
                individual_stamina?: (number|null);
                nickname?: (string|null);
                favorite?: (boolean|null);
                move3?: (POGOProtos.Enums.PokemonMove|null);
                creation_time_ms?: (number|Long|null);
            }

            class TradingPokemon implements ITradingPokemon {
                constructor(properties?: POGOProtos.Data.Trading.ITradingPokemon);
                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.Enums.PokemonMove;
                public move2: POGOProtos.Enums.PokemonMove;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public captured_s2_cell_id: (number|Long);
                public traded_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public pokeball?: (POGOProtos.Inventory.Item.IItemData|null);
                public individual_attack: number;
                public individual_defense: number;
                public individual_stamina: number;
                public nickname: string;
                public favorite: boolean;
                public move3: POGOProtos.Enums.PokemonMove;
                public creation_time_ms: (number|Long);
                public static encode(message: POGOProtos.Data.Trading.ITradingPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Data.Trading.TradingPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Data.Trading.TradingPokemon;
                public static toObject(message: POGOProtos.Data.Trading.TradingPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }
    }

    namespace Enums {

        enum ActivityType {
            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_SHARE_EX_RAID_PASS = 41,
            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
        }

        enum ArContext {
            ENCOUNTER = 0
        }

        enum ArPlusMode {
            ARPLUS = 0,
            AR = 1,
            NORMAL = 2
        }

        enum AssetBundleStatus {
            UNLOADED = 0,
            LOADING = 1,
            LOADED = 2,
            FAILED_ASSET_BUNDLE_STATUS = 3
        }

        enum AvatarCompletion {
            SUCCESS_AVATAR_COMPLETION = 0,
            QUIT = 1
        }

        enum BadgeType {
            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_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
        }

        enum BattleResultsExit {
            LEAVE_GYM = 0,
            LEAVE_BATTLE = 1,
            CONTINUE_BATTLE = 2
        }

        enum BuddySize {
            BUDDY_MEDIUM = 0,
            BUDDY_SHOULDER = 1,
            BUDDY_BIG = 2,
            BUDDY_FLYING = 3,
            BUDDY_BABY = 4
        }

        enum CameraInterpolation {
            CAM_INTERP_CUT = 0,
            CAM_INTERP_LINEAR = 1,
            CAM_INTERP_SMOOTH = 2,
            CAM_INTERP_SMOOTH_ROT_LINEAR_MOVE = 3,
            CAM_INTERP_DEPENDS = 4
        }

        enum CameraTarget {
            CAM_TARGET_ATTACKER = 0,
            CAM_TARGET_ATTACKER_EDGE = 1,
            CAM_TARGET_ATTACKER_GROUND = 2,
            CAM_TARGET_DEFENDER = 3,
            CAM_TARGET_DEFENDER_EDGE = 4,
            CAM_TARGET_DEFENDER_GROUND = 5,
            CAM_TARGET_ATTACKER_DEFENDER = 6,
            CAM_TARGET_ATTACKER_DEFENDER_EDGE = 7,
            CAM_TARGET_DEFENDER_ATTACKER = 8,
            CAM_TARGET_DEFENDER_ATTACKER_EDGE = 9,
            CAM_TARGET_ATTACKER_DEFENDER_MIRROR = 11,
            CAM_TARGET_SHOULDER_ATTACKER_DEFENDER = 12,
            CAM_TARGET_SHOULDER_ATTACKER_DEFENDER_MIRROR = 13,
            CAM_TARGET_ATTACKER_DEFENDER_WORLD = 14
        }

        enum CameraType {
            DEFAULT_CAMERA = 0,
            SHOULDER = 1,
            ENEMY_POKEMON_FOCUS = 2,
            MY_POKEMON_FOCUS = 3
        }

        enum CameraZoomInLevel {
            DEFAULT_CAMERA_ZOOM_IN_LEVEL = 0,
            NICE_CAMERA_ZOOM_IN_LEVEL = 1,
            GREAT_CAMERA_ZOOM_IN_LEVEL = 2,
            EXCELLENT_CAMERA_ZOOM_IN_LEVEL = 3
        }

        enum CentralState {
            UNKNOWN_CENTRAL_STATE = 0,
            RESETTING = 1,
            UNSUPPORTED = 2,
            UNAUTHORIZED = 3,
            POWERED_OFF = 4,
            POWERED_ON = 5
        }

        enum CombatPlayerFinishState {
            WINNER = 0,
            LOSER = 1,
            DRAW = 2
        }

        enum CombatRewardStatus {
            UNSET_REWARD_STATUS = 0,
            REWARDS_GRANTED = 1,
            MAX_REWARDS_RECEIVED = 2,
            PLAYER_BAG_FULL = 3
        }

        enum CombatType {
            COMBAT_TYPE_UNSET = 0,
            SOLO = 1,
            QR_CODE = 2,
            FRIENDS = 3,
            NEARBY_COMBAT = 4
        }

        enum ConditionType {
            UNSET_CONDITION = 0,
            WITH_POKEMON_CP_LIMIT = 1,
            WITH_PLAYER_LEVEL = 2,
            WITH_POKEMON_TYPE = 3,
            WITH_POKEMON_CATEGORY = 4
        }

        enum Costume {
            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
        }

        enum CurrencyType {
            UNKNOWN_CURRENCY_TYPE = 0,
            POKECOIN = 1,
            STARDUST = 2
        }

        enum EncounterType {
            SPAWN_POINT = 0,
            INCENSE = 1,
            DISK = 2,
            POST_RAID = 3,
            STORY_QUEST = 4,
            QUEST_STAMP_CARD = 5,
            CHALLENGE_QUEST = 6,
            PHOTOBOMB = 7
        }

        enum Filter {
            UNSET_FILTER = 0,
            ALL = 1,
            DEFAULT = 2,
            OWNED = 3,
            FEATURED = 4,
            PURCHASABLE = 5,
            UNLOCKABLE = 6
        }

        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
        }

        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 Gender {
            GENDER_UNSET = 0,
            MALE = 1,
            FEMALE = 2,
            GENDERLESS = 3
        }

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

        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
        }

        enum IdentityProvider {
            UNSET_IDENTITY_PROVIDER = 0,
            GOOGLE = 1,
            PTC = 2,
            FACEBOOK = 3,
            BACKGROUND = 4,
            INTERNAL = 5,
            SFIDA = 6,
            SUPER_AWESOME = 7
        }

        enum IncubationResult {
            SUCCESS_INCUBATION_RESULT = 0,
            FAILURE = 1
        }

        enum InvitationType {
            INVITATION_TYPE_UNSET = 0,
            INVITATION_TYPE_CODE = 1,
            INVITATION_TYPE_FACEBOOK = 2,
            INVITATION_TYPE_SERVER_REQUEST = 3
        }

        enum ItemCategory {
            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
        }

        enum ItemEffect {
            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 NotificationCategory {
            UNSET_NOTIFICATION_CATEGORY = 0,
            GYM_REMOVAL = 1,
            POKEMON_HUNGRY = 2,
            EXCLUSIVE_RAID_INVITE = 3,
            EXCLUSIVE_RAID_CANCELLATION = 4,
            SHARED_EXCLUSIVE_RAID_INVITE = 5,
            GIFTBOX_INCOMING = 6,
            GIFTBOX_DELIVERED = 7,
            FRIENDSHIP_MILESTONE_REWARD = 8,
            GYM_BATTLE_FRIENDSHIP_INCREMENT = 9,
            BGMODE_EGG_HATCH = 10,
            BGMODE_BUDDY_CANDY = 11,
            BGMODE_WEEKLY_FITNESS_REPORT = 12,
            BGMODE_OFF_SESSION_DISTANCE = 13,
            BGMODE_POI_PROXIMITY = 14,
            COMBAT_CHALLENGE_OPENED = 15,
            FRIEND_INVITE_RECEIVED = 16,
            FRIEND_INVITE_ACCEPTED = 17,
            BGMODE_NAMED_BUDDY_CANDY = 18,
            APP_BADGE_ONLY = 19
        }

        enum NotificationState {
            UNSET_STATE = 0,
            VIEWED = 1
        }

        enum NotificationType {
            NO_NOTIFICATIONS = 0,
            POKEMON_NOTIFICATIONS = 1,
            POKESTOP_NOTIFICATIONS = 2,
            ALL_NOTIFICATIONS = 3
        }

        enum OnboardingArStatus {
            UNSET_ONBOARDING_AR_STATUS = 0,
            OFF = 1,
            AR_STANDARD = 2,
            AR_PLUS = 3
        }

        enum OnboardingEventIds {
            TOS_ACCEPTED = 0,
            PRIVACY_ACCEPTED = 1,
            CONVERSATION = 2,
            ENCOUNTER_ENTER = 3,
            ENCOUNTER_LEAVE = 4,
            AVATAR_SELECTION_ONBOARDING = 5,
            AVATAR_GENDER = 6,
            AVATAR_GENDER_CHOSEN = 7,
            AVATAR_HEAD_CHOSEN = 8,
            AVATAR_BODY_CHOSEN = 9,
            AVATAR_TRY_AGAIN = 10,
            AVATAR_ACCEPTED = 11,
            NAME_ENTRY = 12,
            NAME_UNAVAILABLE = 13,
            NAME_ACCEPTED = 14,
            POKEDEX_TUTORIAL_STARTED = 15,
            POKEDEX_TUTORIAL_INFO_PANEL_EXIT_PRESSED = 16,
            POKEDEX_EXIT_PRESSED = 17,
            EGG_TUTORIAL_STARTED = 18,
            EGG_TUTORIAL_PRESS = 19,
            EGG_TUTORIAL_FINISHED = 20,
            POKESTOP_LETSGO = 21,
            WILD_POKEMON_ENCOUNTER_ENTERED = 22,
            WILD_POKEMON_CAUGHT = 23,
            AR_STANDARD_ENABLED = 24,
            AR_STANDARD_REJECTED = 25,
            AR_PLUS_ENABLED = 26,
            AR_PLUS_REJECTED = 27
        }

        enum OnboardingPathIds {
            V1 = 0,
            V2 = 1
        }

        enum Platform {
            UNSET = 0,
            IOS = 1,
            ANDROID = 2,
            OSX = 3,
            WINDOWS = 4,
            APPLE_WATCH = 5
        }

        enum PlayerOnboardingPath {
            UNSET_PLAYER_ONBOARDING_PATH = 0,
            V1_PLAYER_ONBOARDING_PATH = 1,
            V2_PLAYER_ONBOARDING_PATH = 2
        }

        enum PluginState {
            UNKNOWN_PLUGIN_STATE = 0,
            INITIALIZED = 1,
            STARTING = 2,
            STARTED = 3,
            RESUMED = 4,
            PAUSED = 5,
            STOPPED = 6
        }

        enum PoiSubmissionTutorialPage {
            WHAT_IS_POKESTOP = 0,
            SUBMIT_FOR_REVIEW = 1,
            HOW_TO_CHOOSE_A_LOCATION = 2,
            DESCRIBE_A_LOCATION = 3
        }

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

        enum PokemonClass {
            POKEMON_CLASS_NORMAL = 0,
            POKEMON_CLASS_LEGENDARY = 1,
            POKEMON_CLASS_MYTHIC = 2
        }

        enum PokemonCreateContext {
            CREATE_CONTEXT_WILD = 0,
            CREATE_CONTEXT_EGG = 1,
            CREATE_CONTEXT_EVOLVE = 2
        }

        enum PokemonFamilyId {
            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_HYPNO = 97,
            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_MELTAN = 808
        }

        enum PokemonGoPlusIds {
            UNDEFINED_POKEMON_GO_PLUS_EVENT = 0,
            CANNOT_CONNECT_TO_PGP = 1,
            REGISTERING_PGP_FAILED = 2,
            REGISTERING_RETRY = 3,
            CONNECTION_SUCCESS = 4,
            PGP_DISCONNECTED_BY_USER = 5,
            PGP_DISCONNECTED_BY_TIMEOUT = 6,
            PGP_DISCONNECTED_BY_ERROR = 7,
            PGP_LOW_BATTERY = 8,
            BLUETOOTH_SENT_ERROR = 9,
            PGP_SEEN_BY_DEVICE = 10,
            POKEMON_CAUGHT = 11,
            POKEMON_NOT_CAUGHT = 12,
            POKEMON_NOT_CAUGHT_DUE_ERROR = 13,
            POKESTOP_SPUN = 14,
            POKESTOP_NOT_SPUN_DUE_ERROR = 15
        }

        enum DeviceKind {
            POKEMON_GO_PLUS_KIND = 0,
            POKE_BALL_PLUS = 1
        }

        enum PokemonId {
            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,
            MELTAN = 808,
            MELMETAL = 809
        }

        enum PokemonMove {
            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
        }

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

        enum PokemonNature {
            NATURE_UNKNOWN = 0,
            NATURE_STOIC = 1,
            NATURE_ASSASSIN = 2,
            NATURE_GUARDIAN = 3,
            NATURE_RAIDER = 4,
            NATURE_PROTECTOR = 5,
            NATURE_SENTRY = 6,
            NATURE_CHAMPION = 7
        }

        enum PokemonRarity {
            POKEMON_RARITY_NORMAL = 0,
            POKEMON_RARITY_LEGENDARY = 1,
            POKEMON_RARITY_MYTHIC = 2
        }

        enum PokemonTradingType {
            UNSET_POKEMON_TRADING = 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
        }

        enum PokemonType {
            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 PresentationType {
            UNKNOWN_PRESENTATION_TYPE = 0,
            CATEGORY = 1,
            SORT = 2,
            SALE = 3
        }

        enum QuestType {
            QUEST_UNKNOWN_TYPE = 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
        }

        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
        }

        enum SfidaConnectState {
            DISCONNECTED = 0,
            DISCONNECTING = 1,
            CONNECTED = 2,
            DISCOVERED = 3,
            CERTIFIED = 4,
            SOFTWARE_UPDATE = 5,
            FAILED = 6,
            CONNECTING = 7
        }

        enum ShareExRaidPassResult {
            SHARE_EX_RAID_PASS_UNSET = 0,
            SHARE_EX_RAID_PASS_SUCCESS = 1,
            ERROR_FRIEND_ALREADY_INVITED_TO_SAME_RAID = 2,
            ERROR_EX_RAID_PASS_ALREADY_SHARED = 3,
            ERROR_FRIEND_ALREADY_HAS_SHARED_EX_PASS_IN_INVENTORY = 4,
            ERROR_TOO_LOW_FRIENDSHIP_LEVEL = 5,
            ERROR_FRIEND_NOT_FOUND = 6,
            ERROR_EX_RAID_ALREADY_STARTED = 7,
            ERROR_EX_RAID_INVALID = 8,
            ERROR_EX_RAID_PASS_NOT_FOUND = 9,
            ERROR_UNKNOWN = 10
        }

        enum SocialAction {
            UNKNOWN_SOCIAL_ACTION = 0,
            SEARCH_PLAYER = 10000,
            SEND_FRIEND_INVITE = 10002,
            CANCEL_FRIEND_INVITE = 10003,
            ACCEPT_FRIEND_INVITE = 10004,
            DECLINE_FRIEND_INVITE = 10005,
            LIST_FRIENDS = 10006,
            LIST_OUTGOING_FRIEND_INVITES = 10007,
            LIST_INCOMING_FRIEND_INVITES = 10008,
            REMOVE_FRIEND = 10009,
            LIST_FRIEND_STATUS = 10010,
            SEND_FACEBOOK_FRIEND_INVITE = 10011,
            IS_MY_FRIEND = 10012,
            CREATE_INVITE_CODE = 10013,
            GET_FACEBOOK_FRIEND_LIST = 10014,
            UPDATE_FACEBOOK_STATUS = 10015,
            REGISTER_PUSH_NOTIFICATION_SOCIAL_ACTION = 10101,
            UNREGISTER_PUSH_NOTIFICATION_SOCIAL_ACTION = 10102,
            UPDATE_NOTIFICATION = 10103,
            OPT_OUT_PUSH_NOTIFICATION_CATEGORY_SOCIAL_ACTION = 10104,
            GET_INBOX = 10105
        }

        enum SocialNotificationCategory {
            UNSET_SOCIAL_NOTIFICATION = 0,
            FRIEND_INVITE_RECEIVED_SOCIAL_NOTIFICATION = 1,
            FRIEND_INVITE_ACCEPTED_SOCIAL_NOTIFICATION = 2
        }

        enum SocialNotificationVariableName {
            UNSET_SOCIAL_NOTIFICATION_VARIABLE_NAME = 0,
            SOCIAL_CODENAME = 1,
            SOCIAL_TEAM = 2,
            SOCIAL_PLAYER_SUMMARY = 3
        }

        enum TeamColor {
            NEUTRAL = 0,
            BLUE = 1,
            RED = 2,
            YELLOW = 3
        }

        enum DeviceServiceTelemetryIds {
            UNDEFINED_DEVICE_SERVICE = 0,
            FITNESS = 1,
            SMART_WATCH = 2,
            SFIDA_DEVICE_SERVICE = 3
        }

        enum PermissionContextTelemetryIds {
            UNDEFINED_PERMISSION_CONTEXT = 0,
            EGG_HATCH = 1,
            BUDDY_CANDY_FOUND = 2,
            PLAYER_PROFILE_CLICKED = 3,
            SMART_WATCH_INSTALLED = 4,
            SFIDA_SESSION_STARTED = 5,
            SETTINGS_TOGGLE = 6
        }

        enum PermissionFlowStepTelemetryIds {
            UNDEFINED_PERMISSION_FLOW_STEP = 0,
            INITIAL_PROMPT = 1,
            FITNESS_PERMISSION = 2,
            LOCATION_PERMISSION = 3
        }

        enum AssetTelemetryIds {
            UNDEFINED_ASSET_EVENT = 0,
            DOWNLOAD_START = 1,
            DOWNLOAD_FINISHED = 2,
            DOWNLOAD_FAILED = 3,
            ASSET_RETRIEVED_FROM_CACHE = 4,
            CACHE_THRASH = 5
        }

        enum ClientTelemetryIds {
            UNDEFINED = 0,
            BOOT_TIME = 1,
            FRAME_RATE = 2,
            GENERIC_CLICK = 3,
            MAP_EVENT = 4,
            SPIN_POKESTOP = 5,
            PROFILE_PAGE = 6,
            SHOPPING_PAGE = 7,
            ENCOUNTER_POKEMON = 8,
            CATCH_POKEMON = 9,
            DEPLOY_POKEMON = 10,
            FEED_POKEMON = 11,
            EVOLVE_POKEMON = 12,
            RELEASE_POKEMON = 13,
            NICKNAME_POKEMON = 14,
            NEWS_PAGE = 15,
            ITEM = 16,
            BATTLE_PARTY = 17,
            PASSCODE_REDEEM = 18,
            LINK_LOGIN = 19,
            RAID = 20,
            PUSH_NOTIFICATION = 21,
            AVATAR_CUSTOMIZATION = 22,
            READ_POINT_OF_INTEREST_DESCRIPTION = 23,
            WEB = 24,
            CHANGE_AR = 25,
            WEATHER_DETAIL_CLICK = 26,
            USER_ISSUE_WEATHER_REPORT = 27,
            POKEMON_INVENTORY = 28,
            SOCIAL = 29,
            CHECK_ENCOUNTER_TRAY_INFO = 30,
            POKEMON_GO_PLUS = 31,
            RPC_TIMING = 32,
            SOCIAL_GIFT_COUNT = 33,
            ASSET_BUNDLE_DOWNLOAD = 34,
            ASSET_POI_DOWNLOAD = 35,
            ASSET_STREAM_DOWNLOAD = 36,
            ASSET_STREAM_CACHE_CULLED = 37,
            RPC_SOCKET_TIMING = 38,
            PERMISSIONS_FLOW = 39,
            DEVICE_SERVICE_TOGGLE = 40,
            BOOT_TELEMETRY = 41,
            AR_PHOTO_SESSION_TELEMETRY = 42
        }

        enum AvatarCustomizationTelemetryIds {
            UNDEFINED_AVATAR_CUSTOMIZATION = 0,
            EQUIP_ITEM = 1,
            OPEN_FEATURES = 2,
            OPEN_STORE = 3,
            PURCHASE_ITEM = 4,
            PURCHASE_ERROR = 5,
            SELECT_ITEM_GROUP = 6,
            SELECT_SLOT = 7,
            SELECT_COLOR = 8,
            SHOW_QUICK_SHOP = 9
        }

        enum BattlePartyTelemetryIds {
            UNDEFINED_BATTLE_PARTY_EVENT = 0,
            ADD = 1,
            REMOVE = 2,
            GYM_BATTLE = 3,
            RAID_BATTLE = 4,
            BATTLE_POKEMON_CHANGED = 5
        }

        enum GenericClickTelemetryIds {
            UNDEFINED_GENERIC_EVENT = 0,
            SPEED_WARNING_SHOW = 1,
            SPEED_WARNING_PASSENGER = 2
        }

        enum ItemUseTelemetryIds {
            UNDEFINED_ITEM_EVENT = 0,
            USE_ITEM = 1,
            RECYCLE_ITEM = 2
        }

        enum LoginActionTelemetryIds {
            UNDEFINED_LOGIN_ACTION = 0,
            CLICK_AGE_GATE = 1,
            CLICK_NEW_PLAYER = 2,
            CLICK_EXISTING_PLAYER = 3,
            CLICK_GOOGLE = 4,
            COMPLETE_GOOGLE = 5,
            CANCEL_GOOGLE = 6,
            CLICK_FACEBOOK = 7,
            COMPLETE_FACEBOOK = 8,
            CANCEL_FACEBOOK = 9,
            CLICK_PTC = 10,
            EXIT_PTC = 11,
            CLICK_PTC_REGISTER = 12,
            CLICK_PTC_SIGN_IN = 13,
            CANCEL_PTC_SIGN_IN = 14,
            COMPLETE_PTC_SIGN_IN = 15,
            CLICK_SUPERAWESOME = 16,
            EXIT_SUPERAWESOME = 17,
            CLICK_SUPERAWESOME_REGISTER = 18,
            CLICK_SUPERAWESOME_FORGOT_PASSWORD = 19,
            CLICK_SUPERAWESOME_SIGN_IN = 20,
            CANCEL_SUPERAWESOME_SIGN_IN = 21,
            COMPLETE_SUPERAWESOME_SIGN_IN = 22,
            EXIT_NEW_PLAYER = 23,
            EXIT_EXISTING_PLAYER = 24,
            LOGIN_STARTED = 25
        }

        enum MapEventsTelemetryIds {
            UNDEFINED_MAP_EVENT = 0,
            ITEM_BAG = 1,
            MAIN_MENU = 2,
            POKEDEX = 3,
            PROFILE = 4,
            SETTINGS = 5,
            SHOP_FROM_MAP = 6,
            GYM = 7,
            POKESTOP = 8,
            RESEARCH = 9,
            COMPASS = 10,
            NEARBY = 11
        }

        enum NewsPageTelemetryIds {
            UNDEFINED_NEWS_EVENT = 0,
            NEWS_VIEWED = 1,
            NEWS_DISMISSED = 2,
            NEWS_LINK_CLICKED = 3,
            NEWS_UPDATED_APP = 4
        }

        enum PokemonInventoryTelemetryIds {
            UNDEFINED_POKEMON_INVENTORY_EVENT = 0,
            OPEN = 1,
            SORTING_CHANGE = 2,
            FILTER = 3
        }

        enum ProfilePageTelemetryIds {
            UNDEFINED_PROFILE_PAGE = 0,
            SHOP_FROM_PROFILE = 1,
            LOG = 2,
            SET_BUDDY = 3,
            CUSTOMIZE_AVATAR = 4
        }

        enum PushNotificationTelemetryIds {
            UNDEFINED_PUSH_NOTIFICATION_EVENT = 0,
            OPEN_APP = 1
        }

        enum RaidTelemetryIds {
            UNDEFINED_RAID_EVENT = 0,
            APPROACH_ENTER = 1,
            APPROACH_CLICK_SPINNER = 2,
            APPROACH_JOIN = 3,
            APPROACH_TICKET_CONFIRMATION = 4,
            APPROACH_CLICK_TUTORIAL = 5,
            APPROACH_CLICK_SHOP = 6,
            APPROACH_CLICK_INSPECT = 7,
            LOBBY_ENTER = 8,
            LOBBY_CLICK_INVENTORY = 9,
            LOBBY_CLICK_EXIT = 10,
            LOBBY_TAP_AVATAR = 11,
            LOBBY_CLICK_REJOIN_BATTLE = 12,
            LOBBY_CLICK_LOBBY_PUBLIC = 13
        }

        enum ShoppingPageTelemetryIds {
            UNDEFINED_SHOPPING_PAGE_EVENT = 0,
            CLICK_CUSTOMIZE_AVATAR = 1,
            QUICK_SHOP_MORE = 2,
            QUICK_SHOP_EXCHANGE = 3
        }

        enum SocialTelemetryIds {
            UNDEFINED_SOCIAL = 0,
            FRIEND_TAB = 1,
            NOTIFICATION_TAB = 2,
            FRIEND_PROFILE = 3,
            OPEN_FRIEND_SHIP_LEVEL_DETAIL = 4,
            CLOSE_OPEN_GIFT_CONFIRMATION = 5,
            FRIEND_LIST_SORT_CHANGED = 6,
            FRIEND_LIST_CLOSED = 7
        }

        enum WebTelemetryIds {
            UNDEFINED_WEB_EVENT = 0,
            POINT_OF_INTEREST_DESCRIPTION_WEB_CLICK = 1
        }

        enum TutorialState {
            LEGAL_SCREEN = 0,
            AVATAR_SELECTION = 1,
            ACCOUNT_CREATION = 2,
            POKEMON_CAPTURE = 3,
            NAME_SELECTION = 4,
            POKEMON_BERRY = 5,
            USE_ITEM_TUTORIAL_STATE = 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
        }

        enum UpdateType {
            ADD_UPDATE_TYPE = 0,
            MODIFY = 1,
            REMOVE_UPDATE_TYPE = 2,
            PREDICTED_MODIFY = 3,
            PREDICTED_REMOVE = 4,
            ROLLED_BACK_MODIFY = 5,
            ROLLED_BACK_REMOVE = 6
        }

        enum VariableName {
            UNSET_VARIABLE_NAME = 0,
            CODE_NAME = 1,
            TEAM = 2,
            LEVEL = 3,
            EXPERIENCE = 4,
            POKECOIN_BALANCE = 5,
            STARDUST_BALANCE = 6,
            EMAIL = 7,
            LOGIN_METHOD = 8,
            GYM_ID = 1000,
            GYM_NAME = 1001,
            POKEMON_DISPLAY = 1002,
            POKEDEX_ENTRY_NUMBER = 1003,
            POKEMON_ID = 1004,
            POKEMON_NICKNAME = 1005,
            GYM_BADGE_EARNED_POINTS = 1006,
            GYM_BADGE_PROGRESS = 1007,
            GYM_BADGE_RANK = 1008,
            GYM_BADGE_IMAGE_URL = 1009,
            GYM_BADGE_LEVEL_UP = 1010,
            POKECOIN_AWARDED = 1011,
            POKECOIN_AWARDED_TODAY = 1012,
            MAX_DAILY_POKECOIN = 1013,
            BATTLES_WON = 1014,
            BATTLES_LOST = 1015,
            DEPLOYED_MILLIS = 1016,
            RAID_SEED = 1017,
            EXCLUSIVE_RAID_CANCELLATION_INFO = 1018,
            GIFTBOX_DETAILS = 1019,
            FRIEND_AVATAR = 1020,
            FRIEND_TEAM = 1021,
            FRIEND_CODENAME = 1022,
            GIFT_LOOT_ITEMS = 1023,
            GIFT_EGG = 1024,
            FRIENDSHIP_MILESTONE_REWARD_DETAILS = 1025,
            FRIENDSHIP_LEVEL_DISPLAY = 1026,
            BGMODE_BUDDY_POKEMON_NICKNAME = 1027,
            COMBAT_CHALLENGE = 1028,
            COMBAT_CHALLENGER_CODENAME = 1029,
            BGMODE_OFF_SESSION_DISTANCE_KM = 1030,
            POI_NAME = 1031
        }

        enum VfxLevel {
            NONE_VFX_LEVEL = 0,
            START = 1,
            NICE = 2,
            GREAT = 3,
            EXCELLENT = 4
        }

        enum WeatherCondition {
            NONE = 0,
            CLEAR = 1,
            RAINY = 2,
            PARTLY_CLOUDY = 3,
            OVERCAST = 4,
            WINDY = 5,
            SNOW = 6,
            FOG = 7
        }
    }

    namespace Inventory {

        interface IAppliedItem {
            item_id?: (POGOProtos.Inventory.Item.ItemId|null);
            item_type?: (POGOProtos.Inventory.Item.ItemType|null);
            expire_ms?: (number|Long|null);
            applied_ms?: (number|Long|null);
        }

        class AppliedItem implements IAppliedItem {
            constructor(properties?: POGOProtos.Inventory.IAppliedItem);
            public item_id: POGOProtos.Inventory.Item.ItemId;
            public item_type: POGOProtos.Inventory.Item.ItemType;
            public expire_ms: (number|Long);
            public applied_ms: (number|Long);
            public static encode(message: POGOProtos.Inventory.IAppliedItem, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.AppliedItem;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.AppliedItem;
            public static toObject(message: POGOProtos.Inventory.AppliedItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IAppliedItems {
            item?: (POGOProtos.Inventory.IAppliedItem[]|null);
        }

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

        interface ICandy {
            family_id?: (POGOProtos.Enums.PokemonFamilyId|null);
            candy?: (number|null);
        }

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

        interface IEggIncubator {
            id?: (string|null);
            item_id?: (POGOProtos.Inventory.Item.ItemId|null);
            incubator_type?: (POGOProtos.Inventory.EggIncubatorType|null);
            uses_remaining?: (number|null);
            pokemon_id?: (number|Long|null);
            start_km_walked?: (number|null);
            target_km_walked?: (number|null);
        }

        class EggIncubator implements IEggIncubator {
            constructor(properties?: POGOProtos.Inventory.IEggIncubator);
            public id: string;
            public item_id: POGOProtos.Inventory.Item.ItemId;
            public incubator_type: POGOProtos.Inventory.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.Inventory.IEggIncubator, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.EggIncubator;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.EggIncubator;
            public static toObject(message: POGOProtos.Inventory.EggIncubator, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEggIncubators {
            egg_incubator?: (POGOProtos.Inventory.IEggIncubator[]|null);
        }

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

        enum EggIncubatorType {
            INCUBATOR_UNSET = 0,
            INCUBATOR_DISTANCE = 1
        }

        interface IExclusiveTicketInfo {
            raid_seed?: (number|Long|null);
            fort_id?: (string|null);
            start_time_ms?: (number|Long|null);
            end_time_ms?: (number|Long|null);
            image_url?: (string|null);
            latitude?: (number|null);
            longitude?: (number|null);
            gym_name?: (string|null);
            spawn_time_ms?: (number|Long|null);
            is_cancelled?: (boolean|null);
            raid_pokemon?: (POGOProtos.Data.IPokemonData|null);
            inviter?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
            invitee?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
        }

        class ExclusiveTicketInfo implements IExclusiveTicketInfo {
            constructor(properties?: POGOProtos.Inventory.IExclusiveTicketInfo);
            public raid_seed: (number|Long);
            public fort_id: string;
            public start_time_ms: (number|Long);
            public end_time_ms: (number|Long);
            public image_url: string;
            public latitude: number;
            public longitude: number;
            public gym_name: string;
            public spawn_time_ms: (number|Long);
            public is_cancelled: boolean;
            public raid_pokemon?: (POGOProtos.Data.IPokemonData|null);
            public inviter?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
            public invitee?: (POGOProtos.Data.Raid.ISharedExclusiveTicketTrainerInfo|null);
            public static encode(message: POGOProtos.Inventory.IExclusiveTicketInfo, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.ExclusiveTicketInfo;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.ExclusiveTicketInfo;
            public static toObject(message: POGOProtos.Inventory.ExclusiveTicketInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryDelta {
            original_timestamp_ms?: (number|Long|null);
            new_timestamp_ms?: (number|Long|null);
            inventory_items?: (POGOProtos.Inventory.IInventoryItem[]|null);
        }

        class InventoryDelta implements IInventoryDelta {
            constructor(properties?: POGOProtos.Inventory.IInventoryDelta);
            public original_timestamp_ms: (number|Long);
            public new_timestamp_ms: (number|Long);
            public inventory_items: POGOProtos.Inventory.IInventoryItem[];
            public static encode(message: POGOProtos.Inventory.IInventoryDelta, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.InventoryDelta;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.InventoryDelta;
            public static toObject(message: POGOProtos.Inventory.InventoryDelta, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryItem {
            modified_timestamp_ms?: (number|Long|null);
            deleted_item?: (POGOProtos.Inventory.InventoryItem.IDeletedItem|null);
            inventory_item_data?: (POGOProtos.Inventory.IInventoryItemData|null);
        }

        class InventoryItem implements IInventoryItem {
            constructor(properties?: POGOProtos.Inventory.IInventoryItem);
            public modified_timestamp_ms: (number|Long);
            public deleted_item?: (POGOProtos.Inventory.InventoryItem.IDeletedItem|null);
            public inventory_item_data?: (POGOProtos.Inventory.IInventoryItemData|null);
            public InventoryItem?: ("deleted_item"|"inventory_item_data");
            public static encode(message: POGOProtos.Inventory.IInventoryItem, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.InventoryItem;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.InventoryItem;
            public static toObject(message: POGOProtos.Inventory.InventoryItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace InventoryItem {

            interface IDeletedItem {
                pokemon_id?: (number|Long|null);
            }

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

        interface IInventoryItemData {
            pokemon_data?: (POGOProtos.Data.IPokemonData|null);
            item?: (POGOProtos.Inventory.Item.IItemData|null);
            pokedex_entry?: (POGOProtos.Data.IPokedexEntry|null);
            player_stats?: (POGOProtos.Data.Player.IPlayerStats|null);
            player_currency?: (POGOProtos.Data.Player.IPlayerCurrency|null);
            player_camera?: (POGOProtos.Data.Player.IPlayerCamera|null);
            inventory_upgrades?: (POGOProtos.Inventory.IInventoryUpgrades|null);
            applied_items?: (POGOProtos.Inventory.IAppliedItems|null);
            egg_incubators?: (POGOProtos.Inventory.IEggIncubators|null);
            candy?: (POGOProtos.Inventory.ICandy|null);
            quest?: (POGOProtos.Data.Quests.IQuest|null);
            avatar_item?: (POGOProtos.Data.Avatar.IAvatarItem|null);
            raid_tickets?: (POGOProtos.Inventory.IRaidTickets|null);
            quests?: (POGOProtos.Data.Quests.IQuests|null);
            gift_boxes?: (POGOProtos.Data.Gift.IGiftBoxes|null);
            beluga_incense?: (POGOProtos.Data.Beluga.IBelugaIncenseBox|null);
        }

        class InventoryItemData implements IInventoryItemData {
            constructor(properties?: POGOProtos.Inventory.IInventoryItemData);
            public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
            public item?: (POGOProtos.Inventory.Item.IItemData|null);
            public pokedex_entry?: (POGOProtos.Data.IPokedexEntry|null);
            public player_stats?: (POGOProtos.Data.Player.IPlayerStats|null);
            public player_currency?: (POGOProtos.Data.Player.IPlayerCurrency|null);
            public player_camera?: (POGOProtos.Data.Player.IPlayerCamera|null);
            public inventory_upgrades?: (POGOProtos.Inventory.IInventoryUpgrades|null);
            public applied_items?: (POGOProtos.Inventory.IAppliedItems|null);
            public egg_incubators?: (POGOProtos.Inventory.IEggIncubators|null);
            public candy?: (POGOProtos.Inventory.ICandy|null);
            public quest?: (POGOProtos.Data.Quests.IQuest|null);
            public avatar_item?: (POGOProtos.Data.Avatar.IAvatarItem|null);
            public raid_tickets?: (POGOProtos.Inventory.IRaidTickets|null);
            public quests?: (POGOProtos.Data.Quests.IQuests|null);
            public gift_boxes?: (POGOProtos.Data.Gift.IGiftBoxes|null);
            public beluga_incense?: (POGOProtos.Data.Beluga.IBelugaIncenseBox|null);
            public Type?: ("pokemon_data"|"item"|"pokedex_entry"|"player_stats"|"player_currency"|"player_camera"|"inventory_upgrades"|"applied_items"|"egg_incubators"|"candy"|"quest"|"avatar_item"|"raid_tickets"|"quests"|"gift_boxes"|"beluga_incense");
            public static encode(message: POGOProtos.Inventory.IInventoryItemData, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.InventoryItemData;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.InventoryItemData;
            public static toObject(message: POGOProtos.Inventory.InventoryItemData, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryKey {
            pokemon_id?: (number|Long|null);
            item?: (POGOProtos.Inventory.Item.ItemId|null);
            pokedex_entry_id?: (number|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.Enums.PokemonFamilyId|null);
            quest_type?: (POGOProtos.Enums.QuestType|null);
            avatar_template_id?: (string|null);
            raid_tickets?: (boolean|null);
            quests?: (boolean|null);
            gift_boxes?: (boolean|null);
            beluga_incense_box?: (boolean|null);
        }

        class InventoryKey implements IInventoryKey {
            constructor(properties?: POGOProtos.Inventory.IInventoryKey);
            public pokemon_id: (number|Long);
            public item: POGOProtos.Inventory.Item.ItemId;
            public pokedex_entry_id: number;
            public player_stats: boolean;
            public player_currency: boolean;
            public player_camera: boolean;
            public inventory_upgrades: boolean;
            public applied_items: boolean;
            public egg_incubators: boolean;
            public pokemon_family_id: POGOProtos.Enums.PokemonFamilyId;
            public quest_type: POGOProtos.Enums.QuestType;
            public avatar_template_id: string;
            public raid_tickets: boolean;
            public quests: boolean;
            public gift_boxes: boolean;
            public beluga_incense_box: boolean;
            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");
            public static encode(message: POGOProtos.Inventory.IInventoryKey, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.InventoryKey;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.InventoryKey;
            public static toObject(message: POGOProtos.Inventory.InventoryKey, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryUpgrade {
            item_id?: (POGOProtos.Inventory.Item.ItemId|null);
            upgrade_type?: (POGOProtos.Inventory.InventoryUpgradeType|null);
            additional_storage?: (number|null);
        }

        class InventoryUpgrade implements IInventoryUpgrade {
            constructor(properties?: POGOProtos.Inventory.IInventoryUpgrade);
            public item_id: POGOProtos.Inventory.Item.ItemId;
            public upgrade_type: POGOProtos.Inventory.InventoryUpgradeType;
            public additional_storage: number;
            public static encode(message: POGOProtos.Inventory.IInventoryUpgrade, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.InventoryUpgrade;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.InventoryUpgrade;
            public static toObject(message: POGOProtos.Inventory.InventoryUpgrade, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IInventoryUpgrades {
            inventory_upgrades?: (POGOProtos.Inventory.IInventoryUpgrade[]|null);
        }

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

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

        namespace Item {

            interface IItemAward {
                item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                item_count?: (number|null);
                bonus_count?: (number|null);
            }

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

            interface IItemData {
                item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                count?: (number|null);
                unseen?: (boolean|null);
            }

            class ItemData implements IItemData {
                constructor(properties?: POGOProtos.Inventory.Item.IItemData);
                public item_id: POGOProtos.Inventory.Item.ItemId;
                public count: number;
                public unseen: boolean;
                public static encode(message: POGOProtos.Inventory.Item.IItemData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.Item.ItemData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.Item.ItemData;
                public static toObject(message: POGOProtos.Inventory.Item.ItemData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum ItemId {
                ITEM_UNKNOWN = 0,
                ITEM_POKE_BALL = 1,
                ITEM_GREAT_BALL = 2,
                ITEM_ULTRA_BALL = 3,
                ITEM_MASTER_BALL = 4,
                ITEM_PREMIER_BALL = 5,
                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_INCENSE_ORDINARY = 401,
                ITEM_INCENSE_SPICY = 402,
                ITEM_INCENSE_COOL = 403,
                ITEM_INCENSE_FLORAL = 404,
                ITEM_INCENSE_BELUGA_BOX = 405,
                ITEM_TROY_DISK = 501,
                ITEM_X_ATTACK = 602,
                ITEM_X_DEFENSE = 603,
                ITEM_X_MIRACLE = 604,
                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_SPECIAL_CAMERA = 801,
                ITEM_INCUBATOR_BASIC_UNLIMITED = 901,
                ITEM_INCUBATOR_BASIC = 902,
                ITEM_INCUBATOR_SUPER = 903,
                ITEM_POKEMON_STORAGE_UPGRADE = 1001,
                ITEM_ITEM_STORAGE_UPGRADE = 1002,
                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_MOVE_REROLL_FAST_ATTACK = 1201,
                ITEM_MOVE_REROLL_SPECIAL_ATTACK = 1202,
                ITEM_RARE_CANDY = 1301,
                ITEM_FREE_RAID_TICKET = 1401,
                ITEM_PAID_RAID_TICKET = 1402,
                ITEM_LEGENDARY_RAID_TICKET = 1403,
                ITEM_STAR_PIECE = 1404,
                ITEM_FRIEND_GIFT_BOX = 1405,
                ITEM_TEAM_CHANGE = 1406
            }

            enum ItemType {
                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
            }
        }

        interface ILoot {
            loot_item?: (POGOProtos.Inventory.ILootItem[]|null);
        }

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

        interface ILootItem {
            item?: (POGOProtos.Inventory.Item.ItemId|null);
            stardust?: (boolean|null);
            pokecoin?: (boolean|null);
            pokemon_candy?: (POGOProtos.Enums.PokemonId|null);
            count?: (number|null);
            experience?: (boolean|null);
            pokemon_egg?: (POGOProtos.Data.IPokemonData|null);
        }

        class LootItem implements ILootItem {
            constructor(properties?: POGOProtos.Inventory.ILootItem);
            public item: POGOProtos.Inventory.Item.ItemId;
            public stardust: boolean;
            public pokecoin: boolean;
            public pokemon_candy: POGOProtos.Enums.PokemonId;
            public count: number;
            public experience: boolean;
            public pokemon_egg?: (POGOProtos.Data.IPokemonData|null);
            public Type?: ("item"|"stardust"|"pokecoin"|"pokemon_candy"|"count"|"experience"|"pokemon_egg");
            public static encode(message: POGOProtos.Inventory.ILootItem, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.LootItem;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.LootItem;
            public static toObject(message: POGOProtos.Inventory.LootItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidTicket {
            ticket_id?: (string|null);
            item?: (POGOProtos.Inventory.Item.ItemId|null);
            exclusive_info?: (POGOProtos.Inventory.IExclusiveTicketInfo|null);
        }

        class RaidTicket implements IRaidTicket {
            constructor(properties?: POGOProtos.Inventory.IRaidTicket);
            public ticket_id: string;
            public item: POGOProtos.Inventory.Item.ItemId;
            public exclusive_info?: (POGOProtos.Inventory.IExclusiveTicketInfo|null);
            public static encode(message: POGOProtos.Inventory.IRaidTicket, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Inventory.RaidTicket;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Inventory.RaidTicket;
            public static toObject(message: POGOProtos.Inventory.RaidTicket, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IRaidTickets {
            raid_ticket?: (POGOProtos.Inventory.IRaidTicket[]|null);
        }

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

    namespace Map {

        namespace Fort {

            interface IFortData {
                id?: (string|null);
                last_modified_timestamp_ms?: (number|Long|null);
                latitude?: (number|null);
                longitude?: (number|null);
                owned_by_team?: (POGOProtos.Enums.TeamColor|null);
                guard_pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                guard_pokemon_level?: (number|null);
                enabled?: (boolean|null);
                type?: (POGOProtos.Map.Fort.FortType|null);
                gym_points?: (number|Long|null);
                is_in_battle?: (boolean|null);
                active_fort_modifier?: (POGOProtos.Inventory.Item.ItemId[]|null);
                active_pokemon?: (POGOProtos.Map.Pokemon.IMapPokemon|null);
                cooldown_complete_ms?: (number|Long|null);
                sponsor?: (POGOProtos.Map.Fort.FortSponsor|null);
                rendering_type?: (POGOProtos.Map.Fort.FortRenderingType|null);
                deploy_lockout_end_ms?: (number|Long|null);
                guard_pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                closed?: (boolean|null);
                raid_info?: (POGOProtos.Data.Raid.IRaidInfo|null);
                gym_display?: (POGOProtos.Map.Fort.IGymDisplay|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);
            }

            class FortData implements IFortData {
                constructor(properties?: POGOProtos.Map.Fort.IFortData);
                public id: string;
                public last_modified_timestamp_ms: (number|Long);
                public latitude: number;
                public longitude: number;
                public owned_by_team: POGOProtos.Enums.TeamColor;
                public guard_pokemon_id: POGOProtos.Enums.PokemonId;
                public guard_pokemon_level: number;
                public enabled: boolean;
                public type: POGOProtos.Map.Fort.FortType;
                public gym_points: (number|Long);
                public is_in_battle: boolean;
                public active_fort_modifier: POGOProtos.Inventory.Item.ItemId[];
                public active_pokemon?: (POGOProtos.Map.Pokemon.IMapPokemon|null);
                public cooldown_complete_ms: (number|Long);
                public sponsor: POGOProtos.Map.Fort.FortSponsor;
                public rendering_type: POGOProtos.Map.Fort.FortRenderingType;
                public deploy_lockout_end_ms: (number|Long);
                public guard_pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public closed: boolean;
                public raid_info?: (POGOProtos.Data.Raid.IRaidInfo|null);
                public gym_display?: (POGOProtos.Map.Fort.IGymDisplay|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 static encode(message: POGOProtos.Map.Fort.IFortData, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Fort.FortData;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Fort.FortData;
                public static toObject(message: POGOProtos.Map.Fort.FortData, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFortModifier {
                item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                expiration_timestamp_ms?: (number|Long|null);
                deployer_player_codename?: (string|null);
            }

            class FortModifier implements IFortModifier {
                constructor(properties?: POGOProtos.Map.Fort.IFortModifier);
                public item_id: POGOProtos.Inventory.Item.ItemId;
                public expiration_timestamp_ms: (number|Long);
                public deployer_player_codename: string;
                public static encode(message: POGOProtos.Map.Fort.IFortModifier, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Fort.FortModifier;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Fort.FortModifier;
                public static toObject(message: POGOProtos.Map.Fort.FortModifier, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum FortRenderingType {
                DEFAULT = 0,
                INTERNAL_TEST = 1
            }

            enum FortSponsor {
                UNSET_SPONSOR = 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 IFortSummary {
                fort_summary_id?: (string|null);
                last_modified_timestamp_ms?: (number|Long|null);
                latitude?: (number|null);
                longitude?: (number|null);
            }

            class FortSummary implements IFortSummary {
                constructor(properties?: POGOProtos.Map.Fort.IFortSummary);
                public fort_summary_id: string;
                public last_modified_timestamp_ms: (number|Long);
                public latitude: number;
                public longitude: number;
                public static encode(message: POGOProtos.Map.Fort.IFortSummary, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Fort.FortSummary;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Fort.FortSummary;
                public static toObject(message: POGOProtos.Map.Fort.FortSummary, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum FortType {
                GYM = 0,
                CHECKPOINT = 1
            }

            interface IGymDisplay {
                gym_event?: (POGOProtos.Map.Fort.IGymEvent[]|null);
                total_gym_cp?: (number|null);
                lowest_pokemon_motivation?: (number|null);
                slots_available?: (number|null);
                occupied_millis?: (number|Long|null);
            }

            class GymDisplay implements IGymDisplay {
                constructor(properties?: POGOProtos.Map.Fort.IGymDisplay);
                public gym_event: POGOProtos.Map.Fort.IGymEvent[];
                public total_gym_cp: number;
                public lowest_pokemon_motivation: number;
                public slots_available: number;
                public occupied_millis: (number|Long);
                public static encode(message: POGOProtos.Map.Fort.IGymDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Fort.GymDisplay;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Fort.GymDisplay;
                public static toObject(message: POGOProtos.Map.Fort.GymDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymEvent {
                trainer?: (string|null);
                timestamp_ms?: (number|Long|null);
                event?: (POGOProtos.Map.Fort.GymEvent.Event|null);
                pokedex_id?: (number|null);
                pokemon_id?: (number|Long|null);
            }

            class GymEvent implements IGymEvent {
                constructor(properties?: POGOProtos.Map.Fort.IGymEvent);
                public trainer: string;
                public timestamp_ms: (number|Long);
                public event: POGOProtos.Map.Fort.GymEvent.Event;
                public pokedex_id: number;
                public pokemon_id: (number|Long);
                public static encode(message: POGOProtos.Map.Fort.IGymEvent, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Fort.GymEvent;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Fort.GymEvent;
                public static toObject(message: POGOProtos.Map.Fort.GymEvent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymEvent {

                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 IMapCell {
            s2_cell_id?: (number|Long|null);
            current_timestamp_ms?: (number|Long|null);
            forts?: (POGOProtos.Map.Fort.IFortData[]|null);
            spawn_points?: (POGOProtos.Map.ISpawnPoint[]|null);
            deleted_objects?: (string[]|null);
            is_truncated_list?: (boolean|null);
            fort_summaries?: (POGOProtos.Map.Fort.IFortSummary[]|null);
            decimated_spawn_points?: (POGOProtos.Map.ISpawnPoint[]|null);
            wild_pokemons?: (POGOProtos.Map.Pokemon.IWildPokemon[]|null);
            catchable_pokemons?: (POGOProtos.Map.Pokemon.IMapPokemon[]|null);
            nearby_pokemons?: (POGOProtos.Map.Pokemon.INearbyPokemon[]|null);
        }

        class MapCell implements IMapCell {
            constructor(properties?: POGOProtos.Map.IMapCell);
            public s2_cell_id: (number|Long);
            public current_timestamp_ms: (number|Long);
            public forts: POGOProtos.Map.Fort.IFortData[];
            public spawn_points: POGOProtos.Map.ISpawnPoint[];
            public deleted_objects: string[];
            public is_truncated_list: boolean;
            public fort_summaries: POGOProtos.Map.Fort.IFortSummary[];
            public decimated_spawn_points: POGOProtos.Map.ISpawnPoint[];
            public wild_pokemons: POGOProtos.Map.Pokemon.IWildPokemon[];
            public catchable_pokemons: POGOProtos.Map.Pokemon.IMapPokemon[];
            public nearby_pokemons: POGOProtos.Map.Pokemon.INearbyPokemon[];
            public static encode(message: POGOProtos.Map.IMapCell, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.MapCell;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Map.MapCell;
            public static toObject(message: POGOProtos.Map.MapCell, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        enum MapObjectsStatus {
            UNSET_STATUS = 0,
            SUCCESS = 1,
            LOCATION_UNSET = 2
        }

        namespace Pokemon {

            interface ILobbyPokemon {
                id?: (number|Long|null);
                pokedex_id?: (POGOProtos.Enums.PokemonId|null);
                cp?: (number|null);
                percent_health?: (number|null);
            }

            class LobbyPokemon implements ILobbyPokemon {
                constructor(properties?: POGOProtos.Map.Pokemon.ILobbyPokemon);
                public id: (number|Long);
                public pokedex_id: POGOProtos.Enums.PokemonId;
                public cp: number;
                public percent_health: number;
                public static encode(message: POGOProtos.Map.Pokemon.ILobbyPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Pokemon.LobbyPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Pokemon.LobbyPokemon;
                public static toObject(message: POGOProtos.Map.Pokemon.LobbyPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMapPokemon {
                spawn_point_id?: (string|null);
                encounter_id?: (number|Long|null);
                pokedex_type_id?: (POGOProtos.Enums.PokemonId|null);
                expiration_time_ms?: (number|Long|null);
                latitude?: (number|null);
                longitude?: (number|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            }

            class MapPokemon implements IMapPokemon {
                constructor(properties?: POGOProtos.Map.Pokemon.IMapPokemon);
                public spawn_point_id: string;
                public encounter_id: (number|Long);
                public pokedex_type_id: POGOProtos.Enums.PokemonId;
                public expiration_time_ms: (number|Long);
                public latitude: number;
                public longitude: number;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Map.Pokemon.IMapPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Pokemon.MapPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Pokemon.MapPokemon;
                public static toObject(message: POGOProtos.Map.Pokemon.MapPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMotivatedPokemon {
                pokemon?: (POGOProtos.Data.IPokemonData|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.Data.IFoodValue[]|null);
            }

            class MotivatedPokemon implements IMotivatedPokemon {
                constructor(properties?: POGOProtos.Map.Pokemon.IMotivatedPokemon);
                public pokemon?: (POGOProtos.Data.IPokemonData|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.Data.IFoodValue[];
                public static encode(message: POGOProtos.Map.Pokemon.IMotivatedPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Pokemon.MotivatedPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Pokemon.MotivatedPokemon;
                public static toObject(message: POGOProtos.Map.Pokemon.MotivatedPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface INearbyPokemon {
                pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                distance_in_meters?: (number|null);
                encounter_id?: (number|Long|null);
                fort_id?: (string|null);
                fort_image_url?: (string|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            }

            class NearbyPokemon implements INearbyPokemon {
                constructor(properties?: POGOProtos.Map.Pokemon.INearbyPokemon);
                public pokemon_id: POGOProtos.Enums.PokemonId;
                public distance_in_meters: number;
                public encounter_id: (number|Long);
                public fort_id: string;
                public fort_image_url: string;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Map.Pokemon.INearbyPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Pokemon.NearbyPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Pokemon.NearbyPokemon;
                public static toObject(message: POGOProtos.Map.Pokemon.NearbyPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWildPokemon {
                encounter_id?: (number|Long|null);
                last_modified_timestamp_ms?: (number|Long|null);
                latitude?: (number|null);
                longitude?: (number|null);
                spawn_point_id?: (string|null);
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                time_till_hidden_ms?: (number|null);
            }

            class WildPokemon implements IWildPokemon {
                constructor(properties?: POGOProtos.Map.Pokemon.IWildPokemon);
                public encounter_id: (number|Long);
                public last_modified_timestamp_ms: (number|Long);
                public latitude: number;
                public longitude: number;
                public spawn_point_id: string;
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public time_till_hidden_ms: number;
                public static encode(message: POGOProtos.Map.Pokemon.IWildPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Pokemon.WildPokemon;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Pokemon.WildPokemon;
                public static toObject(message: POGOProtos.Map.Pokemon.WildPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface ISpawnPoint {
            latitude?: (number|null);
            longitude?: (number|null);
        }

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

        namespace Weather {

            interface IClientWeather {
                s2_cell_id?: (number|Long|null);
                display_weather?: (POGOProtos.Map.Weather.IDisplayWeather|null);
                gameplay_weather?: (POGOProtos.Map.Weather.IGameplayWeather|null);
                alerts?: (POGOProtos.Map.Weather.IWeatherAlert[]|null);
            }

            class ClientWeather implements IClientWeather {
                constructor(properties?: POGOProtos.Map.Weather.IClientWeather);
                public s2_cell_id: (number|Long);
                public display_weather?: (POGOProtos.Map.Weather.IDisplayWeather|null);
                public gameplay_weather?: (POGOProtos.Map.Weather.IGameplayWeather|null);
                public alerts: POGOProtos.Map.Weather.IWeatherAlert[];
                public static encode(message: POGOProtos.Map.Weather.IClientWeather, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Weather.ClientWeather;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Weather.ClientWeather;
                public static toObject(message: POGOProtos.Map.Weather.ClientWeather, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IDisplayWeather {
                cloud_level?: (POGOProtos.Map.Weather.DisplayWeather.DisplayLevel|null);
                rain_level?: (POGOProtos.Map.Weather.DisplayWeather.DisplayLevel|null);
                wind_level?: (POGOProtos.Map.Weather.DisplayWeather.DisplayLevel|null);
                snow_level?: (POGOProtos.Map.Weather.DisplayWeather.DisplayLevel|null);
                fog_level?: (POGOProtos.Map.Weather.DisplayWeather.DisplayLevel|null);
                wind_direction?: (number|null);
                special_effect_level?: (POGOProtos.Map.Weather.DisplayWeather.DisplayLevel|null);
            }

            class DisplayWeather implements IDisplayWeather {
                constructor(properties?: POGOProtos.Map.Weather.IDisplayWeather);
                public cloud_level: POGOProtos.Map.Weather.DisplayWeather.DisplayLevel;
                public rain_level: POGOProtos.Map.Weather.DisplayWeather.DisplayLevel;
                public wind_level: POGOProtos.Map.Weather.DisplayWeather.DisplayLevel;
                public snow_level: POGOProtos.Map.Weather.DisplayWeather.DisplayLevel;
                public fog_level: POGOProtos.Map.Weather.DisplayWeather.DisplayLevel;
                public wind_direction: number;
                public special_effect_level: POGOProtos.Map.Weather.DisplayWeather.DisplayLevel;
                public static encode(message: POGOProtos.Map.Weather.IDisplayWeather, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Weather.DisplayWeather;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Weather.DisplayWeather;
                public static toObject(message: POGOProtos.Map.Weather.DisplayWeather, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DisplayWeather {

                enum DisplayLevel {
                    LEVEL_0 = 0,
                    LEVEL_1 = 1,
                    LEVEL_2 = 2,
                    LEVEL_3 = 3
                }
            }

            interface IGameplayWeather {
                gameplay_condition?: (POGOProtos.Map.Weather.GameplayWeather.WeatherCondition|null);
            }

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

            namespace GameplayWeather {

                enum WeatherCondition {
                    NONE = 0,
                    CLEAR = 1,
                    RAINY = 2,
                    PARTLY_CLOUDY = 3,
                    OVERCAST = 4,
                    WINDY = 5,
                    SNOW = 6,
                    FOG = 7
                }
            }

            interface IWeatherAlert {
                severity?: (POGOProtos.Map.Weather.WeatherAlert.Severity|null);
                warn_weather?: (boolean|null);
            }

            class WeatherAlert implements IWeatherAlert {
                constructor(properties?: POGOProtos.Map.Weather.IWeatherAlert);
                public severity: POGOProtos.Map.Weather.WeatherAlert.Severity;
                public warn_weather: boolean;
                public static encode(message: POGOProtos.Map.Weather.IWeatherAlert, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Map.Weather.WeatherAlert;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Map.Weather.WeatherAlert;
                public static toObject(message: POGOProtos.Map.Weather.WeatherAlert, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace WeatherAlert {

                enum Severity {
                    NONE = 0,
                    MODERATE = 1,
                    EXTREME = 2
                }
            }
        }
    }

    namespace Networking {

        namespace Envelopes {

            interface IAuthInfo {
                provider?: (string|null);
                token?: (POGOProtos.Networking.Envelopes.AuthInfo.IJWT|null);
                options?: (POGOProtos.Networking.Envelopes.AuthInfo.IAuthOptions|null);
            }

            class AuthInfo implements IAuthInfo {
                constructor(properties?: POGOProtos.Networking.Envelopes.IAuthInfo);
                public provider: string;
                public token?: (POGOProtos.Networking.Envelopes.AuthInfo.IJWT|null);
                public options?: (POGOProtos.Networking.Envelopes.AuthInfo.IAuthOptions|null);
                public static encode(message: POGOProtos.Networking.Envelopes.IAuthInfo, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Envelopes.AuthInfo;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Envelopes.AuthInfo;
                public static toObject(message: POGOProtos.Networking.Envelopes.AuthInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AuthInfo {

                interface IJWT {
                    contents?: (string|null);
                    unknown2?: (number|null);
                }

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

                interface IAuthOptions {
                    prevent_account_creation?: (boolean|null);
                }

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

            interface IAuthTicket {
                start?: (Uint8Array|null);
                expire_timestamp_ms?: (number|Long|null);
                end?: (Uint8Array|null);
            }

            class AuthTicket implements IAuthTicket {
                constructor(properties?: POGOProtos.Networking.Envelopes.IAuthTicket);
                public start: Uint8Array;
                public expire_timestamp_ms: (number|Long);
                public end: Uint8Array;
                public static encode(message: POGOProtos.Networking.Envelopes.IAuthTicket, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Envelopes.AuthTicket;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Envelopes.AuthTicket;
                public static toObject(message: POGOProtos.Networking.Envelopes.AuthTicket, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        namespace Platform {

            interface IInternalAuth {
                email?: (string|null);
                player_id?: (string|null);
                app_id?: (string|null);
                key?: (string|null);
            }

            class InternalAuth implements IInternalAuth {
                constructor(properties?: POGOProtos.Networking.Platform.IInternalAuth);
                public email: string;
                public player_id: string;
                public app_id: string;
                public key: string;
                public static encode(message: POGOProtos.Networking.Platform.IInternalAuth, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.InternalAuth;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.InternalAuth;
                public static toObject(message: POGOProtos.Networking.Platform.InternalAuth, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            enum PlatformRequestType {
                UNKNOWN = 0,
                MAP_QUERY_REQUEST = 1,
                PURCHASE_SKU = 2,
                REDEEM_GOOGLE_RECEIPT = 3,
                REDEEM_APPLE_RECEIPT = 4,
                GET_AVAILABLE_SKUS_AND_BALANCES = 5,
                SEND_ENCRYPTED_SIGNATURE = 6,
                REDEEM_DESKTOP_RECEIPT = 7,
                DOWNLOAD_PLATFORM_CLIENT_SETTINGS = 8,
                REDEEM_PASSCODE = 9,
                REGISTER_PUSH_NOTIFICATION = 10,
                UNREGISTER_PUSH_NOTIFICATION = 11,
                UPDATE_NOTIFICATION_STATUS = 12,
                ADD_NEW_POI = 13,
                ADD_LOGIN_ACTION = 14,
                REMOVE_LOGIN_ACTION = 15,
                LIST_LOGIN_ACTION = 16,
                COLLECT_CLIENT_TELEMETRY = 17,
                GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 18,
                REPLACE_LOGIN_ACTION = 19,
                CHALLENGE = 20,
                SAFETY_NET_CHALLENGE = 21,
                UPDATE_FITNESS_METRICS = 22,
                GET_FITNESS_REPORT = 23,
                SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 24,
                REGISTER_DOWNSTREAM_SERVER_ACTIONS = 30,
                DOWNSTREAM_SERVER_ACTIONS = 31,
                TEMP_TEST_RESULT = 101
            }

            namespace Requests {

                interface IAddLoginActionMessage {
                    identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                    inner_message?: (Uint8Array|null);
                }

                class AddLoginActionMessage implements IAddLoginActionMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IAddLoginActionMessage);
                    public identity_provider: POGOProtos.Enums.IdentityProvider;
                    public inner_message: Uint8Array;
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IAddLoginActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.AddLoginActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.AddLoginActionMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.AddLoginActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IAddNewPoiMessage {
                    title?: (string|null);
                    long_description?: (string|null);
                    image_gs_file_path?: (string|null);
                    lat_e6?: (number|null);
                    lng_e6?: (number|null);
                    image_serving_url?: (string|null);
                    user_id?: (string|null);
                    player_language?: (string|null);
                    game_unique_id?: (string|null);
                    app_id?: (string|null);
                    player_reputation?: (POGOProtos.Data.Player.IPlayerReputation|null);
                }

                class AddNewPoiMessage implements IAddNewPoiMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IAddNewPoiMessage);
                    public title: string;
                    public long_description: string;
                    public image_gs_file_path: string;
                    public lat_e6: number;
                    public lng_e6: number;
                    public image_serving_url: string;
                    public user_id: string;
                    public player_language: string;
                    public game_unique_id: string;
                    public app_id: string;
                    public player_reputation?: (POGOProtos.Data.Player.IPlayerReputation|null);
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IAddNewPoiMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.AddNewPoiMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.AddNewPoiMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.AddNewPoiMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDownloadPlatformClientSettingsRequest {
                    message?: (string|null);
                }

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

                interface IGetAvailableSkusAndBalancesRequest {
                }

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

                interface IGetFitnessReportMessage {
                    num_of_days?: (number|null);
                    num_of_weeks?: (number|null);
                }

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

                interface IListLoginActionMessage {
                }

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

                interface IPurchaseSkuRequest {
                    sku_id?: (string|null);
                }

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

                interface IRedeemGoogleReceiptRequest {
                    receipt?: (string|null);
                    receipt_signature?: (string|null);
                    purchase_currency?: (string|null);
                    price_paid_e6?: (number|null);
                    price_paid_e6_long?: (number|Long|null);
                }

                class RedeemGoogleReceiptRequest implements IRedeemGoogleReceiptRequest {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IRedeemGoogleReceiptRequest);
                    public receipt: string;
                    public receipt_signature: string;
                    public purchase_currency: string;
                    public price_paid_e6: number;
                    public price_paid_e6_long: (number|Long);
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IRedeemGoogleReceiptRequest, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.RedeemGoogleReceiptRequest;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.RedeemGoogleReceiptRequest;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.RedeemGoogleReceiptRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IRedeemPasscodeRequest {
                    qrcode?: (string|null);
                }

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

                interface IRegisterDownstreamServerActionsRequest {
                }

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

                interface IRegisterPushNotificationMessage {
                    apn_token?: (POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage.IApnToken|null);
                    gcm_token?: (POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage.IGcmToken|null);
                }

                class RegisterPushNotificationMessage implements IRegisterPushNotificationMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IRegisterPushNotificationMessage);
                    public apn_token?: (POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage.IApnToken|null);
                    public gcm_token?: (POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage.IGcmToken|null);
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IRegisterPushNotificationMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.RegisterPushNotificationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace RegisterPushNotificationMessage {

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

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

                    interface IGcmToken {
                        registration_id?: (string|null);
                    }

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

                interface IRemoveLoginActionMessage {
                    identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                }

                class RemoveLoginActionMessage implements IRemoveLoginActionMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IRemoveLoginActionMessage);
                    public identity_provider: POGOProtos.Enums.IdentityProvider;
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IRemoveLoginActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.RemoveLoginActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.RemoveLoginActionMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.RemoveLoginActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IReplaceLoginActionMessage {
                    existing_identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                    new_login?: (POGOProtos.Networking.Platform.Requests.IAddLoginActionMessage|null);
                }

                class ReplaceLoginActionMessage implements IReplaceLoginActionMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IReplaceLoginActionMessage);
                    public existing_identity_provider: POGOProtos.Enums.IdentityProvider;
                    public new_login?: (POGOProtos.Networking.Platform.Requests.IAddLoginActionMessage|null);
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IReplaceLoginActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.ReplaceLoginActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.ReplaceLoginActionMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.ReplaceLoginActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISendEncryptedSignatureRequest {
                    encrypted_signature?: (Uint8Array|null);
                }

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

                interface ISetInGameCurrencyExchangeRateMessage {
                    in_game_currency?: (string|null);
                    fiat_currency?: (string|null);
                    fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
                }

                class SetInGameCurrencyExchangeRateMessage implements ISetInGameCurrencyExchangeRateMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.ISetInGameCurrencyExchangeRateMessage);
                    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.Networking.Platform.Requests.ISetInGameCurrencyExchangeRateMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.SetInGameCurrencyExchangeRateMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.SetInGameCurrencyExchangeRateMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.SetInGameCurrencyExchangeRateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUpdateFitnessMetricsMessage {
                    fitness_samples?: (POGOProtos.Data.Fitness.IFitnessSample[]|null);
                }

                class UpdateFitnessMetricsMessage implements IUpdateFitnessMetricsMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IUpdateFitnessMetricsMessage);
                    public fitness_samples: POGOProtos.Data.Fitness.IFitnessSample[];
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IUpdateFitnessMetricsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.UpdateFitnessMetricsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.UpdateFitnessMetricsMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.UpdateFitnessMetricsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUpdateNotificationStatusMessage {
                    notification_ids?: (string[]|null);
                    create_timestamp_ms?: ((number|Long)[]|null);
                    state?: (POGOProtos.Enums.NotificationState|null);
                }

                class UpdateNotificationStatusMessage implements IUpdateNotificationStatusMessage {
                    constructor(properties?: POGOProtos.Networking.Platform.Requests.IUpdateNotificationStatusMessage);
                    public notification_ids: string[];
                    public create_timestamp_ms: (number|Long)[];
                    public state: POGOProtos.Enums.NotificationState;
                    public static encode(message: POGOProtos.Networking.Platform.Requests.IUpdateNotificationStatusMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Requests.UpdateNotificationStatusMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Requests.UpdateNotificationStatusMessage;
                    public static toObject(message: POGOProtos.Networking.Platform.Requests.UpdateNotificationStatusMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            namespace Responses {

                interface IAddLoginActionResponse {
                    success?: (boolean|null);
                    login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                    status?: (POGOProtos.Networking.Platform.Responses.AddLoginActionResponse.Status|null);
                }

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

                namespace AddLoginActionResponse {

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

                interface IAddNewPoiResponse {
                    status?: (POGOProtos.Networking.Platform.Responses.AddNewPoiResponse.Status|null);
                    message?: (string[]|null);
                }

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

                namespace AddNewPoiResponse {

                    enum Status {
                        UNSET = 0,
                        SUCCESS = 1,
                        FAILURE = 2,
                        INTERNAL_ERROR = 3,
                        TOO_MANY_RECENT_SUBMISSIONS = 4,
                        INVALID_INPUT = 5
                    }
                }

                interface IDownloadPlatformClientSettingsResponse {
                    message?: (string|null);
                }

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

                interface IGetAvailableSkusAndBalancesResponse {
                    status?: (POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.Status|null);
                    available_sku?: (POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku[]|null);
                    player_currencies?: (POGOProtos.Data.Store.ICurrencyQuantity[]|null);
                    player_token?: (string|null);
                }

                class GetAvailableSkusAndBalancesResponse implements IGetAvailableSkusAndBalancesResponse {
                    constructor(properties?: POGOProtos.Networking.Platform.Responses.IGetAvailableSkusAndBalancesResponse);
                    public status: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.Status;
                    public available_sku: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku[];
                    public player_currencies: POGOProtos.Data.Store.ICurrencyQuantity[];
                    public player_token: string;
                    public static encode(message: POGOProtos.Networking.Platform.Responses.IGetAvailableSkusAndBalancesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse;
                    public static toObject(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace GetAvailableSkusAndBalancesResponse {

                    interface IAvailableSku {
                        id?: (string|null);
                        is_third_party_vendor_item?: (boolean|null);
                        price?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                        currency_granted?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                        game_item_content?: (POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IGameItemContent[]|null);
                        presentation_data?: (POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.ISkuPresentation[]|null);
                        can_be_purchased?: (boolean|null);
                    }

                    class AvailableSku implements IAvailableSku {
                        constructor(properties?: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku);
                        public id: string;
                        public is_third_party_vendor_item: boolean;
                        public price?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                        public currency_granted?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                        public game_item_content: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IGameItemContent[];
                        public presentation_data: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.ISkuPresentation[];
                        public can_be_purchased: boolean;
                        public static encode(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.AvailableSku;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.AvailableSku;
                        public static toObject(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.AvailableSku, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }

                    interface IGameItemContent {
                        type?: (string|null);
                        quantity?: (number|null);
                    }

                    class GameItemContent implements IGameItemContent {
                        constructor(properties?: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IGameItemContent);
                        public type: string;
                        public quantity: number;
                        public static encode(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.IGameItemContent, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.GameItemContent;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.GameItemContent;
                        public static toObject(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.GameItemContent, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }

                    interface ISkuPresentation {
                        key?: (string|null);
                        value?: (string|null);
                    }

                    class SkuPresentation implements ISkuPresentation {
                        constructor(properties?: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.ISkuPresentation);
                        public key: string;
                        public value: string;
                        public static encode(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.ISkuPresentation, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.SkuPresentation;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.SkuPresentation;
                        public static toObject(message: POGOProtos.Networking.Platform.Responses.GetAvailableSkusAndBalancesResponse.SkuPresentation, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }

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

                interface IGetFitnessReportResponse {
                    status?: (POGOProtos.Networking.Platform.Responses.GetFitnessReportResponse.Status|null);
                    daily_reports?: (POGOProtos.Data.Fitness.IFitnessReport[]|null);
                    weekly_reports?: (POGOProtos.Data.Fitness.IFitnessReport[]|null);
                }

                class GetFitnessReportResponse implements IGetFitnessReportResponse {
                    constructor(properties?: POGOProtos.Networking.Platform.Responses.IGetFitnessReportResponse);
                    public status: POGOProtos.Networking.Platform.Responses.GetFitnessReportResponse.Status;
                    public daily_reports: POGOProtos.Data.Fitness.IFitnessReport[];
                    public weekly_reports: POGOProtos.Data.Fitness.IFitnessReport[];
                    public static encode(message: POGOProtos.Networking.Platform.Responses.IGetFitnessReportResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.GetFitnessReportResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.GetFitnessReportResponse;
                    public static toObject(message: POGOProtos.Networking.Platform.Responses.GetFitnessReportResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace GetFitnessReportResponse {

                    enum Status {
                        UNSET = 0,
                        SUCCESS = 1,
                        ERROR_PLAYER_NOT_FOUND = 2,
                        ERROR_RECORDS_NOT_FOUND = 3,
                        ERROR_INVALID_WINDOW = 4,
                        ERROR_UNKNOWN = 5
                    }
                }

                interface IListLoginActionResponse {
                    success?: (boolean|null);
                    login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                }

                class ListLoginActionResponse implements IListLoginActionResponse {
                    constructor(properties?: POGOProtos.Networking.Platform.Responses.IListLoginActionResponse);
                    public success: boolean;
                    public login_detail: POGOProtos.Data.Login.ILoginDetail[];
                    public static encode(message: POGOProtos.Networking.Platform.Responses.IListLoginActionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.ListLoginActionResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.ListLoginActionResponse;
                    public static toObject(message: POGOProtos.Networking.Platform.Responses.ListLoginActionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IPurchaseSkuResponse {
                    result?: (POGOProtos.Networking.Platform.Responses.PurchaseSkuResponse.Status|null);
                    added_inventory_item?: (Uint8Array[]|null);
                    currency_update?: (POGOProtos.Data.Store.ICurrencyUpdate[]|null);
                }

                class PurchaseSkuResponse implements IPurchaseSkuResponse {
                    constructor(properties?: POGOProtos.Networking.Platform.Responses.IPurchaseSkuResponse);
                    public result: POGOProtos.Networking.Platform.Responses.PurchaseSkuResponse.Status;
                    public added_inventory_item: Uint8Array[];
                    public currency_update: POGOProtos.Data.Store.ICurrencyUpdate[];
                    public static encode(message: POGOProtos.Networking.Platform.Responses.IPurchaseSkuResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.PurchaseSkuResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.PurchaseSkuResponse;
                    public static toObject(message: POGOProtos.Networking.Platform.Responses.PurchaseSkuResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace PurchaseSkuResponse {

                    enum Status {
                        UNSET = 0,
                        SUCCESS = 1,
                        FAILURE = 2,
                        BALANCE_TOO_LOW = 3,
                        SKU_NOT_AVAILABLE = 4,
                        OVER_INVENTORY_LIMIT = 5
                    }
                }

                interface IRedeemGoogleReceiptResponse {
                    result?: (POGOProtos.Networking.Platform.Responses.RedeemGoogleReceiptResponse.Status|null);
                    transaction_token?: (string|null);
                }

                class RedeemGoogleReceiptResponse implements IRedeemGoogleReceiptResponse {
                    constructor(properties?: POGOProtos.Networking.Platform.Responses.IRedeemGoogleReceiptResponse);
                    public result: POGOProtos.Networking.Platform.Responses.RedeemGoogleReceiptResponse.Status;
                    public transaction_token: string;
                    public static encode(message: POGOProtos.Networking.Platform.Responses.IRedeemGoogleReceiptResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.RedeemGoogleReceiptResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.RedeemGoogleReceiptResponse;
                    public static toObject(message: POGOProtos.Networking.Platform.Responses.RedeemGoogleReceiptResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace RedeemGoogleReceiptResponse {

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

                interface IRedeemPasscodeResponse {
                    status?: (POGOProtos.Networking.Platform.Responses.RedeemPasscodeResponse.Status|null);
                    qrcode?: (string|null);
                }

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

                namespace RedeemPasscodeResponse {

                    enum Status {
                        UNDEFINED = 0,
                        SUCCESS = 1,
                        INVALID = 2
                    }
                }

                interface IRegisterDownstreamServerActionsResponse {
                }

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

                interface IRegisterPushNotificationResponse {
                    result?: (POGOProtos.Networking.Platform.Responses.RegisterPushNotificationResponse.Result|null);
                }

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

                namespace RegisterPushNotificationResponse {

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

                interface IRemoveLoginActionResponse {
                    success?: (boolean|null);
                    login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                    status?: (POGOProtos.Networking.Platform.Responses.RemoveLoginActionResponse.Status|null);
                }

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

                namespace RemoveLoginActionResponse {

                    enum Status {
                        UNSET = 0,
                        LOGIN_NOT_REMOVABLE = 1
                    }
                }

                interface IReplaceLoginActionResponse {
                    success?: (boolean|null);
                    login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                    status?: (POGOProtos.Networking.Platform.Responses.ReplaceLoginActionResponse.Status|null);
                }

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

                namespace ReplaceLoginActionResponse {

                    enum Status {
                        UNSET = 0,
                        AUTH_FAILURE = 1,
                        LOGIN_TAKEN = 2,
                        LOGIN_ALREADY_HAVE = 3,
                        LOGIN_NOT_REPLACEABLE = 4
                    }
                }

                interface ISendEncryptedSignatureResponse {
                    received?: (boolean|null);
                }

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

                interface ISetInGameCurrencyExchangeRateResponse {
                    status?: (POGOProtos.Networking.Platform.Responses.SetInGameCurrencyExchangeRateResponse.Status|null);
                }

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

                namespace SetInGameCurrencyExchangeRateResponse {

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

                interface IUpdateFitnessMetricsResponse {
                    status?: (POGOProtos.Networking.Platform.Responses.UpdateFitnessMetricsResponse.Status|null);
                }

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

                namespace UpdateFitnessMetricsResponse {

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

                interface IUpdateNotificationStatusResponse {
                    notification_ids?: (string[]|null);
                    create_timestamp_ms?: ((number|Long)[]|null);
                    state?: (POGOProtos.Enums.NotificationState|null);
                }

                class UpdateNotificationStatusResponse implements IUpdateNotificationStatusResponse {
                    constructor(properties?: POGOProtos.Networking.Platform.Responses.IUpdateNotificationStatusResponse);
                    public notification_ids: string[];
                    public create_timestamp_ms: (number|Long)[];
                    public state: POGOProtos.Enums.NotificationState;
                    public static encode(message: POGOProtos.Networking.Platform.Responses.IUpdateNotificationStatusResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Platform.Responses.UpdateNotificationStatusResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Platform.Responses.UpdateNotificationStatusResponse;
                    public static toObject(message: POGOProtos.Networking.Platform.Responses.UpdateNotificationStatusResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        namespace Requests {

            namespace Messages {

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

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

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

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

                interface IAddFortModifierMessage {
                    modifier_type?: (POGOProtos.Inventory.Item.ItemId|null);
                    fort_id?: (string|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class AddFortModifierMessage implements IAddFortModifierMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IAddFortModifierMessage);
                    public modifier_type: POGOProtos.Inventory.Item.ItemId;
                    public fort_id: string;
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IAddFortModifierMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.AddFortModifierMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.AddFortModifierMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.AddFortModifierMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IAttackGymMessage {
                    gym_id?: (string|null);
                    battle_id?: (string|null);
                    attack_actions?: (POGOProtos.Data.Battle.IBattleAction[]|null);
                    last_retrieved_action?: (POGOProtos.Data.Battle.IBattleAction|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class AttackGymMessage implements IAttackGymMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IAttackGymMessage);
                    public gym_id: string;
                    public battle_id: string;
                    public attack_actions: POGOProtos.Data.Battle.IBattleAction[];
                    public last_retrieved_action?: (POGOProtos.Data.Battle.IBattleAction|null);
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IAttackGymMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.AttackGymMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.AttackGymMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.AttackGymMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IAttackRaidBattleMessage {
                    gym_id?: (string|null);
                    battle_id?: (string|null);
                    attacker_actions?: (POGOProtos.Data.Battle.IBattleAction[]|null);
                    last_retrieved_action?: (POGOProtos.Data.Battle.IBattleAction|null);
                    timestamp_ms?: (number|Long|null);
                }

                class AttackRaidBattleMessage implements IAttackRaidBattleMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IAttackRaidBattleMessage);
                    public gym_id: string;
                    public battle_id: string;
                    public attacker_actions: POGOProtos.Data.Battle.IBattleAction[];
                    public last_retrieved_action?: (POGOProtos.Data.Battle.IBattleAction|null);
                    public timestamp_ms: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IAttackRaidBattleMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.AttackRaidBattleMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.AttackRaidBattleMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.AttackRaidBattleMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IBelugaTransactionCompleteMessage {
                    beluga_transfer?: (POGOProtos.Data.Beluga.IBelugaBleCompleteTransferRequest|null);
                    app_signature?: (Uint8Array|null);
                    firmware_signature?: (Uint8Array|null);
                }

                class BelugaTransactionCompleteMessage implements IBelugaTransactionCompleteMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IBelugaTransactionCompleteMessage);
                    public beluga_transfer?: (POGOProtos.Data.Beluga.IBelugaBleCompleteTransferRequest|null);
                    public app_signature: Uint8Array;
                    public firmware_signature: Uint8Array;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IBelugaTransactionCompleteMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.BelugaTransactionCompleteMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.BelugaTransactionCompleteMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.BelugaTransactionCompleteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IBelugaTransactionStartMessage {
                    pokemon_id?: ((number|Long)[]|null);
                    nonce?: (string|null);
                    beluga_id?: (string|null);
                }

                class BelugaTransactionStartMessage implements IBelugaTransactionStartMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IBelugaTransactionStartMessage);
                    public pokemon_id: (number|Long)[];
                    public nonce: string;
                    public beluga_id: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IBelugaTransactionStartMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.BelugaTransactionStartMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.BelugaTransactionStartMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.BelugaTransactionStartMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ICancelCombatChallengeMessage {
                    challenge_id?: (string|null);
                }

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

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

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

                interface ICatchPokemonMessage {
                    encounter_id?: (number|Long|null);
                    pokeball?: (POGOProtos.Inventory.Item.ItemId|null);
                    normalized_reticle_size?: (number|null);
                    spawn_point_id?: (string|null);
                    hit_pokemon?: (boolean|null);
                    spin_modifier?: (number|null);
                    normalized_hit_position?: (number|null);
                    ar_plus_values?: (POGOProtos.Data.IARPlusEncounterValues|null);
                }

                class CatchPokemonMessage implements ICatchPokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ICatchPokemonMessage);
                    public encounter_id: (number|Long);
                    public pokeball: POGOProtos.Inventory.Item.ItemId;
                    public normalized_reticle_size: number;
                    public spawn_point_id: string;
                    public hit_pokemon: boolean;
                    public spin_modifier: number;
                    public normalized_hit_position: number;
                    public ar_plus_values?: (POGOProtos.Data.IARPlusEncounterValues|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ICatchPokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.CatchPokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.CatchPokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.CatchPokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IChangeTeamMessage {
                    item?: (POGOProtos.Inventory.Item.ItemId|null);
                    team?: (POGOProtos.Enums.TeamColor|null);
                }

                class ChangeTeamMessage implements IChangeTeamMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IChangeTeamMessage);
                    public item: POGOProtos.Inventory.Item.ItemId;
                    public team: POGOProtos.Enums.TeamColor;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IChangeTeamMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ChangeTeamMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ChangeTeamMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ChangeTeamMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ICheckAwardedBadgesMessage {
                }

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

                interface ICheckChallengeMessage {
                    debug_request?: (boolean|null);
                }

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

                interface ICheckPhotobombMessage {
                    photo_pokemon_id?: (number|Long|null);
                }

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

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

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

                interface ICheckShareExRaidPassMessage {
                    friend_id?: (string|null);
                    fort_id?: (string|null);
                    raid_seed?: (number|Long|null);
                }

                class CheckShareExRaidPassMessage implements ICheckShareExRaidPassMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ICheckShareExRaidPassMessage);
                    public friend_id: string;
                    public fort_id: string;
                    public raid_seed: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ICheckShareExRaidPassMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.CheckShareExRaidPassMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.CheckShareExRaidPassMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.CheckShareExRaidPassMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IClaimCodenameMessage {
                    codename?: (string|null);
                    force?: (boolean|null);
                    generate_suggested_codenames?: (boolean|null);
                }

                class ClaimCodenameMessage implements IClaimCodenameMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IClaimCodenameMessage);
                    public codename: string;
                    public force: boolean;
                    public generate_suggested_codenames: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IClaimCodenameMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ClaimCodenameMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ClaimCodenameMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ClaimCodenameMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ICollectDailyBonusMessage {
                }

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

                interface ICollectDailyDefenderBonusMessage {
                }

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

                interface ICombatFriendRequestMessage {
                    combat_id?: (string|null);
                }

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

                interface ICompleteQuestMessage {
                    quest_id?: (string|null);
                    sub_quest_id?: (string|null);
                }

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

                interface ICompleteQuestStampCardMessage {
                }

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

                interface IConfirmPhotobombMessage {
                    encounter_id?: (number|Long|null);
                }

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

                interface IConfirmTradingMessage {
                    player_id?: (string|null);
                    transaction_log?: (string|null);
                }

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

                interface ICreateCombatChallengeMessage {
                    challenge_id?: (string|null);
                }

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

                interface IDeclineCombatChallengeMessage {
                    challenge_id?: (string|null);
                }

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

                interface IDeclineSharedExRaidPassMessage {
                    fort_id?: (string|null);
                    raid_seed?: (number|Long|null);
                }

                class DeclineSharedExRaidPassMessage implements IDeclineSharedExRaidPassMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IDeclineSharedExRaidPassMessage);
                    public fort_id: string;
                    public raid_seed: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IDeclineSharedExRaidPassMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.DeclineSharedExRaidPassMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.DeclineSharedExRaidPassMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.DeclineSharedExRaidPassMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDeleteGiftFromInventoryMessage {
                    giftbox_id?: ((number|Long)[]|null);
                }

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

                interface IDeleteGiftMessage {
                    player_id?: (string|null);
                    giftbox_id?: (number|Long|null);
                }

                class DeleteGiftMessage implements IDeleteGiftMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IDeleteGiftMessage);
                    public player_id: string;
                    public giftbox_id: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IDeleteGiftMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.DeleteGiftMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.DeleteGiftMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.DeleteGiftMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDiskEncounterMessage {
                    encounter_id?: (number|Long|null);
                    fort_id?: (string|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                    gym_lat_degrees?: (number|null);
                    gym_lng_degrees?: (number|null);
                }

                class DiskEncounterMessage implements IDiskEncounterMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IDiskEncounterMessage);
                    public encounter_id: (number|Long);
                    public fort_id: string;
                    public player_latitude: number;
                    public player_longitude: number;
                    public gym_lat_degrees: number;
                    public gym_lng_degrees: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IDiskEncounterMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.DiskEncounterMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.DiskEncounterMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.DiskEncounterMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDownloadGmTemplatesMessage {
                    basis_batch_id?: (number|Long|null);
                    batch_id?: (number|Long|null);
                    page_offset?: (number|null);
                }

                class DownloadGmTemplatesMessage implements IDownloadGmTemplatesMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IDownloadGmTemplatesMessage);
                    public basis_batch_id: (number|Long);
                    public batch_id: (number|Long);
                    public page_offset: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IDownloadGmTemplatesMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.DownloadGmTemplatesMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.DownloadGmTemplatesMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.DownloadGmTemplatesMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDownloadItemTemplatesMessage {
                    paginate?: (boolean|null);
                    page_offset?: (number|null);
                    page_timestamp?: (number|Long|null);
                }

                class DownloadItemTemplatesMessage implements IDownloadItemTemplatesMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IDownloadItemTemplatesMessage);
                    public paginate: boolean;
                    public page_offset: number;
                    public page_timestamp: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IDownloadItemTemplatesMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.DownloadItemTemplatesMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.DownloadItemTemplatesMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.DownloadItemTemplatesMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDownloadRemoteConfigVersionMessage {
                    platform?: (POGOProtos.Enums.Platform|null);
                    device_manufacturer?: (string|null);
                    device_model?: (string|null);
                    locale?: (string|null);
                    app_version?: (number|null);
                }

                class DownloadRemoteConfigVersionMessage implements IDownloadRemoteConfigVersionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IDownloadRemoteConfigVersionMessage);
                    public platform: POGOProtos.Enums.Platform;
                    public device_manufacturer: string;
                    public device_model: string;
                    public locale: string;
                    public app_version: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IDownloadRemoteConfigVersionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.DownloadRemoteConfigVersionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.DownloadRemoteConfigVersionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.DownloadRemoteConfigVersionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IDownloadSettingsMessage {
                    hash?: (string|null);
                }

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

                interface IEchoMessage {
                }

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

                interface IEncounterMessage {
                    encounter_id?: (number|Long|null);
                    spawn_point_id?: (string|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class EncounterMessage implements IEncounterMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IEncounterMessage);
                    public encounter_id: (number|Long);
                    public spawn_point_id: string;
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IEncounterMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.EncounterMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.EncounterMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.EncounterMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IEncounterTutorialCompleteMessage {
                    pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                }

                class EncounterTutorialCompleteMessage implements IEncounterTutorialCompleteMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IEncounterTutorialCompleteMessage);
                    public pokemon_id: POGOProtos.Enums.PokemonId;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IEncounterTutorialCompleteMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.EncounterTutorialCompleteMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.EncounterTutorialCompleteMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.EncounterTutorialCompleteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IEquipBadgeMessage {
                    badge_type?: (POGOProtos.Enums.BadgeType|null);
                }

                class EquipBadgeMessage implements IEquipBadgeMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IEquipBadgeMessage);
                    public badge_type: POGOProtos.Enums.BadgeType;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IEquipBadgeMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.EquipBadgeMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.EquipBadgeMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.EquipBadgeMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IEvolvePokemonMessage {
                    pokemon_id?: (number|Long|null);
                    evolution_item_requirement?: (POGOProtos.Inventory.Item.ItemId|null);
                }

                class EvolvePokemonMessage implements IEvolvePokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IEvolvePokemonMessage);
                    public pokemon_id: (number|Long);
                    public evolution_item_requirement: POGOProtos.Inventory.Item.ItemId;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IEvolvePokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.EvolvePokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.EvolvePokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.EvolvePokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IFetchAllNewsMessage {
                }

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

                interface IFortDeployPokemonMessage {
                    fort_id?: (string|null);
                    pokemon_id?: (number|Long|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class FortDeployPokemonMessage implements IFortDeployPokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IFortDeployPokemonMessage);
                    public fort_id: string;
                    public pokemon_id: (number|Long);
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IFortDeployPokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.FortDeployPokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.FortDeployPokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.FortDeployPokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IFortDetailsMessage {
                    fort_id?: (string|null);
                    latitude?: (number|null);
                    longitude?: (number|null);
                }

                class FortDetailsMessage implements IFortDetailsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IFortDetailsMessage);
                    public fort_id: string;
                    public latitude: number;
                    public longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IFortDetailsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.FortDetailsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.FortDetailsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.FortDetailsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IFortRecallPokemonMessage {
                    fort_id?: (string|null);
                    pokemon_id?: (number|Long|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class FortRecallPokemonMessage implements IFortRecallPokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IFortRecallPokemonMessage);
                    public fort_id: string;
                    public pokemon_id: (number|Long);
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IFortRecallPokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.FortRecallPokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.FortRecallPokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.FortRecallPokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IFortSearchMessage {
                    fort_id?: (string|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                    fort_latitude?: (number|null);
                    fort_longitude?: (number|null);
                }

                class FortSearchMessage implements IFortSearchMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IFortSearchMessage);
                    public fort_id: string;
                    public player_latitude: number;
                    public player_longitude: number;
                    public fort_latitude: number;
                    public fort_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IFortSearchMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.FortSearchMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.FortSearchMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.FortSearchMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGenerateCombatChallengeIdMessage {
                }

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

                interface IGenerateGmapSignedUrlMessage {
                    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 GenerateGmapSignedUrlMessage implements IGenerateGmapSignedUrlMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGenerateGmapSignedUrlMessage);
                    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.Networking.Requests.Messages.IGenerateGmapSignedUrlMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GenerateGmapSignedUrlMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GenerateGmapSignedUrlMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GenerateGmapSignedUrlMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetAssetDigestMessage {
                    platform?: (POGOProtos.Enums.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 GetAssetDigestMessage implements IGetAssetDigestMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetAssetDigestMessage);
                    public platform: POGOProtos.Enums.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.Networking.Requests.Messages.IGetAssetDigestMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetAssetDigestMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetAssetDigestMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetAssetDigestMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetAvailableSkusAndBalancesMessage {
                }

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

                interface IGetBuddyWalkedMessage {
                }

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

                interface IGetClientBgmodeSettingsMessage {
                }

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

                interface IGetClientTelemetrySettingsMessage {
                }

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

                interface IGetCombatChallengeMessage {
                    challenge_id?: (string|null);
                }

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

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

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

                interface IGetCombatResultsMessage {
                    combat_id?: (string|null);
                }

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

                interface IGetDownloadUrlsMessage {
                    asset_id?: (string[]|null);
                }

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

                interface IGetFitnessReportMessage {
                    num_of_days?: (number|null);
                    num_of_weeks?: (number|null);
                }

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

                interface IGetFitnessRewardsMessage {
                }

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

                interface IGetFriendshipMilestoneRewardsMessage {
                    friend_id?: (string|null);
                }

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

                interface IGetFriendshipRewardsMessage {
                    friend_id?: (string|null);
                }

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

                interface IGetGymBadgeDetailsMessage {
                    fort_id?: (string|null);
                    latitude?: (number|null);
                    longitude?: (number|null);
                }

                class GetGymBadgeDetailsMessage implements IGetGymBadgeDetailsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetGymBadgeDetailsMessage);
                    public fort_id: string;
                    public latitude: number;
                    public longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetGymBadgeDetailsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetGymBadgeDetailsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetGymBadgeDetailsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetGymBadgeDetailsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetGymDetailsMessage {
                    gym_id?: (string|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                    gym_latitude?: (number|null);
                    gym_longitude?: (number|null);
                    client_version?: (string|null);
                }

                class GetGymDetailsMessage implements IGetGymDetailsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetGymDetailsMessage);
                    public gym_id: string;
                    public player_latitude: number;
                    public player_longitude: number;
                    public gym_latitude: number;
                    public gym_longitude: number;
                    public client_version: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetGymDetailsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetGymDetailsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetGymDetailsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetGymDetailsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetHatchedEggsMessage {
                }

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

                interface IGetHoloInventoryMessage {
                    last_timestamp_ms?: (number|Long|null);
                    item_been_seen?: (number|null);
                }

                class GetHoloInventoryMessage implements IGetHoloInventoryMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetHoloInventoryMessage);
                    public last_timestamp_ms: (number|Long);
                    public item_been_seen: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetHoloInventoryMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetHoloInventoryMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetHoloInventoryMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetHoloInventoryMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetInboxMessage {
                    is_history?: (boolean|null);
                    is_reverse?: (boolean|null);
                    not_before_ms?: (number|Long|null);
                }

                class GetInboxMessage implements IGetInboxMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetInboxMessage);
                    public is_history: boolean;
                    public is_reverse: boolean;
                    public not_before_ms: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetInboxMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetInboxMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetInboxMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetInboxMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetIncensePokemonMessage {
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

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

                interface IGetInventoryMessage {
                    last_timestamp_ms?: (number|Long|null);
                }

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

                interface IGetMapObjectsMessage {
                    cell_id?: ((number|Long)[]|null);
                    since_timestamp_ms?: ((number|Long)[]|null);
                    latitude?: (number|null);
                    longitude?: (number|null);
                }

                class GetMapObjectsMessage implements IGetMapObjectsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetMapObjectsMessage);
                    public cell_id: (number|Long)[];
                    public since_timestamp_ms: (number|Long)[];
                    public latitude: number;
                    public longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetMapObjectsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetMapObjectsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetMapObjectsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetMapObjectsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetNewQuestsMessage {
                }

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

                interface IGetNpcCombatRewardsMessage {
                    combat_npc_trainer_template_id?: (string|null);
                    finish_state?: (POGOProtos.Enums.CombatPlayerFinishState|null);
                    attacking_pokemon_id?: ((number|Long)[]|null);
                    combat_id?: (string|null);
                }

                class GetNpcCombatRewardsMessage implements IGetNpcCombatRewardsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetNpcCombatRewardsMessage);
                    public combat_npc_trainer_template_id: string;
                    public finish_state: POGOProtos.Enums.CombatPlayerFinishState;
                    public attacking_pokemon_id: (number|Long)[];
                    public combat_id: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetNpcCombatRewardsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetNpcCombatRewardsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetNpcCombatRewardsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetNpcCombatRewardsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetPhotobombMessage {
                }

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

                interface IGetPlayerDayMessage {
                }

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

                interface IGetPlayerMessage {
                    player_locale?: (POGOProtos.Networking.Requests.Messages.GetPlayerMessage.IPlayerLocale|null);
                    prevent_creation?: (boolean|null);
                }

                class GetPlayerMessage implements IGetPlayerMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetPlayerMessage);
                    public player_locale?: (POGOProtos.Networking.Requests.Messages.GetPlayerMessage.IPlayerLocale|null);
                    public prevent_creation: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetPlayerMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetPlayerMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetPlayerMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetPlayerMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace GetPlayerMessage {

                    interface IPlayerLocale {
                        country?: (string|null);
                        language?: (string|null);
                        timezone?: (string|null);
                    }

                    class PlayerLocale implements IPlayerLocale {
                        constructor(properties?: POGOProtos.Networking.Requests.Messages.GetPlayerMessage.IPlayerLocale);
                        public country: string;
                        public language: string;
                        public timezone: string;
                        public static encode(message: POGOProtos.Networking.Requests.Messages.GetPlayerMessage.IPlayerLocale, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetPlayerMessage.PlayerLocale;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetPlayerMessage.PlayerLocale;
                        public static toObject(message: POGOProtos.Networking.Requests.Messages.GetPlayerMessage.PlayerLocale, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }
                }

                interface IGetPlayerProfileMessage {
                    player_name?: (string|null);
                }

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

                interface IGetQuestDetailsMessage {
                    quest_id?: (string[]|null);
                }

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

                interface IGetRaidDetailsMessage {
                    raid_seed?: (number|Long|null);
                    gym_id?: (string|null);
                    lobby_id?: (number[]|null);
                    player_lat_degrees?: (number|null);
                    player_lng_degrees?: (number|null);
                }

                class GetRaidDetailsMessage implements IGetRaidDetailsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetRaidDetailsMessage);
                    public raid_seed: (number|Long);
                    public gym_id: string;
                    public lobby_id: number[];
                    public player_lat_degrees: number;
                    public player_lng_degrees: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGetRaidDetailsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetRaidDetailsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetRaidDetailsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetRaidDetailsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetSignedGmapUrlMessage {
                    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 GetSignedGmapUrlMessage implements IGetSignedGmapUrlMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGetSignedGmapUrlMessage);
                    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.Networking.Requests.Messages.IGetSignedGmapUrlMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GetSignedGmapUrlMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GetSignedGmapUrlMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GetSignedGmapUrlMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IGetTutorialEggActionMessage {
                }

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

                interface IGetUploadUrlMessage {
                    user_id?: (string|null);
                    game_unique_id?: (string|null);
                }

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

                interface IGiftDetailsMessage {
                    giftbox_id?: ((number|Long)[]|null);
                    player_id?: (string|null);
                }

                class GiftDetailsMessage implements IGiftDetailsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGiftDetailsMessage);
                    public giftbox_id: (number|Long)[];
                    public player_id: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGiftDetailsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GiftDetailsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GiftDetailsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GiftDetailsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGymBattleAttackMessage {
                    gym_id?: (string|null);
                    battle_id?: (string|null);
                    attacker_actions?: (POGOProtos.Data.Battle.IBattleAction[]|null);
                    last_retrieved_action?: (POGOProtos.Data.Battle.IBattleAction|null);
                    player_lat_degrees?: (number|null);
                    player_lng_degrees?: (number|null);
                    timestamp_ms?: (number|Long|null);
                }

                class GymBattleAttackMessage implements IGymBattleAttackMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGymBattleAttackMessage);
                    public gym_id: string;
                    public battle_id: string;
                    public attacker_actions: POGOProtos.Data.Battle.IBattleAction[];
                    public last_retrieved_action?: (POGOProtos.Data.Battle.IBattleAction|null);
                    public player_lat_degrees: number;
                    public player_lng_degrees: number;
                    public timestamp_ms: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGymBattleAttackMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GymBattleAttackMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GymBattleAttackMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GymBattleAttackMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGymDeployMessage {
                    fort_id?: (string|null);
                    pokemon_id?: (number|Long|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class GymDeployMessage implements IGymDeployMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGymDeployMessage);
                    public fort_id: string;
                    public pokemon_id: (number|Long);
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IGymDeployMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GymDeployMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GymDeployMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GymDeployMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGymFeedPokemonMessage {
                    item?: (POGOProtos.Inventory.Item.ItemId|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 GymFeedPokemonMessage implements IGymFeedPokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGymFeedPokemonMessage);
                    public item: POGOProtos.Inventory.Item.ItemId;
                    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.Networking.Requests.Messages.IGymFeedPokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GymFeedPokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GymFeedPokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GymFeedPokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGymGetInfoMessage {
                    gym_id?: (string|null);
                    player_lat_degrees?: (number|null);
                    player_lng_degrees?: (number|null);
                    gym_lat_degrees?: (number|null);
                    gym_lng_degrees?: (number|null);
                }

                class GymGetInfoMessage implements IGymGetInfoMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGymGetInfoMessage);
                    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 static encode(message: POGOProtos.Networking.Requests.Messages.IGymGetInfoMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GymGetInfoMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GymGetInfoMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GymGetInfoMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGymStartSessionMessage {
                    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 GymStartSessionMessage implements IGymStartSessionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IGymStartSessionMessage);
                    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.Networking.Requests.Messages.IGymStartSessionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.GymStartSessionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.GymStartSessionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.GymStartSessionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IJoinLobbyMessage {
                    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);
                }

                class JoinLobbyMessage implements IJoinLobbyMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IJoinLobbyMessage);
                    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 static encode(message: POGOProtos.Networking.Requests.Messages.IJoinLobbyMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.JoinLobbyMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.JoinLobbyMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.JoinLobbyMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ILeaveLobbyMessage {
                    raid_seed?: (number|Long|null);
                    gym_id?: (string|null);
                    lobby_id?: (number[]|null);
                }

                class LeaveLobbyMessage implements ILeaveLobbyMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ILeaveLobbyMessage);
                    public raid_seed: (number|Long);
                    public gym_id: string;
                    public lobby_id: number[];
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ILeaveLobbyMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.LeaveLobbyMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.LeaveLobbyMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.LeaveLobbyMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ILevelUpRewardsMessage {
                    level?: (number|null);
                }

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

                interface IListAvatarCustomizationsMessage {
                    avatar_type?: (POGOProtos.Data.Player.PlayerAvatarType|null);
                    slot?: (POGOProtos.Data.Avatar.AvatarCustomization.Slot[]|null);
                    filters?: (POGOProtos.Enums.Filter[]|null);
                    start?: (number|null);
                    limit?: (number|null);
                }

                class ListAvatarCustomizationsMessage implements IListAvatarCustomizationsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IListAvatarCustomizationsMessage);
                    public avatar_type: POGOProtos.Data.Player.PlayerAvatarType;
                    public slot: POGOProtos.Data.Avatar.AvatarCustomization.Slot[];
                    public filters: POGOProtos.Enums.Filter[];
                    public start: number;
                    public limit: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IListAvatarCustomizationsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ListAvatarCustomizationsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ListAvatarCustomizationsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ListAvatarCustomizationsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IListGymBadgesMessage {
                }

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

                interface IMarkReadNewsArticleMessage {
                    news_ids?: (string[]|null);
                }

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

                interface IMarkTutorialCompleteMessage {
                    tutorials_completed?: (POGOProtos.Enums.TutorialState[]|null);
                    send_marketing_emails?: (boolean|null);
                    send_push_notifications?: (boolean|null);
                }

                class MarkTutorialCompleteMessage implements IMarkTutorialCompleteMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IMarkTutorialCompleteMessage);
                    public tutorials_completed: POGOProtos.Enums.TutorialState[];
                    public send_marketing_emails: boolean;
                    public send_push_notifications: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IMarkTutorialCompleteMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.MarkTutorialCompleteMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.MarkTutorialCompleteMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.MarkTutorialCompleteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface INicknamePokemonMessage {
                    pokemon_id?: (number|Long|null);
                    nickname?: (string|null);
                }

                class NicknamePokemonMessage implements INicknamePokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.INicknamePokemonMessage);
                    public pokemon_id: (number|Long);
                    public nickname: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.INicknamePokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.NicknamePokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.NicknamePokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.NicknamePokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IOpenCombatChallengeMessage {
                    type?: (POGOProtos.Enums.CombatType|null);
                    challenge_id?: (string|null);
                    combat_league_template_id?: (string|null);
                    opponent_player_id?: (string|null);
                    attacking_pokemon_id?: ((number|Long)[]|null);
                }

                class OpenCombatChallengeMessage implements IOpenCombatChallengeMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IOpenCombatChallengeMessage);
                    public type: POGOProtos.Enums.CombatType;
                    public challenge_id: string;
                    public combat_league_template_id: string;
                    public opponent_player_id: string;
                    public attacking_pokemon_id: (number|Long)[];
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IOpenCombatChallengeMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.OpenCombatChallengeMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.OpenCombatChallengeMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.OpenCombatChallengeMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IOpenCombatSessionMessage {
                    combat_id?: (string|null);
                    attacking_pokemon_id?: ((number|Long)[]|null);
                    combat_league_template_id?: (string|null);
                }

                class OpenCombatSessionMessage implements IOpenCombatSessionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IOpenCombatSessionMessage);
                    public combat_id: string;
                    public attacking_pokemon_id: (number|Long)[];
                    public combat_league_template_id: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IOpenCombatSessionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.OpenCombatSessionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.OpenCombatSessionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.OpenCombatSessionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IOpenGiftMessage {
                    player_id?: (string|null);
                    giftbox_id?: (number|Long|null);
                }

                class OpenGiftMessage implements IOpenGiftMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IOpenGiftMessage);
                    public player_id: string;
                    public giftbox_id: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IOpenGiftMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.OpenGiftMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.OpenGiftMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.OpenGiftMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

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

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

                interface IRegisterPushNotificationMessage {
                    apn_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IApnToken|null);
                    gcm_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IGcmToken|null);
                }

                class RegisterPushNotificationMessage implements IRegisterPushNotificationMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IRegisterPushNotificationMessage);
                    public apn_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IApnToken|null);
                    public gcm_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IGcmToken|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IRegisterPushNotificationMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace RegisterPushNotificationMessage {

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

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

                    interface IGcmToken {
                        registration_id?: (string|null);
                    }

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

                interface IUpdateNotificationStatusMessage {
                    notification_ids?: (string[]|null);
                    create_timestamp_ms?: ((number|Long)[]|null);
                    state?: (POGOProtos.Enums.NotificationState|null);
                }

                class UpdateNotificationStatusMessage implements IUpdateNotificationStatusMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUpdateNotificationStatusMessage);
                    public notification_ids: string[];
                    public create_timestamp_ms: (number|Long)[];
                    public state: POGOProtos.Enums.NotificationState;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUpdateNotificationStatusMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UpdateNotificationStatusMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UpdateNotificationStatusMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UpdateNotificationStatusMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IOptOutPushNotificationCategoryMessage {
                    categories?: (string[]|null);
                }

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

                interface IRedeemPasscodeMessage {
                    passcode?: (string|null);
                }

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

                interface IAddNewPoiMessage {
                    title?: (string|null);
                    long_description?: (string|null);
                    image_gs_file_path?: (string|null);
                    lat_e6?: (number|null);
                    lng_e6?: (number|null);
                    image_serving_url?: (string|null);
                    user_id?: (string|null);
                    player_language?: (string|null);
                    game_unique_id?: (string|null);
                    app_id?: (string|null);
                    player_reputation?: (POGOProtos.Data.Player.IPlayerReputation|null);
                }

                class AddNewPoiMessage implements IAddNewPoiMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IAddNewPoiMessage);
                    public title: string;
                    public long_description: string;
                    public image_gs_file_path: string;
                    public lat_e6: number;
                    public lng_e6: number;
                    public image_serving_url: string;
                    public user_id: string;
                    public player_language: string;
                    public game_unique_id: string;
                    public app_id: string;
                    public player_reputation?: (POGOProtos.Data.Player.IPlayerReputation|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IAddNewPoiMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.AddNewPoiMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.AddNewPoiMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.AddNewPoiMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IProxySocialActionMessage {
                    action?: (number|null);
                    host?: (string|null);
                    payload?: (Uint8Array|null);
                }

                class ProxySocialActionMessage implements IProxySocialActionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IProxySocialActionMessage);
                    public action: number;
                    public host: string;
                    public payload: Uint8Array;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IProxySocialActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ProxySocialActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ProxySocialActionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ProxySocialActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IProxySocialSideChannelActionMessage {
                    action?: (number|null);
                    host?: (string|null);
                    payload?: (Uint8Array|null);
                }

                class ProxySocialSideChannelActionMessage implements IProxySocialSideChannelActionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IProxySocialSideChannelActionMessage);
                    public action: number;
                    public host: string;
                    public payload: Uint8Array;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IProxySocialSideChannelActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ProxySocialSideChannelActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ProxySocialSideChannelActionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ProxySocialSideChannelActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetAvailableSubmissionsMessage {
                }

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

                interface IPushNotificationRegistryMessage {
                    apn_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IApnToken|null);
                    gcm_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IGcmToken|null);
                }

                class PushNotificationRegistryMessage implements IPushNotificationRegistryMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IPushNotificationRegistryMessage);
                    public apn_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IApnToken|null);
                    public gcm_token?: (POGOProtos.Networking.Requests.Messages.RegisterPushNotificationMessage.IGcmToken|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IPushNotificationRegistryMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.PushNotificationRegistryMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.PushNotificationRegistryMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.PushNotificationRegistryMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IAddLoginActionMessage {
                    identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                    inner_message?: (Uint8Array|null);
                }

                class AddLoginActionMessage implements IAddLoginActionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IAddLoginActionMessage);
                    public identity_provider: POGOProtos.Enums.IdentityProvider;
                    public inner_message: Uint8Array;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IAddLoginActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.AddLoginActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.AddLoginActionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.AddLoginActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IRemoveLoginActionMessage {
                    identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                }

                class RemoveLoginActionMessage implements IRemoveLoginActionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IRemoveLoginActionMessage);
                    public identity_provider: POGOProtos.Enums.IdentityProvider;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IRemoveLoginActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.RemoveLoginActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.RemoveLoginActionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.RemoveLoginActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISubmitNewPoiMessage {
                    title?: (string|null);
                    long_description?: (string|null);
                    lat_e6?: (number|null);
                    lng_e6?: (number|null);
                    supporting_statement?: (string|null);
                }

                class SubmitNewPoiMessage implements ISubmitNewPoiMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISubmitNewPoiMessage);
                    public title: string;
                    public long_description: string;
                    public lat_e6: number;
                    public lng_e6: number;
                    public supporting_statement: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISubmitNewPoiMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SubmitNewPoiMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SubmitNewPoiMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SubmitNewPoiMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IPingMessage {
                    response_size_bytes?: (number|null);
                    random_request_bytes?: (string|null);
                    use_cache_for_random_request_bytes?: (boolean|null);
                    return_value?: (string|null);
                }

                class PingMessage implements IPingMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IPingMessage);
                    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.Networking.Requests.Messages.IPingMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.PingMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.PingMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.PingMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IReplaceLoginActionMessage {
                    existing_identity_provider?: (POGOProtos.Enums.IdentityProvider|null);
                    new_login?: (POGOProtos.Networking.Requests.Messages.IAddLoginActionMessage|null);
                }

                class ReplaceLoginActionMessage implements IReplaceLoginActionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IReplaceLoginActionMessage);
                    public existing_identity_provider: POGOProtos.Enums.IdentityProvider;
                    public new_login?: (POGOProtos.Networking.Requests.Messages.IAddLoginActionMessage|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IReplaceLoginActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ReplaceLoginActionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ReplaceLoginActionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ReplaceLoginActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IListLoginActionMessage {
                }

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

                interface IPurchaseSkuMessage {
                    sku_id?: (string|null);
                }

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

                interface IQuestEncounterMessage {
                    encounter_id?: (number|Long|null);
                    spawn_point_id?: (string|null);
                }

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

                interface IQuitCombatMessage {
                    combat_id?: (string|null);
                }

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

                interface IReassignPlayerMessage {
                    current_instance?: (number|null);
                }

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

                interface IRecycleInventoryItemMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    count?: (number|null);
                }

                class RecycleInventoryItemMessage implements IRecycleInventoryItemMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IRecycleInventoryItemMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public count: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IRecycleInventoryItemMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.RecycleInventoryItemMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.RecycleInventoryItemMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.RecycleInventoryItemMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IRedeemGoogleReceiptMessage {
                    receipt?: (string|null);
                    receipt_signature?: (string|null);
                    purchase_currency?: (string|null);
                    price_paid_e6?: (number|null);
                    price_paid_e6_long?: (number|Long|null);
                }

                class RedeemGoogleReceiptMessage implements IRedeemGoogleReceiptMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IRedeemGoogleReceiptMessage);
                    public receipt: string;
                    public receipt_signature: string;
                    public purchase_currency: string;
                    public price_paid_e6: number;
                    public price_paid_e6_long: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IRedeemGoogleReceiptMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.RedeemGoogleReceiptMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.RedeemGoogleReceiptMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.RedeemGoogleReceiptMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IReleasePokemonMessage {
                    pokemon_id?: (number|Long|null);
                    pokemon_ids?: ((number|Long)[]|null);
                }

                class ReleasePokemonMessage implements IReleasePokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IReleasePokemonMessage);
                    public pokemon_id: (number|Long);
                    public pokemon_ids: (number|Long)[];
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IReleasePokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ReleasePokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ReleasePokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ReleasePokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IRemoveQuestMessage {
                    quest_id?: (string|null);
                }

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

                interface IRequestGeofenceUpdatesMessage {
                    number_of_points?: (number|null);
                    minimum_point_radius_m?: (number|null);
                }

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

                interface ISaveCombatPlayerPreferencesMessage {
                    preferences?: (POGOProtos.Data.Combat.ICombatPlayerPreferences|null);
                }

                class SaveCombatPlayerPreferencesMessage implements ISaveCombatPlayerPreferencesMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISaveCombatPlayerPreferencesMessage);
                    public preferences?: (POGOProtos.Data.Combat.ICombatPlayerPreferences|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISaveCombatPlayerPreferencesMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SaveCombatPlayerPreferencesMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SaveCombatPlayerPreferencesMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SaveCombatPlayerPreferencesMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISavePlayerSnapshotMessage {
                }

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

                interface ISaveSocialPlayerSettingsMessage {
                    settings?: (POGOProtos.Data.Player.ISocialPlayerSettings|null);
                }

                class SaveSocialPlayerSettingsMessage implements ISaveSocialPlayerSettingsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISaveSocialPlayerSettingsMessage);
                    public settings?: (POGOProtos.Data.Player.ISocialPlayerSettings|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISaveSocialPlayerSettingsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SaveSocialPlayerSettingsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SaveSocialPlayerSettingsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SaveSocialPlayerSettingsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISendGiftMessage {
                    giftbox_id?: (number|Long|null);
                    player_id?: (string|null);
                }

                class SendGiftMessage implements ISendGiftMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISendGiftMessage);
                    public giftbox_id: (number|Long);
                    public player_id: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISendGiftMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SendGiftMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SendGiftMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SendGiftMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISendProbeMessage {
                }

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

                interface ISetAvatarItemAsViewedMessage {
                    avatar_template_id?: (string[]|null);
                }

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

                interface ISetAvatarMessage {
                    player_avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
                }

                class SetAvatarMessage implements ISetAvatarMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetAvatarMessage);
                    public player_avatar?: (POGOProtos.Data.Player.IPlayerAvatar|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISetAvatarMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetAvatarMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetAvatarMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetAvatarMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISetBuddyPokemonMessage {
                    pokemon_id?: (number|Long|null);
                }

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

                interface ISetContactSettingsMessage {
                    contact_settings?: (POGOProtos.Data.Player.IContactSettings|null);
                }

                class SetContactSettingsMessage implements ISetContactSettingsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetContactSettingsMessage);
                    public contact_settings?: (POGOProtos.Data.Player.IContactSettings|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISetContactSettingsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetContactSettingsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetContactSettingsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetContactSettingsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISetFavoritePokemonMessage {
                    pokemon_id?: (number|Long|null);
                    is_favorite?: (boolean|null);
                }

                class SetFavoritePokemonMessage implements ISetFavoritePokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetFavoritePokemonMessage);
                    public pokemon_id: (number|Long);
                    public is_favorite: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISetFavoritePokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetFavoritePokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetFavoritePokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetFavoritePokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISetFriendNicknameMessage {
                    friend_id?: (string|null);
                    friend_nickname?: (string|null);
                }

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

                interface ISetInGameCurrencyExchangeRateMessage {
                    in_game_currency?: (string|null);
                    fiat_currency?: (string|null);
                    fiat_currency_cost_e6_per_in_game_unit?: (number|Long|null);
                }

                class SetInGameCurrencyExchangeRateMessage implements ISetInGameCurrencyExchangeRateMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetInGameCurrencyExchangeRateMessage);
                    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.Networking.Requests.Messages.ISetInGameCurrencyExchangeRateMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetInGameCurrencyExchangeRateMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetInGameCurrencyExchangeRateMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetInGameCurrencyExchangeRateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISetLobbyPokemonMessage {
                    raid_seed?: (number|Long|null);
                    gym_id?: (string|null);
                    lobby_id?: (number[]|null);
                    pokemon_id?: ((number|Long)[]|null);
                }

                class SetLobbyPokemonMessage implements ISetLobbyPokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetLobbyPokemonMessage);
                    public raid_seed: (number|Long);
                    public gym_id: string;
                    public lobby_id: number[];
                    public pokemon_id: (number|Long)[];
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISetLobbyPokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetLobbyPokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetLobbyPokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetLobbyPokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISetLobbyVisibilityMessage {
                    raid_seed?: (number|Long|null);
                    gym_id?: (string|null);
                    lobby_id?: (number[]|null);
                }

                class SetLobbyVisibilityMessage implements ISetLobbyVisibilityMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetLobbyVisibilityMessage);
                    public raid_seed: (number|Long);
                    public gym_id: string;
                    public lobby_id: number[];
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISetLobbyVisibilityMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetLobbyVisibilityMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetLobbyVisibilityMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetLobbyVisibilityMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISetPlayerTeamMessage {
                    team?: (POGOProtos.Enums.TeamColor|null);
                }

                class SetPlayerTeamMessage implements ISetPlayerTeamMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISetPlayerTeamMessage);
                    public team: POGOProtos.Enums.TeamColor;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISetPlayerTeamMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SetPlayerTeamMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SetPlayerTeamMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SetPlayerTeamMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISfidaActionLogMessage {
                }

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

                interface ISfidaCaptureMessage {
                    spawnpoint_id?: (string|null);
                    encounter_id?: (number|Long|null);
                    player_lat?: (number|null);
                    player_lng?: (number|null);
                    encounter_type?: (POGOProtos.Enums.EncounterType|null);
                    gym_lat?: (number|null);
                    gym_lng?: (number|null);
                }

                class SfidaCaptureMessage implements ISfidaCaptureMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISfidaCaptureMessage);
                    public spawnpoint_id: string;
                    public encounter_id: (number|Long);
                    public player_lat: number;
                    public player_lng: number;
                    public encounter_type: POGOProtos.Enums.EncounterType;
                    public gym_lat: number;
                    public gym_lng: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISfidaCaptureMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SfidaCaptureMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SfidaCaptureMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SfidaCaptureMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface ISfidaCertificationMessage {
                    stage?: (POGOProtos.Networking.Requests.Messages.SfidaCertificationMessage.SfidaCertificationStage|null);
                    payload?: (Uint8Array|null);
                }

                class SfidaCertificationMessage implements ISfidaCertificationMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISfidaCertificationMessage);
                    public stage: POGOProtos.Networking.Requests.Messages.SfidaCertificationMessage.SfidaCertificationStage;
                    public payload: Uint8Array;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISfidaCertificationMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SfidaCertificationMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SfidaCertificationMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SfidaCertificationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace SfidaCertificationMessage {

                    enum SfidaCertificationStage {
                        UNSET = 0,
                        STAGE1 = 1,
                        STAGE2 = 2,
                        STAGE3 = 3
                    }
                }

                interface ISfidaDowserMessage {
                    encounter_id?: (number|Long|null);
                }

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

                interface ISfidaRegistrationMessage {
                    sfida_id?: (string|null);
                }

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

                interface ISfidaUpdateMessage {
                    player_lat?: (number|null);
                    player_lng?: (number|null);
                    metrics_update?: (POGOProtos.Data.Sfida.ISfidaMetricsUpdate|null);
                }

                class SfidaUpdateMessage implements ISfidaUpdateMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.ISfidaUpdateMessage);
                    public player_lat: number;
                    public player_lng: number;
                    public metrics_update?: (POGOProtos.Data.Sfida.ISfidaMetricsUpdate|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.ISfidaUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.SfidaUpdateMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.SfidaUpdateMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.SfidaUpdateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IShareExRaidPassMessage {
                    friend_id?: (string|null);
                    fort_id?: (string|null);
                    raid_seed?: (number|Long|null);
                }

                class ShareExRaidPassMessage implements IShareExRaidPassMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IShareExRaidPassMessage);
                    public friend_id: string;
                    public fort_id: string;
                    public raid_seed: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IShareExRaidPassMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.ShareExRaidPassMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.ShareExRaidPassMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.ShareExRaidPassMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IStartGymBattleMessage {
                    gym_id?: (string|null);
                    attacking_pokemon_ids?: ((number|Long)[]|null);
                    defending_pokemon_id?: (number|Long|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class StartGymBattleMessage implements IStartGymBattleMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IStartGymBattleMessage);
                    public gym_id: string;
                    public attacking_pokemon_ids: (number|Long)[];
                    public defending_pokemon_id: (number|Long);
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IStartGymBattleMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.StartGymBattleMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.StartGymBattleMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.StartGymBattleMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IStartRaidBattleMessage {
                    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 StartRaidBattleMessage implements IStartRaidBattleMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IStartRaidBattleMessage);
                    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.Networking.Requests.Messages.IStartRaidBattleMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.StartRaidBattleMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.StartRaidBattleMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.StartRaidBattleMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IStartTutorialActionMessage {
                    onboarding_v2_enabled?: (boolean|null);
                }

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

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

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

                interface IUnlockSpecialMoveMessage {
                    pokemon_id?: (number|Long|null);
                }

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

                interface IUpdateCombatMessage {
                    combat_id?: (string|null);
                    action?: (POGOProtos.Data.Combat.ICombatAction|null);
                }

                class UpdateCombatMessage implements IUpdateCombatMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUpdateCombatMessage);
                    public combat_id: string;
                    public action?: (POGOProtos.Data.Combat.ICombatAction|null);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUpdateCombatMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UpdateCombatMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UpdateCombatMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UpdateCombatMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUpdateFitnessMetricsMessage {
                    fitness_samples?: (POGOProtos.Data.Fitness.IFitnessSample[]|null);
                }

                class UpdateFitnessMetricsMessage implements IUpdateFitnessMetricsMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUpdateFitnessMetricsMessage);
                    public fitness_samples: POGOProtos.Data.Fitness.IFitnessSample[];
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUpdateFitnessMetricsMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UpdateFitnessMetricsMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UpdateFitnessMetricsMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UpdateFitnessMetricsMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUpdatePlayerLocationMessage {
                    geofence_identifier?: (string|null);
                    reason?: (POGOProtos.Networking.Requests.Messages.UpdatePlayerLocationMessage.PingReason|null);
                }

                class UpdatePlayerLocationMessage implements IUpdatePlayerLocationMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUpdatePlayerLocationMessage);
                    public geofence_identifier: string;
                    public reason: POGOProtos.Networking.Requests.Messages.UpdatePlayerLocationMessage.PingReason;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUpdatePlayerLocationMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UpdatePlayerLocationMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UpdatePlayerLocationMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UpdatePlayerLocationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace UpdatePlayerLocationMessage {

                    enum PingReason {
                        UNSET = 0,
                        ENTRANCE_EVENT = 1,
                        EXIT_EVENT = 2,
                        DWELL_EVENT = 3,
                        VISIT_EVENT = 4,
                        FITNESS_WAKEUP = 5,
                        OTHER_WAKEUP = 6
                    }
                }

                interface IUpdateTradingMessage {
                    player_id?: (string|null);
                    pokemon_id?: (number|Long|null);
                }

                class UpdateTradingMessage implements IUpdateTradingMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUpdateTradingMessage);
                    public player_id: string;
                    public pokemon_id: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUpdateTradingMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UpdateTradingMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UpdateTradingMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UpdateTradingMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUpgradePokemonMessage {
                    pokemon_id?: (number|Long|null);
                    preview?: (boolean|null);
                }

                class UpgradePokemonMessage implements IUpgradePokemonMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUpgradePokemonMessage);
                    public pokemon_id: (number|Long);
                    public preview: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUpgradePokemonMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UpgradePokemonMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UpgradePokemonMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UpgradePokemonMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseIncenseMessage {
                    incense_type?: (POGOProtos.Inventory.Item.ItemId|null);
                }

                class UseIncenseMessage implements IUseIncenseMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseIncenseMessage);
                    public incense_type: POGOProtos.Inventory.Item.ItemId;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseIncenseMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseIncenseMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseIncenseMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseIncenseMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemCaptureMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    encounter_id?: (number|Long|null);
                    spawn_point_id?: (string|null);
                }

                class UseItemCaptureMessage implements IUseItemCaptureMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemCaptureMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public encounter_id: (number|Long);
                    public spawn_point_id: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemCaptureMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemCaptureMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemCaptureMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemCaptureMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemEggIncubatorMessage {
                    item_id?: (string|null);
                    pokemon_id?: (number|Long|null);
                }

                class UseItemEggIncubatorMessage implements IUseItemEggIncubatorMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemEggIncubatorMessage);
                    public item_id: string;
                    public pokemon_id: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemEggIncubatorMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemEggIncubatorMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemEggIncubatorMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemEggIncubatorMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemEncounterMessage {
                    item?: (POGOProtos.Inventory.Item.ItemId|null);
                    encounter_id?: (number|Long|null);
                    spawn_point_guid?: (string|null);
                }

                class UseItemEncounterMessage implements IUseItemEncounterMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemEncounterMessage);
                    public item: POGOProtos.Inventory.Item.ItemId;
                    public encounter_id: (number|Long);
                    public spawn_point_guid: string;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemEncounterMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemEncounterMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemEncounterMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemEncounterMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemGymMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    gym_id?: (string|null);
                    player_latitude?: (number|null);
                    player_longitude?: (number|null);
                }

                class UseItemGymMessage implements IUseItemGymMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemGymMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public gym_id: string;
                    public player_latitude: number;
                    public player_longitude: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemGymMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemGymMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemGymMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemGymMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemMoveRerollMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    pokemon_id?: (number|Long|null);
                    reroll_unlocked_move?: (boolean|null);
                }

                class UseItemMoveRerollMessage implements IUseItemMoveRerollMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemMoveRerollMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public pokemon_id: (number|Long);
                    public reroll_unlocked_move: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemMoveRerollMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemMoveRerollMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemMoveRerollMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemMoveRerollMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemPotionMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    pokemon_id?: (number|Long|null);
                }

                class UseItemPotionMessage implements IUseItemPotionMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemPotionMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public pokemon_id: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemPotionMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemPotionMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemPotionMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemPotionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemRareCandyMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                    candy_count?: (number|null);
                }

                class UseItemRareCandyMessage implements IUseItemRareCandyMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemRareCandyMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public pokemon_id: POGOProtos.Enums.PokemonId;
                    public candy_count: number;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemRareCandyMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemRareCandyMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemRareCandyMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemRareCandyMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemReviveMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                    pokemon_id?: (number|Long|null);
                }

                class UseItemReviveMessage implements IUseItemReviveMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemReviveMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public pokemon_id: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemReviveMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemReviveMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemReviveMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemReviveMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemStardustBoostMessage {
                    item?: (POGOProtos.Inventory.Item.ItemId|null);
                }

                class UseItemStardustBoostMessage implements IUseItemStardustBoostMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemStardustBoostMessage);
                    public item: POGOProtos.Inventory.Item.ItemId;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemStardustBoostMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemStardustBoostMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemStardustBoostMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemStardustBoostMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IUseItemXpBoostMessage {
                    item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                }

                class UseItemXpBoostMessage implements IUseItemXpBoostMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Messages.IUseItemXpBoostMessage);
                    public item_id: POGOProtos.Inventory.Item.ItemId;
                    public static encode(message: POGOProtos.Networking.Requests.Messages.IUseItemXpBoostMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.UseItemXpBoostMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.UseItemXpBoostMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Messages.UseItemXpBoostMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IVerifyChallengeMessage {
                    token?: (string|null);
                }

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

                namespace Social {

                    interface IUpdateNotificationMessage {
                        notification_ids?: (string[]|null);
                        create_timestamp_ms?: ((number|Long)[]|null);
                        state?: (POGOProtos.Enums.NotificationState|null);
                    }

                    class UpdateNotificationMessage implements IUpdateNotificationMessage {
                        constructor(properties?: POGOProtos.Networking.Requests.Messages.Social.IUpdateNotificationMessage);
                        public notification_ids: string[];
                        public create_timestamp_ms: (number|Long)[];
                        public state: POGOProtos.Enums.NotificationState;
                        public static encode(message: POGOProtos.Networking.Requests.Messages.Social.IUpdateNotificationMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Messages.Social.UpdateNotificationMessage;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Messages.Social.UpdateNotificationMessage;
                        public static toObject(message: POGOProtos.Networking.Requests.Messages.Social.UpdateNotificationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }
                }
            }

            interface IRequest {
                request_type?: (POGOProtos.Networking.Requests.RequestType|null);
                request_message?: (Uint8Array|null);
            }

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

            enum RequestType {
                METHOD_UNSET = 0,
                GET_PLAYER = 2,
                GET_HOLO_INVENTORY = 4,
                DOWNLOAD_SETTINGS = 5,
                DOWNLOAD_ITEM_TEMPLATES = 6,
                DOWNLOAD_REMOTE_CONFIG_VERSION = 7,
                REGISTER_BACKGROUND_DEVICE = 8,
                GET_PLAYER_DAY = 9,
                ACKNOWLEDGE_PUNISHMENT = 10,
                FORT_SEARCH = 101,
                ENCOUNTER = 102,
                CATCH_POKEMON = 103,
                FORT_DETAILS = 104,
                GET_MAP_OBJECTS = 106,
                FORT_DEPLOY_POKEMON = 110,
                FORT_RECALL_POKEMON = 111,
                RELEASE_POKEMON = 112,
                USE_ITEM_POTION = 113,
                USE_ITEM_CAPTURE = 114,
                USE_ITEM_FLEE = 115,
                USE_ITEM_REVIVE = 116,
                GET_PLAYER_PROFILE = 121,
                EVOLVE_POKEMON = 125,
                GET_HATCHED_EGGS = 126,
                ENCOUNTER_TUTORIAL_COMPLETE = 127,
                LEVEL_UP_REWARDS = 128,
                CHECK_AWARDED_BADGES = 129,
                USE_ITEM_GYM = 133,
                GET_GYM_DETAILS = 134,
                START_GYM_BATTLE = 135,
                ATTACK_GYM = 136,
                RECYCLE_INVENTORY_ITEM = 137,
                COLLECT_DAILY_BONUS = 138,
                USE_ITEM_XP_BOOST = 139,
                USE_ITEM_EGG_INCUBATOR = 140,
                USE_INCENSE = 141,
                GET_INCENSE_POKEMON = 142,
                INCENSE_ENCOUNTER = 143,
                ADD_FORT_MODIFIER = 144,
                DISK_ENCOUNTER = 145,
                COLLECT_DAILY_DEFENDER_BONUS = 146,
                UPGRADE_POKEMON = 147,
                SET_FAVORITE_POKEMON = 148,
                NICKNAME_POKEMON = 149,
                EQUIP_BADGE = 150,
                SET_CONTACT_SETTINGS = 151,
                SET_BUDDY_POKEMON = 152,
                GET_BUDDY_WALKED = 153,
                USE_ITEM_ENCOUNTER = 154,
                GYM_DEPLOY = 155,
                GYM_GET_INFO = 156,
                GYM_START_SESSION = 157,
                GYM_BATTLE_ATTACK = 158,
                JOIN_LOBBY = 159,
                LEAVE_LOBBY = 160,
                SET_LOBBY_VISIBILITY = 161,
                SET_LOBBY_POKEMON = 162,
                GET_RAID_DETAILS = 163,
                GYM_FEED_POKEMON = 164,
                START_RAID_BATTLE = 165,
                ATTACK_RAID = 166,
                AWARD_POKECOIN = 167,
                USE_ITEM_STARDUST_BOOST = 168,
                REASSIGN_PLAYER = 169,
                GET_ASSET_DIGEST = 300,
                GET_DOWNLOAD_URLS = 301,
                CLAIM_CODENAME = 403,
                SET_AVATAR = 404,
                SET_PLAYER_TEAM = 405,
                MARK_TUTORIAL_COMPLETE = 406,
                UPDATE_PERFORMANCE_METRICS = 407,
                CHECK_CHALLENGE = 600,
                VERIFY_CHALLENGE = 601,
                ECHO = 666,
                SFIDA_REGISTRATION = 800,
                SFIDA_ACTION_LOG = 801,
                SFIDA_CERTIFICATION = 802,
                SFIDA_UPDATE = 803,
                SFIDA_ACTION = 804,
                SFIDA_DOWSER = 805,
                SFIDA_CAPTURE = 806,
                LIST_AVATAR_CUSTOMIZATIONS = 807,
                SET_AVATAR_ITEM_AS_VIEWED = 808,
                GET_INBOX = 809,
                LIST_GYM_BADGES = 811,
                GET_GYM_BADGE_DETAILS = 812,
                USE_ITEM_MOVE_REROLL = 813,
                USE_ITEM_RARE_CANDY = 814,
                AWARD_FREE_RAID_TICKET = 815,
                FETCH_ALL_NEWS = 816,
                MARK_READ_NEWS_ARTICLE = 817,
                GET_PLAYER_DISPLAY_INFO = 818,
                BELUGA_TRANSACTION_START = 819,
                BELUGA_TRANSACTION_COMPLETE = 820,
                GET_NEW_QUESTS = 900,
                GET_QUEST_DETAILS = 901,
                COMPLETE_QUEST = 902,
                REMOVE_QUEST = 903,
                QUEST_ENCOUNTER = 904,
                COMPLETE_QUEST_STAMP_CARD = 905,
                SEND_GIFT = 950,
                OPEN_GIFT = 951,
                GIFT_DETAILS = 952,
                DELETE_GIFT = 953,
                SAVE_PLAYER_SNAPSHOT = 954,
                GET_FRIENDSHIP_MILESTONE_REWARDS = 955,
                CHECK_SEND_GIFT = 956,
                SET_FRIEND_NICKNAME = 957,
                DELETE_GIFT_FROM_INVENTORY = 958,
                SAVE_SOCIAL_PLAYER_SETTINGS = 959,
                SHARE_EX_RAID_PASS = 960,
                CHECK_SHARE_EX_RAID_PASS = 961,
                DECLINE_SHARED_EX_RAID_PASS = 962,
                OPEN_TRADING = 970,
                UPDATE_TRADING = 971,
                CONFIRM_TRADING = 972,
                CANCEL_TRADING = 973,
                GET_TRADING = 974,
                GET_FITNESS_REWARDS = 980,
                GET_COMBAT_PLAYER_PROFILE = 990,
                GENERATE_COMBAT_CHALLENGE_ID = 991,
                CREATE_COMBAT_CHALLENGE = 992,
                OPEN_COMBAT_CHALLENGE = 993,
                GET_COMBAT_CHALLENGE = 994,
                ACCEPT_COMBAT_CHALLENGE = 995,
                DECLINE_COMBAT_CHALLENGE = 996,
                CANCEL_COMBAT_CHALLENGE = 997,
                SUBMIT_COMBAT_CHALLENGE_POKEMONS = 998,
                SAVE_COMBAT_PLAYER_PREFERENCES = 999,
                OPEN_COMBAT_SESSION = 1000,
                UPDATE_COMBAT = 1001,
                QUIT_COMBAT = 1002,
                GET_COMBAT_RESULTS = 1003,
                UNLOCK_SPECIAL_MOVE = 1004,
                GET_NPC_COMBAT_REWARDS = 1005,
                COMBAT_FRIEND_REQUEST = 1006,
                OPEN_NPC_COMBAT_SESSION = 1007,
                START_TUTORIAL_ACTION = 1008,
                GET_TUTORIAL_EGG_ACTION = 1009,
                SEND_PROBE = 1020,
                PROBE_DATA = 1021,
                COMBAT_DATA = 1022,
                COMBAT_CHALLENGE_DATA = 1023,
                CHECK_PHOTOBOMB = 1101,
                CONFIRM_PHOTOBOMB = 1102,
                GET_PHOTOBOMB = 1103,
                ENCOUNTER_PHOTOBOMB = 1104,
                GET_SIGNED_GMAP_URL = 1105,
                CHANGE_TEAM = 1106,
                REGISTER_PUSH_NOTIFICATION = 5000,
                UNREGISTER_PUSH_NOTIFICATION = 5001,
                UPDATE_NOTIFICATION_STATUS = 5002,
                OPT_OUT_PUSH_NOTIFICATION_CATEGORY = 5003,
                DOWNLOAD_GAME_MASTER_TEMPLATES = 5004,
                GET_INVENTORY = 5005,
                REDEEM_PASSCODE = 5006,
                PING = 5007,
                ADD_LOGIN_ACTION = 5008,
                REMOVE_LOGIN_ACTION = 5009,
                LIST_LOGIN_ACTION = 5010,
                ADD_NEW_POI = 5011,
                PROXY_SOCIAL_ACTION = 5012,
                CLIENT_TELEMETRY = 5013,
                GET_AVAILABLE_SUBMISSIONS = 5014,
                GET_SIGNED_URL_FOR_PHOTO_UPLOAD = 5015,
                REPLACE_LOGIN_ACTION = 5016,
                PROXY_SOCIAL_SIDE_CHANNEL_ACTION = 5017,
                COLLECT_CLIENT_TELEMETRY = 5018,
                PURCHASE_SKU = 5019,
                GET_AVAILABLE_SKUS_AND_BALANCES = 5020,
                REDEEM_GOOGLE_RECEIPT = 5021,
                REDEEM_APPLE_RECEIPT = 5022,
                REDEEM_DESKTOP_RECEIPT = 5023,
                UPDATE_FITNESS_METRICS = 5024,
                GET_FITNESS_REPORT = 5025,
                GET_CLIENT_TELEMETRY_SETTINGS = 5026,
                REGISTER_BACKGROUND_SERVICE = 5028,
                GET_CLIENT_BGMODE_SETTINGS = 5029,
                PING_ASYNC = 5027,
                PING_DOWNSTREAM = 5030,
                SET_IN_GAME_CURRENCY_EXCHANGE_RATE = 5032,
                REQUEST_GEOFENCE_UPDATES = 5033,
                UPDATE_PLAYER_LOCATION = 5034,
                GENERATE_GMAP_SIGNED_URL = 5035
            }

            namespace Social {

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

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

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

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

                interface ICreateInviteCodeMessage {
                    force_generate_code?: (boolean|null);
                }

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

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

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

                interface IGetFacebookFriendListMessage {
                    fb_access_token?: (string|null);
                    limit?: (number|null);
                    cursor?: (string|null);
                }

                class GetFacebookFriendListMessage implements IGetFacebookFriendListMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Social.IGetFacebookFriendListMessage);
                    public fb_access_token: string;
                    public limit: number;
                    public cursor: string;
                    public static encode(message: POGOProtos.Networking.Requests.Social.IGetFacebookFriendListMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Social.GetFacebookFriendListMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Social.GetFacebookFriendListMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Social.GetFacebookFriendListMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGetInboxMessage {
                    is_history?: (boolean|null);
                    is_reverse?: (boolean|null);
                    not_before_ms?: (number|Long|null);
                }

                class GetInboxMessage implements IGetInboxMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Social.IGetInboxMessage);
                    public is_history: boolean;
                    public is_reverse: boolean;
                    public not_before_ms: (number|Long);
                    public static encode(message: POGOProtos.Networking.Requests.Social.IGetInboxMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Social.GetInboxMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Social.GetInboxMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Social.GetInboxMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

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

                interface IListFriendsMessage {
                }

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

                interface IListFriendStatusMessage {
                    player_id?: (string[]|null);
                }

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

                interface IListIncomingFriendInvitesMessage {
                }

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

                interface IListOutgoingFriendInvitesMessage {
                }

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

                interface IOptOutPushNotificationCategoryMessage {
                    categories?: (string[]|null);
                }

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

                interface IRegisterPushNotificationMessage {
                    apn_token?: (POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage.IApnToken|null);
                    gcm_token?: (POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage.IGcmToken|null);
                }

                class RegisterPushNotificationMessage implements IRegisterPushNotificationMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Social.IRegisterPushNotificationMessage);
                    public apn_token?: (POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage.IApnToken|null);
                    public gcm_token?: (POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage.IGcmToken|null);
                    public static encode(message: POGOProtos.Networking.Requests.Social.IRegisterPushNotificationMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Social.RegisterPushNotificationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace RegisterPushNotificationMessage {

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

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

                    interface IGcmToken {
                        registration_id?: (string|null);
                    }

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

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

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

                interface ISearchPlayerMessage {
                    friend_code?: (string|null);
                }

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

                interface ISendFacebookFriendInviteMessage {
                    fb_access_token?: (string|null);
                    friend_fb_user_id?: (string|null);
                }

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

                interface ISendFriendInviteMessage {
                    player_id?: (string|null);
                    friend_code?: (string|null);
                }

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

                interface IUpdateFacebookStatusMessage {
                    fb_access_token?: (string|null);
                    force_update?: (boolean|null);
                }

                class UpdateFacebookStatusMessage implements IUpdateFacebookStatusMessage {
                    constructor(properties?: POGOProtos.Networking.Requests.Social.IUpdateFacebookStatusMessage);
                    public fb_access_token: string;
                    public force_update: boolean;
                    public static encode(message: POGOProtos.Networking.Requests.Social.IUpdateFacebookStatusMessage, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Requests.Social.UpdateFacebookStatusMessage;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Requests.Social.UpdateFacebookStatusMessage;
                    public static toObject(message: POGOProtos.Networking.Requests.Social.UpdateFacebookStatusMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        namespace Responses {

            interface IAcceptCombatChallengeResponse {
                result?: (POGOProtos.Networking.Responses.AcceptCombatChallengeResponse.Result|null);
                challenge?: (POGOProtos.Data.Combat.ICombatChallenge|null);
            }

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

            namespace AcceptCombatChallengeResponse {

                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 IAcknowledgePunishmentResponse {
                result?: (POGOProtos.Networking.Responses.AcknowledgePunishmentResponse.Result|null);
            }

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

            namespace AcknowledgePunishmentResponse {

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

            interface IAddFortModifierResponse {
                result?: (POGOProtos.Networking.Responses.AddFortModifierResponse.Result|null);
                fort_details?: (POGOProtos.Networking.Responses.IFortDetailsResponse|null);
            }

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

            namespace AddFortModifierResponse {

                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 IAttackGymResponse {
                result?: (POGOProtos.Networking.Responses.AttackGymResponse.Result|null);
                battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                battle_id?: (string|null);
                active_defender?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                active_attacker?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                battle_update?: (POGOProtos.Data.Battle.IBattleUpdate|null);
            }

            class AttackGymResponse implements IAttackGymResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IAttackGymResponse);
                public result: POGOProtos.Networking.Responses.AttackGymResponse.Result;
                public battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                public battle_id: string;
                public active_defender?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                public active_attacker?: (POGOProtos.Data.Battle.IBattlePokemonInfo|null);
                public battle_update?: (POGOProtos.Data.Battle.IBattleUpdate|null);
                public static encode(message: POGOProtos.Networking.Responses.IAttackGymResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.AttackGymResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.AttackGymResponse;
                public static toObject(message: POGOProtos.Networking.Responses.AttackGymResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AttackGymResponse {

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

            interface IAttackRaidBattleResponse {
                result?: (POGOProtos.Networking.Responses.AttackRaidBattleResponse.Result|null);
                battle_update?: (POGOProtos.Data.Battle.IBattleUpdate|null);
            }

            class AttackRaidBattleResponse implements IAttackRaidBattleResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IAttackRaidBattleResponse);
                public result: POGOProtos.Networking.Responses.AttackRaidBattleResponse.Result;
                public battle_update?: (POGOProtos.Data.Battle.IBattleUpdate|null);
                public static encode(message: POGOProtos.Networking.Responses.IAttackRaidBattleResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.AttackRaidBattleResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.AttackRaidBattleResponse;
                public static toObject(message: POGOProtos.Networking.Responses.AttackRaidBattleResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace AttackRaidBattleResponse {

                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 IAwardFreeRaidTicketResponse {
                result?: (POGOProtos.Networking.Responses.AwardFreeRaidTicketResponse.Result|null);
            }

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

            namespace AwardFreeRaidTicketResponse {

                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 IBelugaTransactionCompleteResponse {
                status?: (POGOProtos.Networking.Responses.BelugaTransactionCompleteResponse.Status|null);
                candy_awarded?: (number|null);
                loot_awarded?: (POGOProtos.Inventory.ILoot|null);
                beluga_finalize_response?: (POGOProtos.Data.Beluga.IBelugaBleFinalizeTransfer|null);
                buckets_until_weekly_award?: (number|null);
            }

            class BelugaTransactionCompleteResponse implements IBelugaTransactionCompleteResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IBelugaTransactionCompleteResponse);
                public status: POGOProtos.Networking.Responses.BelugaTransactionCompleteResponse.Status;
                public candy_awarded: number;
                public loot_awarded?: (POGOProtos.Inventory.ILoot|null);
                public beluga_finalize_response?: (POGOProtos.Data.Beluga.IBelugaBleFinalizeTransfer|null);
                public buckets_until_weekly_award: number;
                public static encode(message: POGOProtos.Networking.Responses.IBelugaTransactionCompleteResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.BelugaTransactionCompleteResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.BelugaTransactionCompleteResponse;
                public static toObject(message: POGOProtos.Networking.Responses.BelugaTransactionCompleteResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BelugaTransactionCompleteResponse {

                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
                }
            }

            interface IBelugaTransactionStartResponse {
                status?: (POGOProtos.Networking.Responses.BelugaTransactionStartResponse.Status|null);
                beluga_transfer_prep?: (POGOProtos.Data.Beluga.IBelugaBleTransferPrep|null);
                server_signature?: (Uint8Array|null);
            }

            class BelugaTransactionStartResponse implements IBelugaTransactionStartResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IBelugaTransactionStartResponse);
                public status: POGOProtos.Networking.Responses.BelugaTransactionStartResponse.Status;
                public beluga_transfer_prep?: (POGOProtos.Data.Beluga.IBelugaBleTransferPrep|null);
                public server_signature: Uint8Array;
                public static encode(message: POGOProtos.Networking.Responses.IBelugaTransactionStartResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.BelugaTransactionStartResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.BelugaTransactionStartResponse;
                public static toObject(message: POGOProtos.Networking.Responses.BelugaTransactionStartResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace BelugaTransactionStartResponse {

                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
                }
            }

            interface ICancelCombatChallengeResponse {
                result?: (POGOProtos.Networking.Responses.CancelCombatChallengeResponse.Result|null);
            }

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

            namespace CancelCombatChallengeResponse {

                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 ICancelTradingResponse {
                result?: (POGOProtos.Networking.Responses.CancelTradingResponse.Result|null);
                trading?: (POGOProtos.Data.Trading.ITrading|null);
            }

            class CancelTradingResponse implements ICancelTradingResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ICancelTradingResponse);
                public result: POGOProtos.Networking.Responses.CancelTradingResponse.Result;
                public trading?: (POGOProtos.Data.Trading.ITrading|null);
                public static encode(message: POGOProtos.Networking.Responses.ICancelTradingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.CancelTradingResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.CancelTradingResponse;
                public static toObject(message: POGOProtos.Networking.Responses.CancelTradingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CancelTradingResponse {

                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 ICatchPokemonResponse {
                status?: (POGOProtos.Networking.Responses.CatchPokemonResponse.CatchStatus|null);
                miss_percent?: (number|null);
                captured_pokemon_id?: (number|Long|null);
                capture_award?: (POGOProtos.Data.Capture.ICaptureAward|null);
                capture_reason?: (POGOProtos.Networking.Responses.CatchPokemonResponse.CaptureReason|null);
                display_pokedex_id?: (number|null);
                throws_remaining?: (number|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            }

            class CatchPokemonResponse implements ICatchPokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ICatchPokemonResponse);
                public status: POGOProtos.Networking.Responses.CatchPokemonResponse.CatchStatus;
                public miss_percent: number;
                public captured_pokemon_id: (number|Long);
                public capture_award?: (POGOProtos.Data.Capture.ICaptureAward|null);
                public capture_reason: POGOProtos.Networking.Responses.CatchPokemonResponse.CaptureReason;
                public display_pokedex_id: number;
                public throws_remaining: number;
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Networking.Responses.ICatchPokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.CatchPokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.CatchPokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.CatchPokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CatchPokemonResponse {

                enum CatchStatus {
                    CATCH_ERROR = 0,
                    CATCH_SUCCESS = 1,
                    CATCH_ESCAPE = 2,
                    CATCH_FLEE = 3,
                    CATCH_MISSED = 4
                }

                enum CaptureReason {
                    UNSET = 0,
                    DEFAULT = 1,
                    ELEMENTAL_BADGE = 2,
                    CRITICAL_CATCH = 3
                }
            }

            interface IChangeTeamResponse {
                status?: (POGOProtos.Networking.Responses.ChangeTeamResponse.Status|null);
                updated_player?: (POGOProtos.Data.IPlayerData|null);
            }

            class ChangeTeamResponse implements IChangeTeamResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IChangeTeamResponse);
                public status: POGOProtos.Networking.Responses.ChangeTeamResponse.Status;
                public updated_player?: (POGOProtos.Data.IPlayerData|null);
                public static encode(message: POGOProtos.Networking.Responses.IChangeTeamResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.ChangeTeamResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.ChangeTeamResponse;
                public static toObject(message: POGOProtos.Networking.Responses.ChangeTeamResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ChangeTeamResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_SAME_TEAM = 2,
                    ERROR_ITEM_NOT_IN_INVENTORY = 3,
                    ERROR_WRONG_ITEM = 4,
                    ERROR_UNKNOWN = 5
                }
            }

            interface ICheckAwardedBadgesResponse {
                success?: (boolean|null);
                awarded_badges?: (POGOProtos.Enums.BadgeType[]|null);
                awarded_badge_levels?: (number[]|null);
                avatar_template_ids?: (string[]|null);
            }

            class CheckAwardedBadgesResponse implements ICheckAwardedBadgesResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ICheckAwardedBadgesResponse);
                public success: boolean;
                public awarded_badges: POGOProtos.Enums.BadgeType[];
                public awarded_badge_levels: number[];
                public avatar_template_ids: string[];
                public static encode(message: POGOProtos.Networking.Responses.ICheckAwardedBadgesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.CheckAwardedBadgesResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.CheckAwardedBadgesResponse;
                public static toObject(message: POGOProtos.Networking.Responses.CheckAwardedBadgesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICheckChallengeResponse {
                show_challenge?: (boolean|null);
                challenge_url?: (string|null);
            }

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

            interface ICheckPhotobombResponse {
                status?: (POGOProtos.Networking.Responses.CheckPhotobombResponse.Status|null);
                photobomb_pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                photobomb_pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                encounter_id?: (number|Long|null);
            }

            class CheckPhotobombResponse implements ICheckPhotobombResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ICheckPhotobombResponse);
                public status: POGOProtos.Networking.Responses.CheckPhotobombResponse.Status;
                public photobomb_pokemon_id: POGOProtos.Enums.PokemonId;
                public photobomb_pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public encounter_id: (number|Long);
                public static encode(message: POGOProtos.Networking.Responses.ICheckPhotobombResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.CheckPhotobombResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.CheckPhotobombResponse;
                public static toObject(message: POGOProtos.Networking.Responses.CheckPhotobombResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CheckPhotobombResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PHOTO_POKEMON_INVALID = 2,
                    ERROR_UNKNOWN = 3
                }
            }

            interface ICheckSendGiftResponse {
                result?: (POGOProtos.Networking.Responses.CheckSendGiftResponse.Result|null);
            }

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

            namespace CheckSendGiftResponse {

                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 ICheckShareExRaidPassResponse {
                result?: (POGOProtos.Enums.ShareExRaidPassResult|null);
            }

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

            interface IClaimCodenameResponse {
                codename?: (string|null);
                user_message?: (string|null);
                is_assignable?: (boolean|null);
                status?: (POGOProtos.Networking.Responses.ClaimCodenameResponse.Status|null);
                updated_player?: (POGOProtos.Data.IPlayerData|null);
                suggested_codenames?: (string[]|null);
            }

            class ClaimCodenameResponse implements IClaimCodenameResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IClaimCodenameResponse);
                public codename: string;
                public user_message: string;
                public is_assignable: boolean;
                public status: POGOProtos.Networking.Responses.ClaimCodenameResponse.Status;
                public updated_player?: (POGOProtos.Data.IPlayerData|null);
                public suggested_codenames: string[];
                public static encode(message: POGOProtos.Networking.Responses.IClaimCodenameResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.ClaimCodenameResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.ClaimCodenameResponse;
                public static toObject(message: POGOProtos.Networking.Responses.ClaimCodenameResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ClaimCodenameResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    CODENAME_NOT_AVAILABLE = 2,
                    CODENAME_NOT_VALID = 3,
                    CURRENT_OWNER = 4,
                    CODENAME_CHANGE_NOT_ALLOWED = 5
                }
            }

            interface ICollectDailyBonusResponse {
                result?: (POGOProtos.Networking.Responses.CollectDailyBonusResponse.Result|null);
            }

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

            namespace CollectDailyBonusResponse {

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

            interface ICollectDailyDefenderBonusResponse {
                result?: (POGOProtos.Networking.Responses.CollectDailyDefenderBonusResponse.Result|null);
                currency_type?: (string[]|null);
                currency_awarded?: (number[]|null);
                defenders_count?: (number|null);
            }

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

            namespace CollectDailyDefenderBonusResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    FAILURE = 2,
                    TOO_SOON = 3,
                    NO_DEFENDERS = 4
                }
            }

            interface ICombatFriendRequestResponse {
                result?: (POGOProtos.Networking.Responses.CombatFriendRequestResponse.Result|null);
            }

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

            namespace CombatFriendRequestResponse {

                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 ICompleteQuestResponse {
                status?: (POGOProtos.Networking.Responses.CompleteQuestResponse.Status|null);
                quest?: (POGOProtos.Data.Quests.IClientQuest|null);
                stamp?: (POGOProtos.Data.Quests.IQuestStamp[]|null);
            }

            class CompleteQuestResponse implements ICompleteQuestResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ICompleteQuestResponse);
                public status: POGOProtos.Networking.Responses.CompleteQuestResponse.Status;
                public quest?: (POGOProtos.Data.Quests.IClientQuest|null);
                public stamp: POGOProtos.Data.Quests.IQuestStamp[];
                public static encode(message: POGOProtos.Networking.Responses.ICompleteQuestResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.CompleteQuestResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.CompleteQuestResponse;
                public static toObject(message: POGOProtos.Networking.Responses.CompleteQuestResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CompleteQuestResponse {

                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
                }
            }

            interface ICompleteQuestStampCardResponse {
                status?: (POGOProtos.Networking.Responses.CompleteQuestStampCardResponse.Status|null);
                reward?: (POGOProtos.Data.Quests.IQuestReward[]|null);
            }

            class CompleteQuestStampCardResponse implements ICompleteQuestStampCardResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ICompleteQuestStampCardResponse);
                public status: POGOProtos.Networking.Responses.CompleteQuestStampCardResponse.Status;
                public reward: POGOProtos.Data.Quests.IQuestReward[];
                public static encode(message: POGOProtos.Networking.Responses.ICompleteQuestStampCardResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.CompleteQuestStampCardResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.CompleteQuestStampCardResponse;
                public static toObject(message: POGOProtos.Networking.Responses.CompleteQuestStampCardResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CompleteQuestStampCardResponse {

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

            interface IConfirmPhotobombResponse {
                status?: (POGOProtos.Networking.Responses.ConfirmPhotobombResponse.Status|null);
            }

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

            namespace ConfirmPhotobombResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PHOTOBOMB_NOT_FOUND = 2,
                    ERROR_PHOTOBOMB_ALREADY_CONFIRMED = 3,
                    ERROR_UNKNOWN = 4
                }
            }

            interface IConfirmTradingResponse {
                result?: (POGOProtos.Networking.Responses.ConfirmTradingResponse.Result|null);
                trading?: (POGOProtos.Data.Trading.ITrading|null);
            }

            class ConfirmTradingResponse implements IConfirmTradingResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IConfirmTradingResponse);
                public result: POGOProtos.Networking.Responses.ConfirmTradingResponse.Result;
                public trading?: (POGOProtos.Data.Trading.ITrading|null);
                public static encode(message: POGOProtos.Networking.Responses.IConfirmTradingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.ConfirmTradingResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.ConfirmTradingResponse;
                public static toObject(message: POGOProtos.Networking.Responses.ConfirmTradingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ConfirmTradingResponse {

                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 ICreateCombatChallengeResponse {
                result?: (POGOProtos.Networking.Responses.CreateCombatChallengeResponse.Result|null);
                challenge?: (POGOProtos.Data.Combat.ICombatChallenge|null);
            }

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

            namespace CreateCombatChallengeResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_INVALID_CHALLENGE_STATE = 2,
                    ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 3,
                    ERROR_ACCESS_DENIED = 4
                }
            }

            interface IDeclineCombatChallengeResponse {
                result?: (POGOProtos.Networking.Responses.DeclineCombatChallengeResponse.Result|null);
            }

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

            namespace DeclineCombatChallengeResponse {

                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 IDeclineSharedExRaidPassResponse {
                result?: (POGOProtos.Networking.Responses.DeclineSharedExRaidPassResponse.Result|null);
            }

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

            namespace DeclineSharedExRaidPassResponse {

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

            interface IDeleteGiftFromInventoryResponse {
                result?: (POGOProtos.Networking.Responses.DeleteGiftFromInventoryResponse.Result|null);
            }

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

            namespace DeleteGiftFromInventoryResponse {

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

            interface IDeleteGiftResponse {
                result?: (POGOProtos.Networking.Responses.DeleteGiftResponse.Result|null);
            }

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

            namespace DeleteGiftResponse {

                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 IDiskEncounterResponse {
                result?: (POGOProtos.Networking.Responses.DiskEncounterResponse.Result|null);
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                active_item?: (POGOProtos.Inventory.Item.ItemId|null);
                arplus_attempts_until_flee?: (number|null);
            }

            class DiskEncounterResponse implements IDiskEncounterResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IDiskEncounterResponse);
                public result: POGOProtos.Networking.Responses.DiskEncounterResponse.Result;
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public active_item: POGOProtos.Inventory.Item.ItemId;
                public arplus_attempts_until_flee: number;
                public static encode(message: POGOProtos.Networking.Responses.IDiskEncounterResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.DiskEncounterResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.DiskEncounterResponse;
                public static toObject(message: POGOProtos.Networking.Responses.DiskEncounterResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DiskEncounterResponse {

                enum Result {
                    UNKNOWN = 0,
                    SUCCESS = 1,
                    NOT_AVAILABLE = 2,
                    NOT_IN_RANGE = 3,
                    ENCOUNTER_ALREADY_FINISHED = 4,
                    POKEMON_INVENTORY_FULL = 5
                }
            }

            interface IDownloadGmTemplatesResponse {
                result?: (POGOProtos.Networking.Responses.DownloadGmTemplatesResponse.Result|null);
                template?: (POGOProtos.Networking.Responses.DownloadGmTemplatesResponse.IClientGameMasterTemplate[]|null);
                deleted_template?: (string[]|null);
                batch_id?: (number|Long|null);
                page_offset?: (number|null);
            }

            class DownloadGmTemplatesResponse implements IDownloadGmTemplatesResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IDownloadGmTemplatesResponse);
                public result: POGOProtos.Networking.Responses.DownloadGmTemplatesResponse.Result;
                public template: POGOProtos.Networking.Responses.DownloadGmTemplatesResponse.IClientGameMasterTemplate[];
                public deleted_template: string[];
                public batch_id: (number|Long);
                public page_offset: number;
                public static encode(message: POGOProtos.Networking.Responses.IDownloadGmTemplatesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.DownloadGmTemplatesResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.DownloadGmTemplatesResponse;
                public static toObject(message: POGOProtos.Networking.Responses.DownloadGmTemplatesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DownloadGmTemplatesResponse {

                enum Result {
                    UNSET = 0,
                    COMPLETE = 1,
                    MORE_RESULTS = 2,
                    BATCH_ID_NOT_LIVE = 3,
                    INVALID_BASIS_BATCH_ID = 4
                }

                interface IClientGameMasterTemplate {
                    template_id?: (string|null);
                    data?: (Uint8Array|null);
                }

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

            interface IDownloadItemTemplatesResponse {
                result?: (POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.Result|null);
                item_templates?: (POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.IItemTemplate[]|null);
                timestamp_ms?: (number|Long|null);
                page_offset?: (number|null);
            }

            class DownloadItemTemplatesResponse implements IDownloadItemTemplatesResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IDownloadItemTemplatesResponse);
                public result: POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.Result;
                public item_templates: POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.IItemTemplate[];
                public timestamp_ms: (number|Long);
                public page_offset: number;
                public static encode(message: POGOProtos.Networking.Responses.IDownloadItemTemplatesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.DownloadItemTemplatesResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.DownloadItemTemplatesResponse;
                public static toObject(message: POGOProtos.Networking.Responses.DownloadItemTemplatesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DownloadItemTemplatesResponse {

                interface IItemTemplate {
                    template_id?: (string|null);
                    pokemon_settings?: (POGOProtos.Settings.Master.IPokemonSettings|null);
                    item_settings?: (POGOProtos.Settings.Master.IItemSettings|null);
                    move_settings?: (POGOProtos.Settings.Master.IMoveSettings|null);
                    move_sequence_settings?: (POGOProtos.Settings.Master.IMoveSequenceSettings|null);
                    type_effective?: (POGOProtos.Settings.Master.ITypeEffectiveSettings|null);
                    badge_settings?: (POGOProtos.Settings.Master.IBadgeSettings|null);
                    camera?: (POGOProtos.Settings.Master.ICameraSettings|null);
                    player_level?: (POGOProtos.Settings.Master.IPlayerLevelSettings|null);
                    gym_level?: (POGOProtos.Settings.Master.IGymLevelSettings|null);
                    battle_settings?: (POGOProtos.Settings.Master.IGymBattleSettings|null);
                    encounter_settings?: (POGOProtos.Settings.Master.IEncounterSettings|null);
                    iap_item_display?: (POGOProtos.Settings.Master.IIapItemDisplay|null);
                    iap_settings?: (POGOProtos.Settings.Master.IIapSettings|null);
                    pokemon_upgrades?: (POGOProtos.Settings.Master.IPokemonUpgradeSettings|null);
                    equipped_badges?: (POGOProtos.Settings.Master.IEquippedBadgeSettings|null);
                    quest_settings?: (POGOProtos.Settings.Master.IQuestSettings|null);
                    avatar_customization?: (POGOProtos.Data.Avatar.IAvatarCustomization|null);
                    form_settings?: (POGOProtos.Settings.Master.IFormSettings|null);
                    gender_settings?: (POGOProtos.Settings.Master.IGenderSettings|null);
                    gym_badge_settings?: (POGOProtos.Settings.Master.IGymBadgeGmtSettings|null);
                    weather_affinities?: (POGOProtos.Settings.Master.IWeatherAffinity|null);
                    weather_bonus_settings?: (POGOProtos.Settings.Master.IWeatherBonus|null);
                    pokemon_scale_settings?: (POGOProtos.Settings.Master.IPokemonScaleSetting|null);
                    iap_category_display?: (POGOProtos.Settings.Master.IIapItemCategoryDisplay|null);
                    beluga_pokemon_whitelist?: (POGOProtos.Settings.Master.IBelugaPokemonWhitelist|null);
                    onboarding_settings?: (POGOProtos.Settings.Master.IOnboardingSettings|null);
                    friendship_milestone_settings?: (POGOProtos.Settings.Master.IFriendshipLevelMilestoneSettings|null);
                    lucky_pokemon_settings?: (POGOProtos.Settings.Master.ILuckyPokemonSettings|null);
                    combat_settings?: (POGOProtos.Settings.Master.ICombatSettings|null);
                    combat_league_settings?: (POGOProtos.Settings.Master.ICombatLeagueSettings|null);
                    combat_league?: (POGOProtos.Settings.Master.ICombatLeague|null);
                    ex_raid_settings?: (POGOProtos.Settings.Master.IExRaidSettings|null);
                    combat_move?: (POGOProtos.Settings.Master.ICombatMoveSettings|null);
                    background_mode_settings?: (POGOProtos.Settings.Master.IBackgroundModeSettings|null);
                    combat_stat_stage_settings?: (POGOProtos.Settings.Master.ICombatStatStageSettings|null);
                    combat_npc_trainer?: (POGOProtos.Settings.Master.ICombatNpcTrainer|null);
                    combat_npc_personality?: (POGOProtos.Settings.Master.ICombatNpcPersonality|null);
                    onboarding_v2_settings?: (POGOProtos.Settings.Master.IOnboardingV2Settings|null);
                    party_recommendation_settings?: (POGOProtos.Settings.Master.IPartyRecommendationSettings|null);
                    smeargle_moves_settings?: (POGOProtos.Settings.Master.ISmeargleMovesSettings|null);
                }

                class ItemTemplate implements IItemTemplate {
                    constructor(properties?: POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.IItemTemplate);
                    public template_id: string;
                    public pokemon_settings?: (POGOProtos.Settings.Master.IPokemonSettings|null);
                    public item_settings?: (POGOProtos.Settings.Master.IItemSettings|null);
                    public move_settings?: (POGOProtos.Settings.Master.IMoveSettings|null);
                    public move_sequence_settings?: (POGOProtos.Settings.Master.IMoveSequenceSettings|null);
                    public type_effective?: (POGOProtos.Settings.Master.ITypeEffectiveSettings|null);
                    public badge_settings?: (POGOProtos.Settings.Master.IBadgeSettings|null);
                    public camera?: (POGOProtos.Settings.Master.ICameraSettings|null);
                    public player_level?: (POGOProtos.Settings.Master.IPlayerLevelSettings|null);
                    public gym_level?: (POGOProtos.Settings.Master.IGymLevelSettings|null);
                    public battle_settings?: (POGOProtos.Settings.Master.IGymBattleSettings|null);
                    public encounter_settings?: (POGOProtos.Settings.Master.IEncounterSettings|null);
                    public iap_item_display?: (POGOProtos.Settings.Master.IIapItemDisplay|null);
                    public iap_settings?: (POGOProtos.Settings.Master.IIapSettings|null);
                    public pokemon_upgrades?: (POGOProtos.Settings.Master.IPokemonUpgradeSettings|null);
                    public equipped_badges?: (POGOProtos.Settings.Master.IEquippedBadgeSettings|null);
                    public quest_settings?: (POGOProtos.Settings.Master.IQuestSettings|null);
                    public avatar_customization?: (POGOProtos.Data.Avatar.IAvatarCustomization|null);
                    public form_settings?: (POGOProtos.Settings.Master.IFormSettings|null);
                    public gender_settings?: (POGOProtos.Settings.Master.IGenderSettings|null);
                    public gym_badge_settings?: (POGOProtos.Settings.Master.IGymBadgeGmtSettings|null);
                    public weather_affinities?: (POGOProtos.Settings.Master.IWeatherAffinity|null);
                    public weather_bonus_settings?: (POGOProtos.Settings.Master.IWeatherBonus|null);
                    public pokemon_scale_settings?: (POGOProtos.Settings.Master.IPokemonScaleSetting|null);
                    public iap_category_display?: (POGOProtos.Settings.Master.IIapItemCategoryDisplay|null);
                    public beluga_pokemon_whitelist?: (POGOProtos.Settings.Master.IBelugaPokemonWhitelist|null);
                    public onboarding_settings?: (POGOProtos.Settings.Master.IOnboardingSettings|null);
                    public friendship_milestone_settings?: (POGOProtos.Settings.Master.IFriendshipLevelMilestoneSettings|null);
                    public lucky_pokemon_settings?: (POGOProtos.Settings.Master.ILuckyPokemonSettings|null);
                    public combat_settings?: (POGOProtos.Settings.Master.ICombatSettings|null);
                    public combat_league_settings?: (POGOProtos.Settings.Master.ICombatLeagueSettings|null);
                    public combat_league?: (POGOProtos.Settings.Master.ICombatLeague|null);
                    public ex_raid_settings?: (POGOProtos.Settings.Master.IExRaidSettings|null);
                    public combat_move?: (POGOProtos.Settings.Master.ICombatMoveSettings|null);
                    public background_mode_settings?: (POGOProtos.Settings.Master.IBackgroundModeSettings|null);
                    public combat_stat_stage_settings?: (POGOProtos.Settings.Master.ICombatStatStageSettings|null);
                    public combat_npc_trainer?: (POGOProtos.Settings.Master.ICombatNpcTrainer|null);
                    public combat_npc_personality?: (POGOProtos.Settings.Master.ICombatNpcPersonality|null);
                    public onboarding_v2_settings?: (POGOProtos.Settings.Master.IOnboardingV2Settings|null);
                    public party_recommendation_settings?: (POGOProtos.Settings.Master.IPartyRecommendationSettings|null);
                    public smeargle_moves_settings?: (POGOProtos.Settings.Master.ISmeargleMovesSettings|null);
                    public static encode(message: POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.IItemTemplate, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.ItemTemplate;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.ItemTemplate;
                    public static toObject(message: POGOProtos.Networking.Responses.DownloadItemTemplatesResponse.ItemTemplate, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

            interface IDownloadRemoteConfigVersionResponse {
                result?: (POGOProtos.Networking.Responses.DownloadRemoteConfigVersionResponse.Result|null);
                item_templates_timestamp_ms?: (number|Long|null);
                asset_digest_timestamp_ms?: (number|Long|null);
                experiment_id?: (number[]|null);
            }

            class DownloadRemoteConfigVersionResponse implements IDownloadRemoteConfigVersionResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IDownloadRemoteConfigVersionResponse);
                public result: POGOProtos.Networking.Responses.DownloadRemoteConfigVersionResponse.Result;
                public item_templates_timestamp_ms: (number|Long);
                public asset_digest_timestamp_ms: (number|Long);
                public experiment_id: number[];
                public static encode(message: POGOProtos.Networking.Responses.IDownloadRemoteConfigVersionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.DownloadRemoteConfigVersionResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.DownloadRemoteConfigVersionResponse;
                public static toObject(message: POGOProtos.Networking.Responses.DownloadRemoteConfigVersionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace DownloadRemoteConfigVersionResponse {

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

            interface IDownloadSettingsResponse {
                error?: (string|null);
                hash?: (string|null);
                settings?: (POGOProtos.Settings.IGlobalSettings|null);
            }

            class DownloadSettingsResponse implements IDownloadSettingsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IDownloadSettingsResponse);
                public error: string;
                public hash: string;
                public settings?: (POGOProtos.Settings.IGlobalSettings|null);
                public static encode(message: POGOProtos.Networking.Responses.IDownloadSettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.DownloadSettingsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.DownloadSettingsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.DownloadSettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEchoResponse {
                context?: (string|null);
            }

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

            interface IEncounterPhotobombResponse {
                result?: (POGOProtos.Networking.Responses.EncounterPhotobombResponse.Result|null);
                pokemon?: (POGOProtos.Data.IPokemonData|null);
                capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                active_item?: (POGOProtos.Inventory.Item.ItemId|null);
                arplus_attempts_until_flee?: (number|null);
            }

            class EncounterPhotobombResponse implements IEncounterPhotobombResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IEncounterPhotobombResponse);
                public result: POGOProtos.Networking.Responses.EncounterPhotobombResponse.Result;
                public pokemon?: (POGOProtos.Data.IPokemonData|null);
                public capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public active_item: POGOProtos.Inventory.Item.ItemId;
                public arplus_attempts_until_flee: number;
                public static encode(message: POGOProtos.Networking.Responses.IEncounterPhotobombResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.EncounterPhotobombResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.EncounterPhotobombResponse;
                public static toObject(message: POGOProtos.Networking.Responses.EncounterPhotobombResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace EncounterPhotobombResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    NO_ENCOUNTER_AVAILABLE = 2,
                    POKEMON_INVENTORY_FULL = 3,
                    ERROR_UNKNOWN = 4
                }
            }

            interface IEncounterResponse {
                wild_pokemon?: (POGOProtos.Map.Pokemon.IWildPokemon|null);
                background?: (POGOProtos.Networking.Responses.EncounterResponse.Background|null);
                status?: (POGOProtos.Networking.Responses.EncounterResponse.Status|null);
                capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                active_item?: (POGOProtos.Inventory.Item.ItemId|null);
                arplus_attempts_until_flee?: (number|null);
            }

            class EncounterResponse implements IEncounterResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IEncounterResponse);
                public wild_pokemon?: (POGOProtos.Map.Pokemon.IWildPokemon|null);
                public background: POGOProtos.Networking.Responses.EncounterResponse.Background;
                public status: POGOProtos.Networking.Responses.EncounterResponse.Status;
                public capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public active_item: POGOProtos.Inventory.Item.ItemId;
                public arplus_attempts_until_flee: number;
                public static encode(message: POGOProtos.Networking.Responses.IEncounterResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.EncounterResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.EncounterResponse;
                public static toObject(message: POGOProtos.Networking.Responses.EncounterResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace EncounterResponse {

                enum Background {
                    PARK = 0,
                    DESERT = 1
                }

                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 IEncounterTutorialCompleteResponse {
                result?: (POGOProtos.Networking.Responses.EncounterTutorialCompleteResponse.Result|null);
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                capture_award?: (POGOProtos.Data.Capture.ICaptureAward|null);
            }

            class EncounterTutorialCompleteResponse implements IEncounterTutorialCompleteResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IEncounterTutorialCompleteResponse);
                public result: POGOProtos.Networking.Responses.EncounterTutorialCompleteResponse.Result;
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public capture_award?: (POGOProtos.Data.Capture.ICaptureAward|null);
                public static encode(message: POGOProtos.Networking.Responses.IEncounterTutorialCompleteResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.EncounterTutorialCompleteResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.EncounterTutorialCompleteResponse;
                public static toObject(message: POGOProtos.Networking.Responses.EncounterTutorialCompleteResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace EncounterTutorialCompleteResponse {

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

            interface IEquipBadgeResponse {
                result?: (POGOProtos.Networking.Responses.EquipBadgeResponse.Result|null);
                equipped?: (POGOProtos.Data.Player.IEquippedBadge|null);
            }

            class EquipBadgeResponse implements IEquipBadgeResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IEquipBadgeResponse);
                public result: POGOProtos.Networking.Responses.EquipBadgeResponse.Result;
                public equipped?: (POGOProtos.Data.Player.IEquippedBadge|null);
                public static encode(message: POGOProtos.Networking.Responses.IEquipBadgeResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.EquipBadgeResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.EquipBadgeResponse;
                public static toObject(message: POGOProtos.Networking.Responses.EquipBadgeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace EquipBadgeResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    COOLDOWN_ACTIVE = 2,
                    NOT_QUALIFIED = 3
                }
            }

            interface IEvolvePokemonResponse {
                result?: (POGOProtos.Networking.Responses.EvolvePokemonResponse.Result|null);
                evolved_pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                experience_awarded?: (number|null);
                candy_awarded?: (number|null);
            }

            class EvolvePokemonResponse implements IEvolvePokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IEvolvePokemonResponse);
                public result: POGOProtos.Networking.Responses.EvolvePokemonResponse.Result;
                public evolved_pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public experience_awarded: number;
                public candy_awarded: number;
                public static encode(message: POGOProtos.Networking.Responses.IEvolvePokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.EvolvePokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.EvolvePokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.EvolvePokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace EvolvePokemonResponse {

                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
                }
            }

            interface IFetchAllNewsResponse {
                result?: (POGOProtos.Networking.Responses.FetchAllNewsResponse.Result|null);
                current_news?: (POGOProtos.Data.News.ICurrentNews|null);
            }

            class FetchAllNewsResponse implements IFetchAllNewsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IFetchAllNewsResponse);
                public result: POGOProtos.Networking.Responses.FetchAllNewsResponse.Result;
                public current_news?: (POGOProtos.Data.News.ICurrentNews|null);
                public static encode(message: POGOProtos.Networking.Responses.IFetchAllNewsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.FetchAllNewsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.FetchAllNewsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.FetchAllNewsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FetchAllNewsResponse {

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

            interface IFortDeployPokemonResponse {
                result?: (POGOProtos.Networking.Responses.FortDeployPokemonResponse.Result|null);
                fort_details?: (POGOProtos.Networking.Responses.IFortDetailsResponse|null);
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                gym_state?: (POGOProtos.Data.Gym.IGymState|null);
            }

            class FortDeployPokemonResponse implements IFortDeployPokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IFortDeployPokemonResponse);
                public result: POGOProtos.Networking.Responses.FortDeployPokemonResponse.Result;
                public fort_details?: (POGOProtos.Networking.Responses.IFortDetailsResponse|null);
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public gym_state?: (POGOProtos.Data.Gym.IGymState|null);
                public static encode(message: POGOProtos.Networking.Responses.IFortDeployPokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.FortDeployPokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.FortDeployPokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.FortDeployPokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FortDeployPokemonResponse {

                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 IFortDetailsResponse {
                fort_id?: (string|null);
                team_color?: (POGOProtos.Enums.TeamColor|null);
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                name?: (string|null);
                image_urls?: (string[]|null);
                fp?: (number|null);
                stamina?: (number|null);
                max_stamina?: (number|null);
                type?: (POGOProtos.Map.Fort.FortType|null);
                latitude?: (number|null);
                longitude?: (number|null);
                description?: (string|null);
                modifiers?: (POGOProtos.Map.Fort.IFortModifier[]|null);
                close_soon?: (boolean|null);
                checkin_image_url?: (string|null);
                event_info?: (POGOProtos.Data.Raid.IEventInfo|null);
            }

            class FortDetailsResponse implements IFortDetailsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IFortDetailsResponse);
                public fort_id: string;
                public team_color: POGOProtos.Enums.TeamColor;
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public name: string;
                public image_urls: string[];
                public fp: number;
                public stamina: number;
                public max_stamina: number;
                public type: POGOProtos.Map.Fort.FortType;
                public latitude: number;
                public longitude: number;
                public description: string;
                public modifiers: POGOProtos.Map.Fort.IFortModifier[];
                public close_soon: boolean;
                public checkin_image_url: string;
                public event_info?: (POGOProtos.Data.Raid.IEventInfo|null);
                public static encode(message: POGOProtos.Networking.Responses.IFortDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.FortDetailsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.FortDetailsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.FortDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IFortRecallPokemonResponse {
                result?: (POGOProtos.Networking.Responses.FortRecallPokemonResponse.Result|null);
                fort_details?: (POGOProtos.Networking.Responses.IFortDetailsResponse|null);
            }

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

            namespace FortRecallPokemonResponse {

                enum Result {
                    NO_RESULT_SET = 0,
                    SUCCESS = 1,
                    ERROR_NOT_IN_RANGE = 2,
                    ERROR_POKEMON_NOT_ON_FORT = 3,
                    ERROR_NO_PLAYER = 4
                }
            }

            interface IFortSearchResponse {
                result?: (POGOProtos.Networking.Responses.FortSearchResponse.Result|null);
                items_awarded?: (POGOProtos.Inventory.Item.IItemAward[]|null);
                gems_awarded?: (number|null);
                pokemon_data_egg?: (POGOProtos.Data.IPokemonData|null);
                experience_awarded?: (number|null);
                cooldown_complete_timestamp_ms?: (number|Long|null);
                chain_hack_sequence_number?: (number|null);
                awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                loot?: (POGOProtos.Inventory.ILoot|null);
                bonus_loot?: (POGOProtos.Inventory.ILoot|null);
                raid_tickets?: (number|null);
                team_bonus_loot?: (POGOProtos.Inventory.ILoot|null);
                fort_id?: (string|null);
                challenge_quest?: (POGOProtos.Data.Quests.IClientQuest|null);
                gift_box?: (POGOProtos.Data.Gift.IGiftBox|null);
            }

            class FortSearchResponse implements IFortSearchResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IFortSearchResponse);
                public result: POGOProtos.Networking.Responses.FortSearchResponse.Result;
                public items_awarded: POGOProtos.Inventory.Item.IItemAward[];
                public gems_awarded: number;
                public pokemon_data_egg?: (POGOProtos.Data.IPokemonData|null);
                public experience_awarded: number;
                public cooldown_complete_timestamp_ms: (number|Long);
                public chain_hack_sequence_number: number;
                public awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                public loot?: (POGOProtos.Inventory.ILoot|null);
                public bonus_loot?: (POGOProtos.Inventory.ILoot|null);
                public raid_tickets: number;
                public team_bonus_loot?: (POGOProtos.Inventory.ILoot|null);
                public fort_id: string;
                public challenge_quest?: (POGOProtos.Data.Quests.IClientQuest|null);
                public gift_box?: (POGOProtos.Data.Gift.IGiftBox|null);
                public static encode(message: POGOProtos.Networking.Responses.IFortSearchResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.FortSearchResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.FortSearchResponse;
                public static toObject(message: POGOProtos.Networking.Responses.FortSearchResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FortSearchResponse {

                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 IGenerateCombatChallengeIdResponse {
                result?: (POGOProtos.Networking.Responses.GenerateCombatChallengeIdResponse.Result|null);
                challenge_id?: (string|null);
            }

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

            namespace GenerateCombatChallengeIdResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 2,
                    ERROR_ACCESS_DENIED = 3
                }
            }

            interface IGenerateGmapSignedUrlResponse {
                result?: (POGOProtos.Networking.Responses.GenerateGmapSignedUrlResponse.Result|null);
                signed_url?: (string|null);
            }

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

            namespace GenerateGmapSignedUrlResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_NOT_VALID = 2,
                    ERROR_RATE_LIMITED = 3,
                    ERROR_MISSING_INPUT = 4,
                    ERROR_UNKNOWN = 5
                }
            }

            interface IGetAssetDigestResponse {
                digest?: (POGOProtos.Data.IAssetDigestEntry[]|null);
                timestamp_ms?: (number|Long|null);
                result?: (POGOProtos.Networking.Responses.GetAssetDigestResponse.Result|null);
                page_offset?: (number|null);
            }

            class GetAssetDigestResponse implements IGetAssetDigestResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetAssetDigestResponse);
                public digest: POGOProtos.Data.IAssetDigestEntry[];
                public timestamp_ms: (number|Long);
                public result: POGOProtos.Networking.Responses.GetAssetDigestResponse.Result;
                public page_offset: number;
                public static encode(message: POGOProtos.Networking.Responses.IGetAssetDigestResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetAssetDigestResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetAssetDigestResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetAssetDigestResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetAssetDigestResponse {

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

            interface IGetAvailableSkusAndBalancesResponse {
                status?: (POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.Status|null);
                available_sku?: (POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku[]|null);
                player_currencies?: (POGOProtos.Data.Store.ICurrencyQuantity[]|null);
                player_token?: (string|null);
            }

            class GetAvailableSkusAndBalancesResponse implements IGetAvailableSkusAndBalancesResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetAvailableSkusAndBalancesResponse);
                public status: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.Status;
                public available_sku: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku[];
                public player_currencies: POGOProtos.Data.Store.ICurrencyQuantity[];
                public player_token: string;
                public static encode(message: POGOProtos.Networking.Responses.IGetAvailableSkusAndBalancesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetAvailableSkusAndBalancesResponse {

                interface IAvailableSku {
                    id?: (string|null);
                    is_third_party_vendor_item?: (boolean|null);
                    price?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                    currency_granted?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                    game_item_content?: (POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.IGameItemContent[]|null);
                    presentation_data?: (POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.ISkuPresentation[]|null);
                    can_be_purchased?: (boolean|null);
                }

                class AvailableSku implements IAvailableSku {
                    constructor(properties?: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku);
                    public id: string;
                    public is_third_party_vendor_item: boolean;
                    public price?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                    public currency_granted?: (POGOProtos.Data.Store.ICurrencyQuantity|null);
                    public game_item_content: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.IGameItemContent[];
                    public presentation_data: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.ISkuPresentation[];
                    public can_be_purchased: boolean;
                    public static encode(message: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.IAvailableSku, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.AvailableSku;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.AvailableSku;
                    public static toObject(message: POGOProtos.Networking.Responses.GetAvailableSkusAndBalancesResponse.AvailableSku, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IGameItemContent {
                    type?: (string|null);
                    quantity?: (number|null);
                }

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

                interface ISkuPresentation {
                    key?: (string|null);
                    value?: (string|null);
                }

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

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

            interface IGetBuddyWalkedResponse {
                success?: (boolean|null);
                family_candy_id?: (POGOProtos.Enums.PokemonFamilyId|null);
                candy_earned_count?: (number|null);
                km_remaining?: (number|null);
            }

            class GetBuddyWalkedResponse implements IGetBuddyWalkedResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetBuddyWalkedResponse);
                public success: boolean;
                public family_candy_id: POGOProtos.Enums.PokemonFamilyId;
                public candy_earned_count: number;
                public km_remaining: number;
                public static encode(message: POGOProtos.Networking.Responses.IGetBuddyWalkedResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetBuddyWalkedResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetBuddyWalkedResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetBuddyWalkedResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetClientBgmodeSettingsResponse {
                status?: (POGOProtos.Networking.Responses.GetClientBgmodeSettingsResponse.Status|null);
                settings?: (POGOProtos.Settings.IBackgroundModeClientSettings|null);
            }

            class GetClientBgmodeSettingsResponse implements IGetClientBgmodeSettingsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetClientBgmodeSettingsResponse);
                public status: POGOProtos.Networking.Responses.GetClientBgmodeSettingsResponse.Status;
                public settings?: (POGOProtos.Settings.IBackgroundModeClientSettings|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetClientBgmodeSettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetClientBgmodeSettingsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetClientBgmodeSettingsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetClientBgmodeSettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetClientBgmodeSettingsResponse {

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

            interface IGetClientTelemetrySettingsResponse {
                one?: (number|null);
                two?: (number|null);
                three?: (number|null);
                four?: (number|null);
                five?: (number|null);
                six?: (number|Long|null);
                seven?: (number|null);
                eight?: (number|Long|null);
                nine?: (string|null);
            }

            class GetClientTelemetrySettingsResponse implements IGetClientTelemetrySettingsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetClientTelemetrySettingsResponse);
                public one: number;
                public two: number;
                public three: number;
                public four: number;
                public five: number;
                public six: (number|Long);
                public seven: number;
                public eight: (number|Long);
                public nine: string;
                public static encode(message: POGOProtos.Networking.Responses.IGetClientTelemetrySettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetClientTelemetrySettingsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetClientTelemetrySettingsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetClientTelemetrySettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetCombatChallengeResponse {
                result?: (POGOProtos.Networking.Responses.GetCombatChallengeResponse.Result|null);
                challenge?: (POGOProtos.Data.Combat.ICombatChallenge|null);
            }

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

            namespace GetCombatChallengeResponse {

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

            interface IGetCombatPlayerProfileResponse {
                result?: (POGOProtos.Networking.Responses.GetCombatPlayerProfileResponse.Result|null);
                profile?: (POGOProtos.Data.Combat.ICombatPlayerProfile|null);
            }

            class GetCombatPlayerProfileResponse implements IGetCombatPlayerProfileResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetCombatPlayerProfileResponse);
                public result: POGOProtos.Networking.Responses.GetCombatPlayerProfileResponse.Result;
                public profile?: (POGOProtos.Data.Combat.ICombatPlayerProfile|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetCombatPlayerProfileResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetCombatPlayerProfileResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetCombatPlayerProfileResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetCombatPlayerProfileResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetCombatPlayerProfileResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_NOT_FOUND = 2,
                    ERROR_ACCESS_DENIED = 3
                }
            }

            interface IGetCombatResultsResponse {
                result?: (POGOProtos.Networking.Responses.GetCombatResultsResponse.Result|null);
                reward_status?: (POGOProtos.Enums.CombatRewardStatus|null);
                rewards?: (POGOProtos.Inventory.ILoot|null);
                friend_level_up?: (POGOProtos.Data.Friends.ILeveledUpFriends|null);
                number_rewarded_battles_today?: (number|null);
                combat_player_finish_state?: (POGOProtos.Enums.CombatPlayerFinishState|null);
                combat_rematch?: (POGOProtos.Networking.Responses.GetCombatResultsResponse.ICombatRematch|null);
            }

            class GetCombatResultsResponse implements IGetCombatResultsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetCombatResultsResponse);
                public result: POGOProtos.Networking.Responses.GetCombatResultsResponse.Result;
                public reward_status: POGOProtos.Enums.CombatRewardStatus;
                public rewards?: (POGOProtos.Inventory.ILoot|null);
                public friend_level_up?: (POGOProtos.Data.Friends.ILeveledUpFriends|null);
                public number_rewarded_battles_today: number;
                public combat_player_finish_state: POGOProtos.Enums.CombatPlayerFinishState;
                public combat_rematch?: (POGOProtos.Networking.Responses.GetCombatResultsResponse.ICombatRematch|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetCombatResultsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetCombatResultsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetCombatResultsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetCombatResultsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetCombatResultsResponse {

                interface ICombatRematch {
                    combat_rematch_id?: (string|null);
                    combat_league_template_id?: (string|null);
                }

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

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_INVALID_COMBAT_STATE = 2,
                    ERROR_COMBAT_NOT_FOUND = 3,
                    ERROR_PLAYER_QUIT = 4
                }
            }

            interface IGetDownloadUrlsResponse {
                download_urls?: (POGOProtos.Data.IDownloadUrlEntry[]|null);
            }

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

            interface IGetFitnessReportResponse {
                status?: (POGOProtos.Networking.Responses.GetFitnessReportResponse.Status|null);
                daily_reports?: (POGOProtos.Data.Fitness.IFitnessReport[]|null);
                weekly_reports?: (POGOProtos.Data.Fitness.IFitnessReport[]|null);
                week_reset_timestamp_since_monday_ms?: (number|Long|null);
            }

            class GetFitnessReportResponse implements IGetFitnessReportResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetFitnessReportResponse);
                public status: POGOProtos.Networking.Responses.GetFitnessReportResponse.Status;
                public daily_reports: POGOProtos.Data.Fitness.IFitnessReport[];
                public weekly_reports: POGOProtos.Data.Fitness.IFitnessReport[];
                public week_reset_timestamp_since_monday_ms: (number|Long);
                public static encode(message: POGOProtos.Networking.Responses.IGetFitnessReportResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetFitnessReportResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetFitnessReportResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetFitnessReportResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetFitnessReportResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_NOT_FOUND = 2,
                    ERROR_RECORDS_NOT_FOUND = 3,
                    ERROR_INVALID_WINDOW = 4,
                    ERROR_UNKNOWN = 5
                }
            }

            interface IGetFitnessRewardsResponse {
                result?: (POGOProtos.Networking.Responses.GetFitnessRewardsResponse.Result|null);
                rewards?: (POGOProtos.Inventory.ILoot|null);
            }

            class GetFitnessRewardsResponse implements IGetFitnessRewardsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetFitnessRewardsResponse);
                public result: POGOProtos.Networking.Responses.GetFitnessRewardsResponse.Result;
                public rewards?: (POGOProtos.Inventory.ILoot|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetFitnessRewardsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetFitnessRewardsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetFitnessRewardsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetFitnessRewardsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetFitnessRewardsResponse {

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

            interface IGetFriendshipMilestoneRewardsResponse {
                result?: (POGOProtos.Networking.Responses.GetFriendshipMilestoneRewardsResponse.Result|null);
                xp_reward?: (number|Long|null);
                friend_id?: (string|null);
            }

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

            namespace GetFriendshipMilestoneRewardsResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_UNKNOWN = 2,
                    ERROR_NOT_FRIENDS = 3,
                    ERROR_MILESTONE_ALREADY_AWARDED = 4,
                    ERROR_FAILED_TO_UPDATE = 5
                }
            }

            interface IGetFriendshipRewardsResponse {
                result?: (POGOProtos.Networking.Responses.GetFriendshipRewardsResponse.Result|null);
                xp_reward?: (number|Long|null);
                friend_id?: (string|null);
            }

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

            namespace GetFriendshipRewardsResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_UNKNOWN = 2,
                    ERROR_NOT_FRIENDS = 3,
                    ERROR_MILESTONE_ALREADY_AWARDED = 4,
                    ERROR_FAILED_TO_UPDATE = 5
                }
            }

            interface IGetGymBadgeDetailsResponse {
                gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                gym_defender?: (POGOProtos.Data.Gym.IGymDefender|null);
                success?: (boolean|null);
            }

            class GetGymBadgeDetailsResponse implements IGetGymBadgeDetailsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetGymBadgeDetailsResponse);
                public gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                public gym_defender?: (POGOProtos.Data.Gym.IGymDefender|null);
                public success: boolean;
                public static encode(message: POGOProtos.Networking.Responses.IGetGymBadgeDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetGymBadgeDetailsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetGymBadgeDetailsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetGymBadgeDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetGymDetailsResponse {
                gym_state?: (POGOProtos.Data.Gym.IGymState|null);
                name?: (string|null);
                urls?: (string[]|null);
                result?: (POGOProtos.Networking.Responses.GetGymDetailsResponse.Result|null);
                description?: (string|null);
                secondary_url?: (string[]|null);
                checkin_image_url?: (string|null);
                event_info?: (POGOProtos.Data.Raid.IEventInfo|null);
            }

            class GetGymDetailsResponse implements IGetGymDetailsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetGymDetailsResponse);
                public gym_state?: (POGOProtos.Data.Gym.IGymState|null);
                public name: string;
                public urls: string[];
                public result: POGOProtos.Networking.Responses.GetGymDetailsResponse.Result;
                public description: string;
                public secondary_url: string[];
                public checkin_image_url: string;
                public event_info?: (POGOProtos.Data.Raid.IEventInfo|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetGymDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetGymDetailsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetGymDetailsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetGymDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetGymDetailsResponse {

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

            interface IGetHatchedEggsResponse {
                success?: (boolean|null);
                pokemon_id?: ((number|Long)[]|null);
                experience_awarded?: (number[]|null);
                candy_awarded?: (number[]|null);
                stardust_awarded?: (number[]|null);
                egg_km_walked?: (number[]|null);
                hatched_pokemon?: (POGOProtos.Data.IPokemonData[]|null);
            }

            class GetHatchedEggsResponse implements IGetHatchedEggsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetHatchedEggsResponse);
                public success: boolean;
                public pokemon_id: (number|Long)[];
                public experience_awarded: number[];
                public candy_awarded: number[];
                public stardust_awarded: number[];
                public egg_km_walked: number[];
                public hatched_pokemon: POGOProtos.Data.IPokemonData[];
                public static encode(message: POGOProtos.Networking.Responses.IGetHatchedEggsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetHatchedEggsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetHatchedEggsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetHatchedEggsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetHoloInventoryResponse {
                success?: (boolean|null);
                inventory_delta?: (POGOProtos.Inventory.IInventoryDelta|null);
            }

            class GetHoloInventoryResponse implements IGetHoloInventoryResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetHoloInventoryResponse);
                public success: boolean;
                public inventory_delta?: (POGOProtos.Inventory.IInventoryDelta|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetHoloInventoryResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetHoloInventoryResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetHoloInventoryResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetHoloInventoryResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetInboxResponse {
                result?: (POGOProtos.Networking.Responses.GetInboxResponse.Result|null);
                inbox?: (POGOProtos.Data.Inbox.IClientInbox|null);
            }

            class GetInboxResponse implements IGetInboxResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetInboxResponse);
                public result: POGOProtos.Networking.Responses.GetInboxResponse.Result;
                public inbox?: (POGOProtos.Data.Inbox.IClientInbox|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetInboxResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetInboxResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetInboxResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetInboxResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetInboxResponse {

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

            interface IGetIncensePokemonResponse {
                result?: (POGOProtos.Networking.Responses.GetIncensePokemonResponse.Result|null);
                pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                latitude?: (number|null);
                longitude?: (number|null);
                encounter_location?: (string|null);
                encounter_id?: (number|Long|null);
                disappear_timestamp_ms?: (number|Long|null);
                pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
            }

            class GetIncensePokemonResponse implements IGetIncensePokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetIncensePokemonResponse);
                public result: POGOProtos.Networking.Responses.GetIncensePokemonResponse.Result;
                public pokemon_id: POGOProtos.Enums.PokemonId;
                public latitude: number;
                public longitude: number;
                public encounter_location: string;
                public encounter_id: (number|Long);
                public disappear_timestamp_ms: (number|Long);
                public pokemon_display?: (POGOProtos.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetIncensePokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetIncensePokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetIncensePokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetIncensePokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetIncensePokemonResponse {

                enum Result {
                    INCENSE_ENCOUNTER_UNKNOWN = 0,
                    INCENSE_ENCOUNTER_AVAILABLE = 1,
                    INCENSE_ENCOUNTER_NOT_AVAILABLE = 2
                }
            }

            interface IGetInventoryResponse {
                success?: (boolean|null);
                inventory_delta?: (POGOProtos.Inventory.IInventoryDelta|null);
            }

            class GetInventoryResponse implements IGetInventoryResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetInventoryResponse);
                public success: boolean;
                public inventory_delta?: (POGOProtos.Inventory.IInventoryDelta|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetInventoryResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetInventoryResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetInventoryResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetInventoryResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetMapObjectsResponse {
                map_cells?: (POGOProtos.Map.IMapCell[]|null);
                status?: (POGOProtos.Map.MapObjectsStatus|null);
                time_of_day?: (POGOProtos.Networking.Responses.GetMapObjectsResponse.TimeOfDay|null);
                client_weather?: (POGOProtos.Map.Weather.IClientWeather[]|null);
            }

            class GetMapObjectsResponse implements IGetMapObjectsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetMapObjectsResponse);
                public map_cells: POGOProtos.Map.IMapCell[];
                public status: POGOProtos.Map.MapObjectsStatus;
                public time_of_day: POGOProtos.Networking.Responses.GetMapObjectsResponse.TimeOfDay;
                public client_weather: POGOProtos.Map.Weather.IClientWeather[];
                public static encode(message: POGOProtos.Networking.Responses.IGetMapObjectsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetMapObjectsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetMapObjectsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetMapObjectsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetMapObjectsResponse {

                enum TimeOfDay {
                    NONE = 0,
                    DAY = 1,
                    NIGHT = 2
                }
            }

            interface IGetNewQuestsResponse {
                status?: (POGOProtos.Networking.Responses.GetNewQuestsResponse.Status|null);
                quests?: (POGOProtos.Data.Quests.IClientQuest[]|null);
                version_changed_quests?: (POGOProtos.Data.Quests.IClientQuest[]|null);
            }

            class GetNewQuestsResponse implements IGetNewQuestsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetNewQuestsResponse);
                public status: POGOProtos.Networking.Responses.GetNewQuestsResponse.Status;
                public quests: POGOProtos.Data.Quests.IClientQuest[];
                public version_changed_quests: POGOProtos.Data.Quests.IClientQuest[];
                public static encode(message: POGOProtos.Networking.Responses.IGetNewQuestsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetNewQuestsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetNewQuestsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetNewQuestsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetNewQuestsResponse {

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

            interface IGetNpcCombatRewardsResponse {
                result?: (POGOProtos.Networking.Responses.GetNpcCombatRewardsResponse.Result|null);
                reward_status?: (POGOProtos.Enums.CombatRewardStatus|null);
                rewards?: (POGOProtos.Inventory.ILoot|null);
                number_rewarded_npc_battles_today?: (number|null);
            }

            class GetNpcCombatRewardsResponse implements IGetNpcCombatRewardsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetNpcCombatRewardsResponse);
                public result: POGOProtos.Networking.Responses.GetNpcCombatRewardsResponse.Result;
                public reward_status: POGOProtos.Enums.CombatRewardStatus;
                public rewards?: (POGOProtos.Inventory.ILoot|null);
                public number_rewarded_npc_battles_today: number;
                public static encode(message: POGOProtos.Networking.Responses.IGetNpcCombatRewardsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetNpcCombatRewardsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetNpcCombatRewardsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetNpcCombatRewardsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetNpcCombatRewardsResponse {

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

            interface IGetPhotobombResponse {
                status?: (POGOProtos.Networking.Responses.GetPhotobombResponse.Status|null);
                pokemon_id?: (POGOProtos.Enums.PokemonId|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.Data.IPokemonDisplay|null);
            }

            class GetPhotobombResponse implements IGetPhotobombResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetPhotobombResponse);
                public status: POGOProtos.Networking.Responses.GetPhotobombResponse.Status;
                public pokemon_id: POGOProtos.Enums.PokemonId;
                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.Data.IPokemonDisplay|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetPhotobombResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetPhotobombResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetPhotobombResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetPhotobombResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetPhotobombResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    PHOTOBOMB_NOT_AVAILABLE = 2,
                    ENCOUNTER_ALREADY_COMPLETED = 3,
                    ERROR_UNKNOWN = 4
                }
            }

            interface IGetPlayerDayResponse {
                result?: (POGOProtos.Networking.Responses.GetPlayerDayResponse.Result|null);
                day?: (number|Long|null);
            }

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

            namespace GetPlayerDayResponse {

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

            interface IGetPlayerProfileResponse {
                result?: (POGOProtos.Networking.Responses.GetPlayerProfileResponse.Result|null);
                start_time?: (number|Long|null);
                badges?: (POGOProtos.Data.IPlayerBadge[]|null);
                gym_badges?: (POGOProtos.Networking.Responses.GetPlayerProfileResponse.IGymBadges|null);
            }

            class GetPlayerProfileResponse implements IGetPlayerProfileResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetPlayerProfileResponse);
                public result: POGOProtos.Networking.Responses.GetPlayerProfileResponse.Result;
                public start_time: (number|Long);
                public badges: POGOProtos.Data.IPlayerBadge[];
                public gym_badges?: (POGOProtos.Networking.Responses.GetPlayerProfileResponse.IGymBadges|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetPlayerProfileResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetPlayerProfileResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetPlayerProfileResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetPlayerProfileResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetPlayerProfileResponse {

                interface IGymBadges {
                    gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge[]|null);
                    total?: (number|null);
                }

                class GymBadges implements IGymBadges {
                    constructor(properties?: POGOProtos.Networking.Responses.GetPlayerProfileResponse.IGymBadges);
                    public gym_badge: POGOProtos.Data.Badge.IAwardedGymBadge[];
                    public total: number;
                    public static encode(message: POGOProtos.Networking.Responses.GetPlayerProfileResponse.IGymBadges, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetPlayerProfileResponse.GymBadges;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetPlayerProfileResponse.GymBadges;
                    public static toObject(message: POGOProtos.Networking.Responses.GetPlayerProfileResponse.GymBadges, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

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

            interface IGetPlayerResponse {
                success?: (boolean|null);
                player_data?: (POGOProtos.Data.IPlayerData|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);
            }

            class GetPlayerResponse implements IGetPlayerResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetPlayerResponse);
                public success: boolean;
                public player_data?: (POGOProtos.Data.IPlayerData|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 static encode(message: POGOProtos.Networking.Responses.IGetPlayerResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetPlayerResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetPlayerResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetPlayerResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGetQuestDetailsResponse {
                status?: (POGOProtos.Networking.Responses.GetQuestDetailsResponse.Status|null);
                quests?: (POGOProtos.Data.Quests.IClientQuest[]|null);
            }

            class GetQuestDetailsResponse implements IGetQuestDetailsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetQuestDetailsResponse);
                public status: POGOProtos.Networking.Responses.GetQuestDetailsResponse.Status;
                public quests: POGOProtos.Data.Quests.IClientQuest[];
                public static encode(message: POGOProtos.Networking.Responses.IGetQuestDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetQuestDetailsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetQuestDetailsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetQuestDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetQuestDetailsResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_QUEST_NOT_FOUND = 2,
                    ERROR_INVALID_DISPLAY = 3
                }
            }

            interface IGetRaidDetailsResponse {
                lobby?: (POGOProtos.Data.Raid.ILobby|null);
                raid_battle?: (POGOProtos.Data.Battle.IBattle|null);
                player_can_join_lobby?: (boolean|null);
                result?: (POGOProtos.Networking.Responses.GetRaidDetailsResponse.Result|null);
                raid_info?: (POGOProtos.Data.Raid.IRaidInfo|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);
            }

            class GetRaidDetailsResponse implements IGetRaidDetailsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetRaidDetailsResponse);
                public lobby?: (POGOProtos.Data.Raid.ILobby|null);
                public raid_battle?: (POGOProtos.Data.Battle.IBattle|null);
                public player_can_join_lobby: boolean;
                public result: POGOProtos.Networking.Responses.GetRaidDetailsResponse.Result;
                public raid_info?: (POGOProtos.Data.Raid.IRaidInfo|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 static encode(message: POGOProtos.Networking.Responses.IGetRaidDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetRaidDetailsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetRaidDetailsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetRaidDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetRaidDetailsResponse {

                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 IGetSignedGmapUrlResponse {
                result?: (POGOProtos.Networking.Responses.GetSignedGmapUrlResponse.Result|null);
                signed_url?: (string|null);
            }

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

            namespace GetSignedGmapUrlResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_NOT_VALID = 2,
                    ERROR_RATE_LIMITED = 3,
                    ERROR_MISSING_INPUT = 4,
                    ERROR_UNKNOWN = 5
                }
            }

            interface IGetTradingResponse {
                result?: (POGOProtos.Networking.Responses.GetTradingResponse.Result|null);
                trading?: (POGOProtos.Data.Trading.ITrading|null);
            }

            class GetTradingResponse implements IGetTradingResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetTradingResponse);
                public result: POGOProtos.Networking.Responses.GetTradingResponse.Result;
                public trading?: (POGOProtos.Data.Trading.ITrading|null);
                public static encode(message: POGOProtos.Networking.Responses.IGetTradingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetTradingResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetTradingResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetTradingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GetTradingResponse {

                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 IGetTutorialEggActionResponse {
                result?: (POGOProtos.Networking.Responses.GetTutorialEggActionResponse.Result|null);
            }

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

            namespace GetTutorialEggActionResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_ALREADY_HAS_TUTORIAL_EGG = 2,
                    ERROR_FAILED_TO_ADD_EGG = 3,
                    ERROR_NOT_V2_FLOW = 4
                }
            }

            interface IGetUploadUrlResponse {
                status?: (POGOProtos.Networking.Responses.GetUploadUrlResponse.Status|null);
                signed_url?: (string|null);
                supporting_image_signed_url?: (string|null);
            }

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

            namespace GetUploadUrlResponse {

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

            interface IGiftDetailsResponse {
                result?: (POGOProtos.Networking.Responses.GiftDetailsResponse.Result|null);
                gift_boxes?: (POGOProtos.Data.Gift.IGiftBoxDetails[]|null);
            }

            class GiftDetailsResponse implements IGiftDetailsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGiftDetailsResponse);
                public result: POGOProtos.Networking.Responses.GiftDetailsResponse.Result;
                public gift_boxes: POGOProtos.Data.Gift.IGiftBoxDetails[];
                public static encode(message: POGOProtos.Networking.Responses.IGiftDetailsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GiftDetailsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GiftDetailsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GiftDetailsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GiftDetailsResponse {

                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 IGymBattleAttackResponse {
                result?: (POGOProtos.Networking.Responses.GymBattleAttackResponse.Result|null);
                battle_update?: (POGOProtos.Data.Battle.IBattleUpdate|null);
                gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
            }

            class GymBattleAttackResponse implements IGymBattleAttackResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGymBattleAttackResponse);
                public result: POGOProtos.Networking.Responses.GymBattleAttackResponse.Result;
                public battle_update?: (POGOProtos.Data.Battle.IBattleUpdate|null);
                public gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                public static encode(message: POGOProtos.Networking.Responses.IGymBattleAttackResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GymBattleAttackResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GymBattleAttackResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GymBattleAttackResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymBattleAttackResponse {

                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 IGymDeployResponse {
                result?: (POGOProtos.Networking.Responses.GymDeployResponse.Result|null);
                gym_status_and_defenders?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                cooldown_complete_timestamp_ms?: (number|Long|null);
            }

            class GymDeployResponse implements IGymDeployResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGymDeployResponse);
                public result: POGOProtos.Networking.Responses.GymDeployResponse.Result;
                public gym_status_and_defenders?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                public awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                public cooldown_complete_timestamp_ms: (number|Long);
                public static encode(message: POGOProtos.Networking.Responses.IGymDeployResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GymDeployResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GymDeployResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GymDeployResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymDeployResponse {

                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
                }
            }

            interface IGymFeedPokemonResponse {
                result?: (POGOProtos.Networking.Responses.GymFeedPokemonResponse.Result|null);
                gym_status_and_defenders?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                stardust_awarded?: (number|null);
                xp_awarded?: (number|null);
                num_candy_awarded?: (number|null);
                family_candy_id?: (POGOProtos.Enums.PokemonFamilyId|null);
                cooldown_complete?: (number|Long|null);
            }

            class GymFeedPokemonResponse implements IGymFeedPokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGymFeedPokemonResponse);
                public result: POGOProtos.Networking.Responses.GymFeedPokemonResponse.Result;
                public gym_status_and_defenders?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                public awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                public stardust_awarded: number;
                public xp_awarded: number;
                public num_candy_awarded: number;
                public family_candy_id: POGOProtos.Enums.PokemonFamilyId;
                public cooldown_complete: (number|Long);
                public static encode(message: POGOProtos.Networking.Responses.IGymFeedPokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GymFeedPokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GymFeedPokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GymFeedPokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymFeedPokemonResponse {

                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 IGymGetInfoResponse {
                gym_status_and_defenders?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                name?: (string|null);
                url?: (string|null);
                result?: (POGOProtos.Networking.Responses.GymGetInfoResponse.Result|null);
                description?: (string|null);
                secondary_url?: (string|null);
                awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                checkin_image_url?: (string|null);
                event_info?: (POGOProtos.Data.Raid.IEventInfo|null);
                display_weather?: (POGOProtos.Map.Weather.IDisplayWeather|null);
            }

            class GymGetInfoResponse implements IGymGetInfoResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGymGetInfoResponse);
                public gym_status_and_defenders?: (POGOProtos.Data.Gym.IGymStatusAndDefenders|null);
                public name: string;
                public url: string;
                public result: POGOProtos.Networking.Responses.GymGetInfoResponse.Result;
                public description: string;
                public secondary_url: string;
                public awarded_gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge|null);
                public checkin_image_url: string;
                public event_info?: (POGOProtos.Data.Raid.IEventInfo|null);
                public display_weather?: (POGOProtos.Map.Weather.IDisplayWeather|null);
                public static encode(message: POGOProtos.Networking.Responses.IGymGetInfoResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GymGetInfoResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GymGetInfoResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GymGetInfoResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymGetInfoResponse {

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

            interface IGymStartSessionResponse {
                result?: (POGOProtos.Networking.Responses.GymStartSessionResponse.Result|null);
                battle?: (POGOProtos.Data.Battle.IBattle|null);
            }

            class GymStartSessionResponse implements IGymStartSessionResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGymStartSessionResponse);
                public result: POGOProtos.Networking.Responses.GymStartSessionResponse.Result;
                public battle?: (POGOProtos.Data.Battle.IBattle|null);
                public static encode(message: POGOProtos.Networking.Responses.IGymStartSessionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GymStartSessionResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GymStartSessionResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GymStartSessionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace GymStartSessionResponse {

                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 IIncenseEncounterResponse {
                result?: (POGOProtos.Networking.Responses.IncenseEncounterResponse.Result|null);
                pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                active_item?: (POGOProtos.Inventory.Item.ItemId|null);
                arplus_attempts_until_flee?: (number|null);
            }

            class IncenseEncounterResponse implements IIncenseEncounterResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IIncenseEncounterResponse);
                public result: POGOProtos.Networking.Responses.IncenseEncounterResponse.Result;
                public pokemon_data?: (POGOProtos.Data.IPokemonData|null);
                public capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public active_item: POGOProtos.Inventory.Item.ItemId;
                public arplus_attempts_until_flee: number;
                public static encode(message: POGOProtos.Networking.Responses.IIncenseEncounterResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.IncenseEncounterResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.IncenseEncounterResponse;
                public static toObject(message: POGOProtos.Networking.Responses.IncenseEncounterResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace IncenseEncounterResponse {

                enum Result {
                    INCENSE_ENCOUNTER_UNKNOWN = 0,
                    INCENSE_ENCOUNTER_SUCCESS = 1,
                    INCENSE_ENCOUNTER_NOT_AVAILABLE = 2,
                    POKEMON_INVENTORY_FULL = 3
                }
            }

            interface IJoinLobbyResponse {
                result?: (POGOProtos.Networking.Responses.JoinLobbyResponse.Result|null);
                lobby?: (POGOProtos.Data.Raid.ILobby|null);
            }

            class JoinLobbyResponse implements IJoinLobbyResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IJoinLobbyResponse);
                public result: POGOProtos.Networking.Responses.JoinLobbyResponse.Result;
                public lobby?: (POGOProtos.Data.Raid.ILobby|null);
                public static encode(message: POGOProtos.Networking.Responses.IJoinLobbyResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.JoinLobbyResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.JoinLobbyResponse;
                public static toObject(message: POGOProtos.Networking.Responses.JoinLobbyResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace JoinLobbyResponse {

                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
                }
            }

            interface ILeaveLobbyResponse {
                result?: (POGOProtos.Networking.Responses.LeaveLobbyResponse.Result|null);
                lobby?: (POGOProtos.Data.Raid.ILobby|null);
            }

            class LeaveLobbyResponse implements ILeaveLobbyResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ILeaveLobbyResponse);
                public result: POGOProtos.Networking.Responses.LeaveLobbyResponse.Result;
                public lobby?: (POGOProtos.Data.Raid.ILobby|null);
                public static encode(message: POGOProtos.Networking.Responses.ILeaveLobbyResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.LeaveLobbyResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.LeaveLobbyResponse;
                public static toObject(message: POGOProtos.Networking.Responses.LeaveLobbyResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace LeaveLobbyResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_RAID_UNAVAILABLE = 2,
                    ERROR_LOBBY_NOT_FOUND = 3
                }
            }

            interface ILevelUpRewardsResponse {
                result?: (POGOProtos.Networking.Responses.LevelUpRewardsResponse.Result|null);
                items_awarded?: (POGOProtos.Inventory.Item.IItemAward[]|null);
                items_unlocked?: (POGOProtos.Inventory.Item.ItemId[]|null);
                avatar_template_ids?: (string[]|null);
            }

            class LevelUpRewardsResponse implements ILevelUpRewardsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ILevelUpRewardsResponse);
                public result: POGOProtos.Networking.Responses.LevelUpRewardsResponse.Result;
                public items_awarded: POGOProtos.Inventory.Item.IItemAward[];
                public items_unlocked: POGOProtos.Inventory.Item.ItemId[];
                public avatar_template_ids: string[];
                public static encode(message: POGOProtos.Networking.Responses.ILevelUpRewardsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.LevelUpRewardsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.LevelUpRewardsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.LevelUpRewardsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace LevelUpRewardsResponse {

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

            interface IListAvatarCustomizationsResponse {
                result?: (POGOProtos.Networking.Responses.ListAvatarCustomizationsResponse.Result|null);
                avatar_customizations?: (POGOProtos.Data.Avatar.IAvatarCustomization[]|null);
            }

            class ListAvatarCustomizationsResponse implements IListAvatarCustomizationsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IListAvatarCustomizationsResponse);
                public result: POGOProtos.Networking.Responses.ListAvatarCustomizationsResponse.Result;
                public avatar_customizations: POGOProtos.Data.Avatar.IAvatarCustomization[];
                public static encode(message: POGOProtos.Networking.Responses.IListAvatarCustomizationsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.ListAvatarCustomizationsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.ListAvatarCustomizationsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.ListAvatarCustomizationsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace ListAvatarCustomizationsResponse {

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

            interface IListGymBadgesResponse {
                gym_badge?: (POGOProtos.Data.Badge.IAwardedGymBadge[]|null);
            }

            class ListGymBadgesResponse implements IListGymBadgesResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IListGymBadgesResponse);
                public gym_badge: POGOProtos.Data.Badge.IAwardedGymBadge[];
                public static encode(message: POGOProtos.Networking.Responses.IListGymBadgesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.ListGymBadgesResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.ListGymBadgesResponse;
                public static toObject(message: POGOProtos.Networking.Responses.ListGymBadgesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IMarkReadNewsArticleResponse {
                result?: (POGOProtos.Networking.Responses.MarkReadNewsArticleResponse.Result|null);
            }

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

            namespace MarkReadNewsArticleResponse {

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

            interface IMarkTutorialCompleteResponse {
                success?: (boolean|null);
                player_data?: (POGOProtos.Data.IPlayerData|null);
            }

            class MarkTutorialCompleteResponse implements IMarkTutorialCompleteResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IMarkTutorialCompleteResponse);
                public success: boolean;
                public player_data?: (POGOProtos.Data.IPlayerData|null);
                public static encode(message: POGOProtos.Networking.Responses.IMarkTutorialCompleteResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.MarkTutorialCompleteResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.MarkTutorialCompleteResponse;
                public static toObject(message: POGOProtos.Networking.Responses.MarkTutorialCompleteResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface INicknamePokemonResponse {
                result?: (POGOProtos.Networking.Responses.NicknamePokemonResponse.Result|null);
            }

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

            namespace NicknamePokemonResponse {

                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 IOpenCombatChallengeResponse {
                result?: (POGOProtos.Networking.Responses.OpenCombatChallengeResponse.Result|null);
                challenge?: (POGOProtos.Data.Combat.ICombatChallenge|null);
            }

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

            namespace OpenCombatChallengeResponse {

                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 IOpenCombatSessionResponse {
                result?: (POGOProtos.Networking.Responses.OpenCombatSessionResponse.Result|null);
                combat?: (POGOProtos.Data.Combat.ICombat|null);
            }

            class OpenCombatSessionResponse implements IOpenCombatSessionResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IOpenCombatSessionResponse);
                public result: POGOProtos.Networking.Responses.OpenCombatSessionResponse.Result;
                public combat?: (POGOProtos.Data.Combat.ICombat|null);
                public static encode(message: POGOProtos.Networking.Responses.IOpenCombatSessionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.OpenCombatSessionResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.OpenCombatSessionResponse;
                public static toObject(message: POGOProtos.Networking.Responses.OpenCombatSessionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace OpenCombatSessionResponse {

                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
                }
            }

            interface IOpenGiftResponse {
                result?: (POGOProtos.Networking.Responses.OpenGiftResponse.Result|null);
                items?: (POGOProtos.Inventory.ILoot|null);
                egg_pokemon?: (POGOProtos.Data.IPokemonData|null);
                updated_friendship_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                friend_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
            }

            class OpenGiftResponse implements IOpenGiftResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IOpenGiftResponse);
                public result: POGOProtos.Networking.Responses.OpenGiftResponse.Result;
                public items?: (POGOProtos.Inventory.ILoot|null);
                public egg_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public updated_friendship_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                public friend_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public static encode(message: POGOProtos.Networking.Responses.IOpenGiftResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.OpenGiftResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.OpenGiftResponse;
                public static toObject(message: POGOProtos.Networking.Responses.OpenGiftResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace OpenGiftResponse {

                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 IOpenNpcCombatSessionResponse {
                result?: (POGOProtos.Networking.Responses.OpenNpcCombatSessionResponse.Result|null);
                combat?: (POGOProtos.Data.Combat.ICombat|null);
            }

            class OpenNpcCombatSessionResponse implements IOpenNpcCombatSessionResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IOpenNpcCombatSessionResponse);
                public result: POGOProtos.Networking.Responses.OpenNpcCombatSessionResponse.Result;
                public combat?: (POGOProtos.Data.Combat.ICombat|null);
                public static encode(message: POGOProtos.Networking.Responses.IOpenNpcCombatSessionResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.OpenNpcCombatSessionResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.OpenNpcCombatSessionResponse;
                public static toObject(message: POGOProtos.Networking.Responses.OpenNpcCombatSessionResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace OpenNpcCombatSessionResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_BELOW_MINIMUM_LEVEL = 2,
                    ERROR_POKEMON_LINEUP_INELIGIBLE_FOR_LEAGUE = 3,
                    ERROR_ACCESS_DENIED = 4
                }
            }

            interface IOpenTradingResponse {
                result?: (POGOProtos.Networking.Responses.OpenTradingResponse.Result|null);
                trading?: (POGOProtos.Data.Trading.ITrading|null);
            }

            class OpenTradingResponse implements IOpenTradingResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IOpenTradingResponse);
                public result: POGOProtos.Networking.Responses.OpenTradingResponse.Result;
                public trading?: (POGOProtos.Data.Trading.ITrading|null);
                public static encode(message: POGOProtos.Networking.Responses.IOpenTradingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.OpenTradingResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.OpenTradingResponse;
                public static toObject(message: POGOProtos.Networking.Responses.OpenTradingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace OpenTradingResponse {

                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 IRegisterPushNotificationResponse {
                result?: (POGOProtos.Networking.Responses.RegisterPushNotificationResponse.Result|null);
            }

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

            namespace RegisterPushNotificationResponse {

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

            interface IUpdateNotificationStatusResponse {
                notification_ids?: (string[]|null);
                create_timestamp_ms?: ((number|Long)[]|null);
                state?: (POGOProtos.Enums.NotificationState|null);
            }

            class UpdateNotificationStatusResponse implements IUpdateNotificationStatusResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUpdateNotificationStatusResponse);
                public notification_ids: string[];
                public create_timestamp_ms: (number|Long)[];
                public state: POGOProtos.Enums.NotificationState;
                public static encode(message: POGOProtos.Networking.Responses.IUpdateNotificationStatusResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UpdateNotificationStatusResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UpdateNotificationStatusResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UpdateNotificationStatusResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOptOutPushNotificationCategoryResponse {
            }

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

            interface IRedeemPasscodeResponse {
                result?: (POGOProtos.Networking.Responses.RedeemPasscodeResponse.Result|null);
                acquired_item?: (POGOProtos.Networking.Responses.RedeemPasscodeResponse.IAcquiredItem[]|null);
                acquired_items_proto?: (Uint8Array|null);
                passcode?: (string|null);
            }

            class RedeemPasscodeResponse implements IRedeemPasscodeResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IRedeemPasscodeResponse);
                public result: POGOProtos.Networking.Responses.RedeemPasscodeResponse.Result;
                public acquired_item: POGOProtos.Networking.Responses.RedeemPasscodeResponse.IAcquiredItem[];
                public acquired_items_proto: Uint8Array;
                public passcode: string;
                public static encode(message: POGOProtos.Networking.Responses.IRedeemPasscodeResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.RedeemPasscodeResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.RedeemPasscodeResponse;
                public static toObject(message: POGOProtos.Networking.Responses.RedeemPasscodeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace RedeemPasscodeResponse {

                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.Networking.Responses.RedeemPasscodeResponse.IAcquiredItem);
                    public item: string;
                    public count: (number|Long);
                    public static encode(message: POGOProtos.Networking.Responses.RedeemPasscodeResponse.IAcquiredItem, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.RedeemPasscodeResponse.AcquiredItem;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.RedeemPasscodeResponse.AcquiredItem;
                    public static toObject(message: POGOProtos.Networking.Responses.RedeemPasscodeResponse.AcquiredItem, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IAddNewPoiResponse {
                status?: (POGOProtos.Networking.Responses.AddNewPoiResponse.Status|null);
                message?: (string[]|null);
            }

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

            namespace AddNewPoiResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    FAILURE = 2,
                    INTERNAL_ERROR = 3,
                    TOO_MANY_RECENT_SUBMISSIONS = 4,
                    INVALID_INPUT = 5
                }
            }

            interface IProxySocialActionResponse {
                status?: (POGOProtos.Networking.Responses.ProxySocialActionResponse.Status|null);
                assigned_host?: (string|null);
                payload?: (Uint8Array|null);
            }

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

            namespace ProxySocialActionResponse {

                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 IProxySocialSideChannelActionResponse {
                status?: (POGOProtos.Networking.Responses.ProxySocialSideChannelActionResponse.Status|null);
                assigned_host?: (string|null);
                payload?: (Uint8Array|null);
            }

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

            namespace ProxySocialSideChannelActionResponse {

                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 IGetAvailableSubmissionsResponse {
                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);
            }

            class GetAvailableSubmissionsResponse implements IGetAvailableSubmissionsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IGetAvailableSubmissionsResponse);
                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 static encode(message: POGOProtos.Networking.Responses.IGetAvailableSubmissionsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.GetAvailableSubmissionsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.GetAvailableSubmissionsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.GetAvailableSubmissionsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPushNotificationRegistryResponse {
                result?: (POGOProtos.Networking.Responses.PushNotificationRegistryResponse.Result|null);
            }

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

            namespace PushNotificationRegistryResponse {

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

            interface IAddLoginActionResponse {
                success?: (boolean|null);
                login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                status?: (POGOProtos.Networking.Responses.AddLoginActionResponse.Status|null);
            }

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

            namespace AddLoginActionResponse {

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

            interface IRemoveLoginActionResponse {
                success?: (boolean|null);
                login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                status?: (POGOProtos.Networking.Responses.RemoveLoginActionResponse.Status|null);
            }

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

            namespace RemoveLoginActionResponse {

                enum Status {
                    UNSET = 0,
                    LOGIN_NOT_REMOVABLE = 1
                }
            }

            interface ISubmitNewPoiResponse {
                status?: (POGOProtos.Networking.Responses.SubmitNewPoiResponse.Status|null);
            }

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

            namespace SubmitNewPoiResponse {

                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 IUploadPoiPhotoByUrlResponse {
                status?: (POGOProtos.Networking.Responses.UploadPoiPhotoByUrlResponse.Result|null);
            }

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

            namespace UploadPoiPhotoByUrlResponse {

                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 IPingResponse {
                user_info?: (string|null);
                server_info?: (string|null);
                random_response_bytes?: (string|null);
                return_value?: (string|null);
            }

            class PingResponse implements IPingResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IPingResponse);
                public user_info: string;
                public server_info: string;
                public random_response_bytes: string;
                public return_value: string;
                public static encode(message: POGOProtos.Networking.Responses.IPingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.PingResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.PingResponse;
                public static toObject(message: POGOProtos.Networking.Responses.PingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IReplaceLoginActionResponse {
                success?: (boolean|null);
                login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
                status?: (POGOProtos.Networking.Responses.ReplaceLoginActionResponse.Status|null);
            }

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

            namespace ReplaceLoginActionResponse {

                enum Status {
                    UNSET = 0,
                    AUTH_FAILURE = 1,
                    LOGIN_TAKEN = 2,
                    LOGIN_ALREADY_HAVE = 3,
                    LOGIN_NOT_REPLACEABLE = 4
                }
            }

            interface IListLoginActionResponse {
                success?: (boolean|null);
                login_detail?: (POGOProtos.Data.Login.ILoginDetail[]|null);
            }

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

            interface IPurchaseSkuResponse {
                result?: (POGOProtos.Networking.Responses.PurchaseSkuResponse.Status|null);
                added_inventory_item?: (Uint8Array[]|null);
                currency_update?: (POGOProtos.Data.Store.ICurrencyUpdate[]|null);
            }

            class PurchaseSkuResponse implements IPurchaseSkuResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IPurchaseSkuResponse);
                public result: POGOProtos.Networking.Responses.PurchaseSkuResponse.Status;
                public added_inventory_item: Uint8Array[];
                public currency_update: POGOProtos.Data.Store.ICurrencyUpdate[];
                public static encode(message: POGOProtos.Networking.Responses.IPurchaseSkuResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.PurchaseSkuResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.PurchaseSkuResponse;
                public static toObject(message: POGOProtos.Networking.Responses.PurchaseSkuResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PurchaseSkuResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    FAILURE = 2,
                    BALANCE_TOO_LOW = 3,
                    SKU_NOT_AVAILABLE = 4,
                    OVER_INVENTORY_LIMIT = 5
                }
            }

            interface IQuestEncounterResponse {
                result?: (POGOProtos.Networking.Responses.QuestEncounterResponse.Result|null);
                pokemon?: (POGOProtos.Map.Pokemon.IWildPokemon|null);
                capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                active_item?: (POGOProtos.Inventory.Item.ItemId|null);
            }

            class QuestEncounterResponse implements IQuestEncounterResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IQuestEncounterResponse);
                public result: POGOProtos.Networking.Responses.QuestEncounterResponse.Result;
                public pokemon?: (POGOProtos.Map.Pokemon.IWildPokemon|null);
                public capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public active_item: POGOProtos.Inventory.Item.ItemId;
                public static encode(message: POGOProtos.Networking.Responses.IQuestEncounterResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.QuestEncounterResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.QuestEncounterResponse;
                public static toObject(message: POGOProtos.Networking.Responses.QuestEncounterResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace QuestEncounterResponse {

                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 IQuitCombatResponse {
                result?: (POGOProtos.Networking.Responses.QuitCombatResponse.Result|null);
                combat?: (POGOProtos.Data.Combat.ICombat|null);
            }

            class QuitCombatResponse implements IQuitCombatResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IQuitCombatResponse);
                public result: POGOProtos.Networking.Responses.QuitCombatResponse.Result;
                public combat?: (POGOProtos.Data.Combat.ICombat|null);
                public static encode(message: POGOProtos.Networking.Responses.IQuitCombatResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.QuitCombatResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.QuitCombatResponse;
                public static toObject(message: POGOProtos.Networking.Responses.QuitCombatResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace QuitCombatResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_COMBAT_NOT_FOUND = 2,
                    ERROR_INVALID_COMBAT_STATE = 3,
                    ERROR_PLAYER_NOT_IN_COMBAT = 4
                }
            }

            interface IReassignPlayerResponse {
                result?: (POGOProtos.Networking.Responses.ReassignPlayerResponse.Result|null);
                reassigned_instance?: (number|null);
            }

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

            namespace ReassignPlayerResponse {

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

            interface IRecycleInventoryItemResponse {
                result?: (POGOProtos.Networking.Responses.RecycleInventoryItemResponse.Result|null);
                new_count?: (number|null);
            }

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

            namespace RecycleInventoryItemResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_NOT_ENOUGH_COPIES = 2,
                    ERROR_CANNOT_RECYCLE_INCUBATORS = 3
                }
            }

            interface IRedeemGoogleReceiptResponse {
                result?: (POGOProtos.Networking.Responses.RedeemGoogleReceiptResponse.Status|null);
                transaction_token?: (string|null);
            }

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

            namespace RedeemGoogleReceiptResponse {

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

            interface IRegisterBackgroundDeviceResponse {
                status?: (POGOProtos.Networking.Responses.RegisterBackgroundDeviceResponse.Status|null);
                token?: (POGOProtos.Data.IBackgroundToken|null);
            }

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

            namespace RegisterBackgroundDeviceResponse {

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

            interface IReleasePokemonResponse {
                result?: (POGOProtos.Networking.Responses.ReleasePokemonResponse.Result|null);
                candy_awarded?: (number|null);
            }

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

            namespace ReleasePokemonResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    POKEMON_DEPLOYED = 2,
                    FAILED = 3,
                    ERROR_POKEMON_IS_EGG = 4,
                    ERROR_POKEMON_IS_BUDDY = 5
                }
            }

            interface IRemoveQuestResponse {
                status?: (POGOProtos.Networking.Responses.RemoveQuestResponse.Status|null);
            }

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

            namespace RemoveQuestResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_QUEST_NOT_FOUND = 2,
                    ERROR_STORY_QUEST_NOT_REMOVABLE = 3
                }
            }

            interface IRequestGeofenceUpdatesResponse {
                geofence?: (POGOProtos.Data.Geofence.IGeofenceMetadata[]|null);
            }

            class RequestGeofenceUpdatesResponse implements IRequestGeofenceUpdatesResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IRequestGeofenceUpdatesResponse);
                public geofence: POGOProtos.Data.Geofence.IGeofenceMetadata[];
                public static encode(message: POGOProtos.Networking.Responses.IRequestGeofenceUpdatesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.RequestGeofenceUpdatesResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.RequestGeofenceUpdatesResponse;
                public static toObject(message: POGOProtos.Networking.Responses.RequestGeofenceUpdatesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISaveCombatPlayerPreferencesResponse {
                result?: (POGOProtos.Networking.Responses.SaveCombatPlayerPreferencesResponse.Result|null);
            }

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

            namespace SaveCombatPlayerPreferencesResponse {

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

            interface ISavePlayerSnapshotResponse {
                result?: (POGOProtos.Networking.Responses.SavePlayerSnapshotResponse.Result|null);
            }

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

            namespace SavePlayerSnapshotResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    TOO_SOON_TO_UPDATE = 2,
                    ERROR_FAILED_TO_UPDATE = 3,
                    ERROR_REQUEST_TIMED_OUT = 4
                }
            }

            interface ISaveSocialPlayerSettingsResponse {
                result?: (POGOProtos.Networking.Responses.SaveSocialPlayerSettingsResponse.Result|null);
            }

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

            namespace SaveSocialPlayerSettingsResponse {

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

            interface ISendGiftResponse {
                result?: (POGOProtos.Networking.Responses.SendGiftResponse.Result|null);
                awarded_xp?: (number|null);
            }

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

            namespace SendGiftResponse {

                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
                }
            }

            interface ISendProbeResponse {
                result?: (POGOProtos.Networking.Responses.SendProbeResponse.Result|null);
                id?: (string|null);
                server_timestamp_ms?: (number|Long|null);
            }

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

            namespace SendProbeResponse {

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

            interface ISetAvatarItemAsViewedResponse {
                result?: (POGOProtos.Networking.Responses.SetAvatarItemAsViewedResponse.Result|null);
            }

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

            namespace SetAvatarItemAsViewedResponse {

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

            interface ISetAvatarResponse {
                status?: (POGOProtos.Networking.Responses.SetAvatarResponse.Status|null);
                player_data?: (POGOProtos.Data.IPlayerData|null);
            }

            class SetAvatarResponse implements ISetAvatarResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISetAvatarResponse);
                public status: POGOProtos.Networking.Responses.SetAvatarResponse.Status;
                public player_data?: (POGOProtos.Data.IPlayerData|null);
                public static encode(message: POGOProtos.Networking.Responses.ISetAvatarResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SetAvatarResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SetAvatarResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SetAvatarResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SetAvatarResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    AVATAR_ALREADY_SET = 2,
                    FAILURE = 3,
                    SLOT_NOT_ALLOWED = 4,
                    ITEM_NOT_OWNED = 5,
                    INVALID_AVATAR_TYPE = 6
                }
            }

            interface ISetBuddyPokemonResponse {
                result?: (POGOProtos.Networking.Responses.SetBuddyPokemonResponse.Result|null);
                updated_buddy?: (POGOProtos.Data.IBuddyPokemon|null);
            }

            class SetBuddyPokemonResponse implements ISetBuddyPokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISetBuddyPokemonResponse);
                public result: POGOProtos.Networking.Responses.SetBuddyPokemonResponse.Result;
                public updated_buddy?: (POGOProtos.Data.IBuddyPokemon|null);
                public static encode(message: POGOProtos.Networking.Responses.ISetBuddyPokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SetBuddyPokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SetBuddyPokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SetBuddyPokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SetBuddyPokemonResponse {

                enum Result {
                    UNEST = 0,
                    SUCCESS = 1,
                    ERROR_POKEMON_DEPLOYED = 2,
                    ERROR_POKEMON_NOT_OWNED = 3,
                    ERROR_POKEMON_IS_EGG = 4,
                    ERROR_INVALID_POKEMON = 5
                }
            }

            interface ISetContactSettingsResponse {
                status?: (POGOProtos.Networking.Responses.SetContactSettingsResponse.Status|null);
                player_data?: (POGOProtos.Data.IPlayerData|null);
            }

            class SetContactSettingsResponse implements ISetContactSettingsResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISetContactSettingsResponse);
                public status: POGOProtos.Networking.Responses.SetContactSettingsResponse.Status;
                public player_data?: (POGOProtos.Data.IPlayerData|null);
                public static encode(message: POGOProtos.Networking.Responses.ISetContactSettingsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SetContactSettingsResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SetContactSettingsResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SetContactSettingsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SetContactSettingsResponse {

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

            interface ISetFavoritePokemonResponse {
                result?: (POGOProtos.Networking.Responses.SetFavoritePokemonResponse.Result|null);
            }

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

            namespace SetFavoritePokemonResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_POKEMON_NOT_FOUND = 2,
                    ERROR_POKEMON_IS_EGG = 3
                }
            }

            interface ISetFriendNicknameResponse {
                result?: (POGOProtos.Networking.Responses.SetFriendNicknameResponse.Result|null);
            }

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

            namespace SetFriendNicknameResponse {

                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 ISetInGameCurrencyExchangeRateResponse {
                status?: (POGOProtos.Networking.Responses.SetInGameCurrencyExchangeRateResponse.Status|null);
            }

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

            namespace SetInGameCurrencyExchangeRateResponse {

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

            interface ISetLobbyPokemonResponse {
                result?: (POGOProtos.Networking.Responses.SetLobbyPokemonResponse.Result|null);
                lobby?: (POGOProtos.Data.Raid.ILobby|null);
            }

            class SetLobbyPokemonResponse implements ISetLobbyPokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISetLobbyPokemonResponse);
                public result: POGOProtos.Networking.Responses.SetLobbyPokemonResponse.Result;
                public lobby?: (POGOProtos.Data.Raid.ILobby|null);
                public static encode(message: POGOProtos.Networking.Responses.ISetLobbyPokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SetLobbyPokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SetLobbyPokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SetLobbyPokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SetLobbyPokemonResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_LOBBY_NOT_FOUND = 2,
                    ERROR_RAID_UNAVAILABLE = 3,
                    ERROR_INVALID_POKEMON = 4
                }
            }

            interface ISetLobbyVisibilityResponse {
                result?: (POGOProtos.Networking.Responses.SetLobbyVisibilityResponse.Result|null);
                lobby?: (POGOProtos.Data.Raid.ILobby|null);
            }

            class SetLobbyVisibilityResponse implements ISetLobbyVisibilityResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISetLobbyVisibilityResponse);
                public result: POGOProtos.Networking.Responses.SetLobbyVisibilityResponse.Result;
                public lobby?: (POGOProtos.Data.Raid.ILobby|null);
                public static encode(message: POGOProtos.Networking.Responses.ISetLobbyVisibilityResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SetLobbyVisibilityResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SetLobbyVisibilityResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SetLobbyVisibilityResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SetLobbyVisibilityResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_NOT_LOBBY_CREATOR = 2,
                    ERROR_LOBBY_NOT_FOUND = 3,
                    ERROR_RAID_UNAVAILABLE = 4
                }
            }

            interface ISetPlayerTeamResponse {
                status?: (POGOProtos.Networking.Responses.SetPlayerTeamResponse.Status|null);
                player_data?: (POGOProtos.Data.IPlayerData|null);
            }

            class SetPlayerTeamResponse implements ISetPlayerTeamResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISetPlayerTeamResponse);
                public status: POGOProtos.Networking.Responses.SetPlayerTeamResponse.Status;
                public player_data?: (POGOProtos.Data.IPlayerData|null);
                public static encode(message: POGOProtos.Networking.Responses.ISetPlayerTeamResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SetPlayerTeamResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SetPlayerTeamResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SetPlayerTeamResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SetPlayerTeamResponse {

                enum Status {
                    UNSET = 0,
                    SUCCESS = 1,
                    TEAM_ALREADY_SET = 2,
                    FAILURE = 3
                }
            }

            interface ISfidaActionLogResponse {
                result?: (POGOProtos.Networking.Responses.SfidaActionLogResponse.Result|null);
                log_entries?: (POGOProtos.Data.Logs.IActionLogEntry[]|null);
            }

            class SfidaActionLogResponse implements ISfidaActionLogResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISfidaActionLogResponse);
                public result: POGOProtos.Networking.Responses.SfidaActionLogResponse.Result;
                public log_entries: POGOProtos.Data.Logs.IActionLogEntry[];
                public static encode(message: POGOProtos.Networking.Responses.ISfidaActionLogResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SfidaActionLogResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SfidaActionLogResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SfidaActionLogResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SfidaActionLogResponse {

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

            interface ISfidaCaptureResponse {
                result?: (POGOProtos.Networking.Responses.SfidaCaptureResponse.Result|null);
                xp_gain?: (number|null);
            }

            class SfidaCaptureResponse implements ISfidaCaptureResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISfidaCaptureResponse);
                public result: POGOProtos.Networking.Responses.SfidaCaptureResponse.Result;
                public xp_gain: number;
                public static encode(message: POGOProtos.Networking.Responses.ISfidaCaptureResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SfidaCaptureResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SfidaCaptureResponse;
                public static toObject(message: POGOProtos.Networking.Responses.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 ISfidaCertificationResponse {
                payload?: (Uint8Array|null);
            }

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

            interface ISfidaDowserResponse {
                result?: (POGOProtos.Networking.Responses.SfidaDowserResponse.Result|null);
                proximity?: (number|null);
                spawnpoint_id?: (string|null);
            }

            class SfidaDowserResponse implements ISfidaDowserResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISfidaDowserResponse);
                public result: POGOProtos.Networking.Responses.SfidaDowserResponse.Result;
                public proximity: number;
                public spawnpoint_id: string;
                public static encode(message: POGOProtos.Networking.Responses.ISfidaDowserResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SfidaDowserResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SfidaDowserResponse;
                public static toObject(message: POGOProtos.Networking.Responses.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 ISfidaRegistrationResponse {
                access_token?: (Uint8Array|null);
            }

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

            interface ISfidaUpdateResponse {
                status?: (POGOProtos.Networking.Responses.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.Enums.EncounterType|null);
                pokedex_number?: (number|null);
                nearby?: (POGOProtos.Data.Sfida.ISfidaNearbyPokemon[]|null);
            }

            class SfidaUpdateResponse implements ISfidaUpdateResponse {
                constructor(properties?: POGOProtos.Networking.Responses.ISfidaUpdateResponse);
                public status: POGOProtos.Networking.Responses.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.Enums.EncounterType;
                public pokedex_number: number;
                public nearby: POGOProtos.Data.Sfida.ISfidaNearbyPokemon[];
                public static encode(message: POGOProtos.Networking.Responses.ISfidaUpdateResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.SfidaUpdateResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.SfidaUpdateResponse;
                public static toObject(message: POGOProtos.Networking.Responses.SfidaUpdateResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace SfidaUpdateResponse {

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

            interface IShareExRaidPassResponse {
                result?: (POGOProtos.Enums.ShareExRaidPassResult|null);
                updated_friendship_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                friend_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
            }

            class ShareExRaidPassResponse implements IShareExRaidPassResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IShareExRaidPassResponse);
                public result: POGOProtos.Enums.ShareExRaidPassResult;
                public updated_friendship_data?: (POGOProtos.Data.Friends.IFriendshipLevelData|null);
                public friend_profile?: (POGOProtos.Data.Player.IPlayerPublicProfile|null);
                public static encode(message: POGOProtos.Networking.Responses.IShareExRaidPassResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.ShareExRaidPassResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.ShareExRaidPassResponse;
                public static toObject(message: POGOProtos.Networking.Responses.ShareExRaidPassResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Social {

                interface IAcceptFriendInviteResponse {
                    result?: (POGOProtos.Networking.Responses.Social.AcceptFriendInviteResponse.Result|null);
                    friend?: (POGOProtos.Data.Player.IPlayerSummary|null);
                }

                class AcceptFriendInviteResponse implements IAcceptFriendInviteResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IAcceptFriendInviteResponse);
                    public result: POGOProtos.Networking.Responses.Social.AcceptFriendInviteResponse.Result;
                    public friend?: (POGOProtos.Data.Player.IPlayerSummary|null);
                    public static encode(message: POGOProtos.Networking.Responses.Social.IAcceptFriendInviteResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.AcceptFriendInviteResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.AcceptFriendInviteResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.AcceptFriendInviteResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace AcceptFriendInviteResponse {

                    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
                    }
                }

                interface ICancelFriendInviteResponse {
                    result?: (POGOProtos.Networking.Responses.Social.CancelFriendInviteResponse.Result|null);
                }

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

                namespace CancelFriendInviteResponse {

                    enum Result {
                        UNSET = 0,
                        SUCCESS = 1,
                        ERROR_UNKNOWN = 2,
                        ERROR_INVITE_DOES_NOT_EXIST = 3,
                        ERROR_ALREADY_CANCELLED = 4
                    }
                }

                interface ICreateInviteCodeResponse {
                    result?: (POGOProtos.Networking.Responses.Social.CreateInviteCodeResponse.Result|null);
                    friend_code?: (string|null);
                }

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

                namespace CreateInviteCodeResponse {

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

                interface IDeclineFriendInviteResponse {
                    result?: (POGOProtos.Networking.Responses.Social.DeclineFriendInviteResponse.Result|null);
                }

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

                namespace DeclineFriendInviteResponse {

                    enum Result {
                        UNSET = 0,
                        SUCCESS = 1,
                        ERROR_UNKNOWN = 2,
                        ERROR_INVITE_DOES_NOT_EXIST = 3,
                        ERROR_INVITE_ALREADY_DECLINED = 4
                    }
                }

                interface IGetFacebookFriendListResponse {
                    result?: (POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.Result|null);
                    friend?: (POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.IFacebookFriend[]|null);
                    next_cursor?: (string|null);
                }

                class GetFacebookFriendListResponse implements IGetFacebookFriendListResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IGetFacebookFriendListResponse);
                    public result: POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.Result;
                    public friend: POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.IFacebookFriend[];
                    public next_cursor: string;
                    public static encode(message: POGOProtos.Networking.Responses.Social.IGetFacebookFriendListResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace GetFacebookFriendListResponse {

                    enum Result {
                        UNSET = 0,
                        SUCCESS = 1,
                        ERROR_UNKNOWN = 2,
                        ERROR_FACEBOOK_API = 3,
                        ERROR_FACEBOOK_PERMISSIONS = 4,
                        ERROR_NO_FACEBOOK_ID = 5
                    }

                    interface IFacebookFriend {
                        player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                        full_name?: (string|null);
                    }

                    class FacebookFriend implements IFacebookFriend {
                        constructor(properties?: POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.IFacebookFriend);
                        public player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                        public full_name: string;
                        public static encode(message: POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.IFacebookFriend, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.FacebookFriend;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.FacebookFriend;
                        public static toObject(message: POGOProtos.Networking.Responses.Social.GetFacebookFriendListResponse.FacebookFriend, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }
                }

                interface IGetInboxResponse {
                    result?: (POGOProtos.Networking.Responses.Social.GetInboxResponse.Result|null);
                    inbox?: (POGOProtos.Data.Inbox.IClientInbox|null);
                }

                class GetInboxResponse implements IGetInboxResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IGetInboxResponse);
                    public result: POGOProtos.Networking.Responses.Social.GetInboxResponse.Result;
                    public inbox?: (POGOProtos.Data.Inbox.IClientInbox|null);
                    public static encode(message: POGOProtos.Networking.Responses.Social.IGetInboxResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.GetInboxResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.GetInboxResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.GetInboxResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace GetInboxResponse {

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

                interface IIsMyFriendResponse {
                    result?: (POGOProtos.Networking.Responses.Social.IsMyFriendResponse.Result|null);
                    is_friend?: (boolean|null);
                }

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

                namespace IsMyFriendResponse {

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

                interface IListFriendsResponse {
                    result?: (POGOProtos.Networking.Responses.Social.ListFriendsResponse.Result|null);
                    friend?: (POGOProtos.Data.Friends.IFriend[]|null);
                }

                class ListFriendsResponse implements IListFriendsResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IListFriendsResponse);
                    public result: POGOProtos.Networking.Responses.Social.ListFriendsResponse.Result;
                    public friend: POGOProtos.Data.Friends.IFriend[];
                    public static encode(message: POGOProtos.Networking.Responses.Social.IListFriendsResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.ListFriendsResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.ListFriendsResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.ListFriendsResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace ListFriendsResponse {

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

                interface IListFriendStatusResponse {
                    result?: (POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Result|null);
                    friend?: (POGOProtos.Data.Friends.IFriendDetails[]|null);
                    friend_details_debug_info?: (POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.IDebug|null);
                }

                class ListFriendStatusResponse implements IListFriendStatusResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IListFriendStatusResponse);
                    public result: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Result;
                    public friend: POGOProtos.Data.Friends.IFriendDetails[];
                    public friend_details_debug_info?: (POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.IDebug|null);
                    public static encode(message: POGOProtos.Networking.Responses.Social.IListFriendStatusResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.ListFriendStatusResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.ListFriendStatusResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace ListFriendStatusResponse {

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

                    interface IDebug {
                        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);
                        callee_list?: (POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.ICallee[]|null);
                    }

                    class Debug implements IDebug {
                        constructor(properties?: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.IDebug);
                        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 callee_list: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.ICallee[];
                        public static encode(message: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.IDebug, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug;
                        public static toObject(message: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }

                    namespace Debug {

                        interface ICallee {
                            callee_id?: (number[]|null);
                            player_id?: (string|null);
                        }

                        class Callee implements ICallee {
                            constructor(properties?: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.ICallee);
                            public callee_id: number[];
                            public player_id: string;
                            public static encode(message: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.ICallee, writer?: $protobuf.Writer): $protobuf.Writer;
                            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.Callee;
                            public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.Callee;
                            public static toObject(message: POGOProtos.Networking.Responses.Social.ListFriendStatusResponse.Debug.Callee, options?: $protobuf.IConversionOptions): { [k: string]: any };
                            public toJSON(): { [k: string]: any };
                        }
                    }
                }

                interface IListIncomingFriendInvitesResponse {
                    result?: (POGOProtos.Networking.Responses.Social.ListIncomingFriendInvitesResponse.Result|null);
                    invites?: (POGOProtos.Data.Friends.IIncomingFriendInviteDisplay[]|null);
                }

                class ListIncomingFriendInvitesResponse implements IListIncomingFriendInvitesResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IListIncomingFriendInvitesResponse);
                    public result: POGOProtos.Networking.Responses.Social.ListIncomingFriendInvitesResponse.Result;
                    public invites: POGOProtos.Data.Friends.IIncomingFriendInviteDisplay[];
                    public static encode(message: POGOProtos.Networking.Responses.Social.IListIncomingFriendInvitesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.ListIncomingFriendInvitesResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.ListIncomingFriendInvitesResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.ListIncomingFriendInvitesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace ListIncomingFriendInvitesResponse {

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

                interface IListOutgoingFriendInvitesResponse {
                    result?: (POGOProtos.Networking.Responses.Social.ListOutgoingFriendInvitesResponse.Result|null);
                    invites?: (POGOProtos.Data.Friends.IOutgoingFriendInviteDisplay[]|null);
                }

                class ListOutgoingFriendInvitesResponse implements IListOutgoingFriendInvitesResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IListOutgoingFriendInvitesResponse);
                    public result: POGOProtos.Networking.Responses.Social.ListOutgoingFriendInvitesResponse.Result;
                    public invites: POGOProtos.Data.Friends.IOutgoingFriendInviteDisplay[];
                    public static encode(message: POGOProtos.Networking.Responses.Social.IListOutgoingFriendInvitesResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.ListOutgoingFriendInvitesResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.ListOutgoingFriendInvitesResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.ListOutgoingFriendInvitesResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace ListOutgoingFriendInvitesResponse {

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

                interface IOptOutPushNotificationCategoryResponse {
                }

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

                interface IRegisterPushNotificationResponse {
                    result?: (POGOProtos.Networking.Responses.Social.RegisterPushNotificationResponse.Result|null);
                }

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

                namespace RegisterPushNotificationResponse {

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

                interface IRemoveFriendResponse {
                    result?: (POGOProtos.Networking.Responses.Social.RemoveFriendResponse.Result|null);
                }

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

                namespace RemoveFriendResponse {

                    enum Result {
                        UNSET = 0,
                        SUCCESS = 1,
                        ERROR_PLAYER_DOES_NOT_EXIST_DELETED = 2,
                        ERROR_PLAYER_NOT_A_FRIEND = 3
                    }
                }

                interface ISearchPlayerResponse {
                    result?: (POGOProtos.Networking.Responses.Social.SearchPlayerResponse.Result|null);
                    player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                }

                class SearchPlayerResponse implements ISearchPlayerResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.ISearchPlayerResponse);
                    public result: POGOProtos.Networking.Responses.Social.SearchPlayerResponse.Result;
                    public player?: (POGOProtos.Data.Player.IPlayerSummary|null);
                    public static encode(message: POGOProtos.Networking.Responses.Social.ISearchPlayerResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.SearchPlayerResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.SearchPlayerResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.SearchPlayerResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace SearchPlayerResponse {

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

                interface ISendFacebookFriendInviteResponse {
                    result?: (POGOProtos.Networking.Responses.Social.SendFacebookFriendInviteResponse.Result|null);
                }

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

                namespace SendFacebookFriendInviteResponse {

                    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
                    }
                }

                interface ISendFriendInviteResponse {
                    result?: (POGOProtos.Networking.Responses.Social.SendFriendInviteResponse.Result|null);
                }

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

                namespace SendFriendInviteResponse {

                    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
                    }
                }

                interface IUpdateFacebookStatusResponse {
                    result?: (POGOProtos.Networking.Responses.Social.UpdateFacebookStatusResponse.Result|null);
                }

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

                namespace UpdateFacebookStatusResponse {

                    enum Result {
                        UNSET = 0,
                        SUCCESS = 1,
                        ERROR_UNKNOWN = 2,
                        ERROR_PLAYER_NOT_FOUND = 3,
                        ERROR_FACEBOOK_API = 4,
                        ERROR_ALREADY_EXISTS = 5
                    }
                }

                interface IUpdateNotificationResponse {
                    notification_ids?: (string[]|null);
                    create_timestamp_ms?: ((number|Long)[]|null);
                    state?: (POGOProtos.Enums.NotificationState|null);
                }

                class UpdateNotificationResponse implements IUpdateNotificationResponse {
                    constructor(properties?: POGOProtos.Networking.Responses.Social.IUpdateNotificationResponse);
                    public notification_ids: string[];
                    public create_timestamp_ms: (number|Long)[];
                    public state: POGOProtos.Enums.NotificationState;
                    public static encode(message: POGOProtos.Networking.Responses.Social.IUpdateNotificationResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.Social.UpdateNotificationResponse;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.Social.UpdateNotificationResponse;
                    public static toObject(message: POGOProtos.Networking.Responses.Social.UpdateNotificationResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IStartGymBattleResponse {
                result?: (POGOProtos.Networking.Responses.StartGymBattleResponse.Result|null);
                battle_start_timestamp_ms?: (number|Long|null);
                battle_end_timestamp_ms?: (number|Long|null);
                battle_id?: (string|null);
                defender?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                attacker?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                battle?: (POGOProtos.Data.Battle.IBattle|null);
            }

            class StartGymBattleResponse implements IStartGymBattleResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IStartGymBattleResponse);
                public result: POGOProtos.Networking.Responses.StartGymBattleResponse.Result;
                public battle_start_timestamp_ms: (number|Long);
                public battle_end_timestamp_ms: (number|Long);
                public battle_id: string;
                public defender?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                public battle_log?: (POGOProtos.Data.Battle.IBattleLog|null);
                public attacker?: (POGOProtos.Data.Battle.IBattleParticipant|null);
                public battle?: (POGOProtos.Data.Battle.IBattle|null);
                public static encode(message: POGOProtos.Networking.Responses.IStartGymBattleResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.StartGymBattleResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.StartGymBattleResponse;
                public static toObject(message: POGOProtos.Networking.Responses.StartGymBattleResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace StartGymBattleResponse {

                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 IStartRaidBattleResponse {
                result?: (POGOProtos.Networking.Responses.StartRaidBattleResponse.Result|null);
                battle?: (POGOProtos.Data.Battle.IBattle|null);
            }

            class StartRaidBattleResponse implements IStartRaidBattleResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IStartRaidBattleResponse);
                public result: POGOProtos.Networking.Responses.StartRaidBattleResponse.Result;
                public battle?: (POGOProtos.Data.Battle.IBattle|null);
                public static encode(message: POGOProtos.Networking.Responses.IStartRaidBattleResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.StartRaidBattleResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.StartRaidBattleResponse;
                public static toObject(message: POGOProtos.Networking.Responses.StartRaidBattleResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace StartRaidBattleResponse {

                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
                }
            }

            interface IStartTutorialActionResponse {
                result?: (POGOProtos.Networking.Responses.StartTutorialActionResponse.Result|null);
            }

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

            namespace StartTutorialActionResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_PLAYER_ALREADY_STARTED_TUTORIAL = 2,
                    ERROR_FAILED_TO_START = 3
                }
            }

            interface ISubmitCombatChallengePokemonsResponse {
                result?: (POGOProtos.Networking.Responses.SubmitCombatChallengePokemonsResponse.Result|null);
                challenge?: (POGOProtos.Data.Combat.ICombatChallenge|null);
            }

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

            namespace SubmitCombatChallengePokemonsResponse {

                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 IUnlockSpecialMoveResponse {
                result?: (POGOProtos.Networking.Responses.UnlockSpecialMoveResponse.Result|null);
                unlocked_pokemon?: (POGOProtos.Data.IPokemonData|null);
            }

            class UnlockSpecialMoveResponse implements IUnlockSpecialMoveResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUnlockSpecialMoveResponse);
                public result: POGOProtos.Networking.Responses.UnlockSpecialMoveResponse.Result;
                public unlocked_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public static encode(message: POGOProtos.Networking.Responses.IUnlockSpecialMoveResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UnlockSpecialMoveResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UnlockSpecialMoveResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UnlockSpecialMoveResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UnlockSpecialMoveResponse {

                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 IUpdateCombatResponse {
                result?: (POGOProtos.Networking.Responses.UpdateCombatResponse.Result|null);
                combat?: (POGOProtos.Data.Combat.ICombat|null);
            }

            class UpdateCombatResponse implements IUpdateCombatResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUpdateCombatResponse);
                public result: POGOProtos.Networking.Responses.UpdateCombatResponse.Result;
                public combat?: (POGOProtos.Data.Combat.ICombat|null);
                public static encode(message: POGOProtos.Networking.Responses.IUpdateCombatResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UpdateCombatResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UpdateCombatResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UpdateCombatResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UpdateCombatResponse {

                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
                }
            }

            interface IUpdateFitnessMetricsResponse {
                status?: (POGOProtos.Networking.Responses.UpdateFitnessMetricsResponse.Status|null);
            }

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

            namespace UpdateFitnessMetricsResponse {

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

            interface IUpdatePlayerLocationResponse {
            }

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

            interface IUpdateTradingResponse {
                result?: (POGOProtos.Networking.Responses.UpdateTradingResponse.Result|null);
                trading?: (POGOProtos.Data.Trading.ITrading|null);
            }

            class UpdateTradingResponse implements IUpdateTradingResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUpdateTradingResponse);
                public result: POGOProtos.Networking.Responses.UpdateTradingResponse.Result;
                public trading?: (POGOProtos.Data.Trading.ITrading|null);
                public static encode(message: POGOProtos.Networking.Responses.IUpdateTradingResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UpdateTradingResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UpdateTradingResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UpdateTradingResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UpdateTradingResponse {

                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 IUpgradePokemonResponse {
                result?: (POGOProtos.Networking.Responses.UpgradePokemonResponse.Result|null);
                upgraded_pokemon?: (POGOProtos.Data.IPokemonData|null);
                next_upgraded_pokemon?: (POGOProtos.Data.IPokemonData|null);
            }

            class UpgradePokemonResponse implements IUpgradePokemonResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUpgradePokemonResponse);
                public result: POGOProtos.Networking.Responses.UpgradePokemonResponse.Result;
                public upgraded_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public next_upgraded_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public static encode(message: POGOProtos.Networking.Responses.IUpgradePokemonResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UpgradePokemonResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UpgradePokemonResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UpgradePokemonResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UpgradePokemonResponse {

                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
                }
            }

            interface IUseIncenseResponse {
                result?: (POGOProtos.Networking.Responses.UseIncenseResponse.Result|null);
                applied_incense?: (POGOProtos.Inventory.IAppliedItem|null);
            }

            class UseIncenseResponse implements IUseIncenseResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseIncenseResponse);
                public result: POGOProtos.Networking.Responses.UseIncenseResponse.Result;
                public applied_incense?: (POGOProtos.Inventory.IAppliedItem|null);
                public static encode(message: POGOProtos.Networking.Responses.IUseIncenseResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseIncenseResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseIncenseResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseIncenseResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseIncenseResponse {

                enum Result {
                    UNKNOWN = 0,
                    SUCCESS = 1,
                    INCENSE_ALREADY_ACTIVE = 2,
                    NONE_IN_INVENTORY = 3,
                    LOCATION_UNSET = 4
                }
            }

            interface IUseItemCaptureResponse {
                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 UseItemCaptureResponse implements IUseItemCaptureResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemCaptureResponse);
                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.Networking.Responses.IUseItemCaptureResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemCaptureResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemCaptureResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemCaptureResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IUseItemEggIncubatorResponse {
                result?: (POGOProtos.Networking.Responses.UseItemEggIncubatorResponse.Result|null);
                egg_incubator?: (POGOProtos.Inventory.IEggIncubator|null);
            }

            class UseItemEggIncubatorResponse implements IUseItemEggIncubatorResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemEggIncubatorResponse);
                public result: POGOProtos.Networking.Responses.UseItemEggIncubatorResponse.Result;
                public egg_incubator?: (POGOProtos.Inventory.IEggIncubator|null);
                public static encode(message: POGOProtos.Networking.Responses.IUseItemEggIncubatorResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemEggIncubatorResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemEggIncubatorResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemEggIncubatorResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseItemEggIncubatorResponse {

                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 IUseItemEncounterResponse {
                status?: (POGOProtos.Networking.Responses.UseItemEncounterResponse.Status|null);
                capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                active_item?: (POGOProtos.Inventory.Item.ItemId|null);
            }

            class UseItemEncounterResponse implements IUseItemEncounterResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemEncounterResponse);
                public status: POGOProtos.Networking.Responses.UseItemEncounterResponse.Status;
                public capture_probability?: (POGOProtos.Data.Capture.ICaptureProbability|null);
                public active_item: POGOProtos.Inventory.Item.ItemId;
                public static encode(message: POGOProtos.Networking.Responses.IUseItemEncounterResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemEncounterResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemEncounterResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemEncounterResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseItemEncounterResponse {

                enum Status {
                    SUCCESS = 0,
                    ALREADY_COMPLETED = 1,
                    ACTIVE_ITEM_EXISTS = 2,
                    NO_ITEM_IN_INVENTORY = 3,
                    INVALID_ITEM_CATEGORY = 4
                }
            }

            interface IUseItemGymResponse {
                result?: (POGOProtos.Networking.Responses.UseItemGymResponse.Result|null);
                updated_gp?: (number|Long|null);
            }

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

            namespace UseItemGymResponse {

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

            interface IUseItemMoveRerollResponse {
                result?: (POGOProtos.Networking.Responses.UseItemMoveRerollResponse.Result|null);
                updated_pokemon?: (POGOProtos.Data.IPokemonData|null);
            }

            class UseItemMoveRerollResponse implements IUseItemMoveRerollResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemMoveRerollResponse);
                public result: POGOProtos.Networking.Responses.UseItemMoveRerollResponse.Result;
                public updated_pokemon?: (POGOProtos.Data.IPokemonData|null);
                public static encode(message: POGOProtos.Networking.Responses.IUseItemMoveRerollResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemMoveRerollResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemMoveRerollResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemMoveRerollResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseItemMoveRerollResponse {

                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
                }
            }

            interface IUseItemPotionResponse {
                result?: (POGOProtos.Networking.Responses.UseItemPotionResponse.Result|null);
                stamina?: (number|null);
            }

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

            namespace UseItemPotionResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_NO_POKEMON = 2,
                    ERROR_CANNOT_USE = 3,
                    ERROR_DEPLOYED_TO_FORT = 4
                }
            }

            interface IUseItemRareCandyResponse {
                result?: (POGOProtos.Networking.Responses.UseItemRareCandyResponse.Result|null);
                pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                updated_candy_count?: (number|null);
            }

            class UseItemRareCandyResponse implements IUseItemRareCandyResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemRareCandyResponse);
                public result: POGOProtos.Networking.Responses.UseItemRareCandyResponse.Result;
                public pokemon_id: POGOProtos.Enums.PokemonId;
                public updated_candy_count: number;
                public static encode(message: POGOProtos.Networking.Responses.IUseItemRareCandyResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemRareCandyResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemRareCandyResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemRareCandyResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseItemRareCandyResponse {

                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 IUseItemReviveResponse {
                result?: (POGOProtos.Networking.Responses.UseItemReviveResponse.Result|null);
                stamina?: (number|null);
            }

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

            namespace UseItemReviveResponse {

                enum Result {
                    UNSET = 0,
                    SUCCESS = 1,
                    ERROR_NO_POKEMON = 2,
                    ERROR_CANNOT_USE = 3,
                    ERROR_DEPLOYED_TO_FORT = 4
                }
            }

            interface IUseItemStardustBoostResponse {
                result?: (POGOProtos.Networking.Responses.UseItemStardustBoostResponse.Result|null);
                applied_items?: (POGOProtos.Inventory.IAppliedItems|null);
            }

            class UseItemStardustBoostResponse implements IUseItemStardustBoostResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemStardustBoostResponse);
                public result: POGOProtos.Networking.Responses.UseItemStardustBoostResponse.Result;
                public applied_items?: (POGOProtos.Inventory.IAppliedItems|null);
                public static encode(message: POGOProtos.Networking.Responses.IUseItemStardustBoostResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemStardustBoostResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemStardustBoostResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemStardustBoostResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseItemStardustBoostResponse {

                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 IUseItemXpBoostResponse {
                result?: (POGOProtos.Networking.Responses.UseItemXpBoostResponse.Result|null);
                applied_items?: (POGOProtos.Inventory.IAppliedItems|null);
            }

            class UseItemXpBoostResponse implements IUseItemXpBoostResponse {
                constructor(properties?: POGOProtos.Networking.Responses.IUseItemXpBoostResponse);
                public result: POGOProtos.Networking.Responses.UseItemXpBoostResponse.Result;
                public applied_items?: (POGOProtos.Inventory.IAppliedItems|null);
                public static encode(message: POGOProtos.Networking.Responses.IUseItemXpBoostResponse, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Networking.Responses.UseItemXpBoostResponse;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Networking.Responses.UseItemXpBoostResponse;
                public static toObject(message: POGOProtos.Networking.Responses.UseItemXpBoostResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace UseItemXpBoostResponse {

                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 IVerifyChallengeResponse {
                success?: (boolean|null);
            }

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

    namespace Settings {

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

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

        interface IBackgroundModeClientSettings {
            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);
        }

        class BackgroundModeClientSettings implements IBackgroundModeClientSettings {
            constructor(properties?: POGOProtos.Settings.IBackgroundModeClientSettings);
            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 static encode(message: POGOProtos.Settings.IBackgroundModeClientSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.BackgroundModeClientSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.BackgroundModeClientSettings;
            public static toObject(message: POGOProtos.Settings.BackgroundModeClientSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IBackgroundModeGlobalSettings {
            min_player_level_fitness?: (number|null);
        }

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

        interface IBelugaGlobalSettings {
            enable_beluga_transfer?: (boolean|null);
            max_num_pokemon_per_transfer?: (number|null);
        }

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

        interface IClientPerformanceSettings {
            enable_local_disk_caching?: (boolean|null);
            max_number_local_battle_parties?: (number|null);
            multi_pokemon_battle_party_select?: (boolean|null);
        }

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

        interface ICombatChallengeGlobalSettings {
            distance_check_override_friendship_level?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
            get_combat_challenge_polling_interval_sec?: (number|null);
        }

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

        interface ICombatGlobalSettings {
            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);
            enable_spin_minigame?: (boolean|null);
            enable_quick_swap_v2?: (boolean|null);
        }

        class CombatGlobalSettings implements ICombatGlobalSettings {
            constructor(properties?: POGOProtos.Settings.ICombatGlobalSettings);
            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 enable_spin_minigame: boolean;
            public enable_quick_swap_v2: boolean;
            public static encode(message: POGOProtos.Settings.ICombatGlobalSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.CombatGlobalSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.CombatGlobalSettings;
            public static toObject(message: POGOProtos.Settings.CombatGlobalSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IEventSettings {
            condolence_ribbon_country?: (string[]|null);
        }

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

        interface IFestivalSettings {
            festival_type?: (POGOProtos.Settings.FestivalSettings.FestivalType|null);
            key?: (string|null);
            vector?: (string|null);
        }

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

        namespace FestivalSettings {

            enum FestivalType {
                NONE = 0,
                HALLOWEEN = 1,
                HOLIDAY = 2
            }
        }

        interface IFortSettings {
            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);
        }

        class FortSettings implements IFortSettings {
            constructor(properties?: POGOProtos.Settings.IFortSettings);
            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 static encode(message: POGOProtos.Settings.IFortSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.FortSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.FortSettings;
            public static toObject(message: POGOProtos.Settings.FortSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGlobalSettings {
            fort_settings?: (POGOProtos.Settings.IFortSettings|null);
            map_settings?: (POGOProtos.Settings.IMapSettings|null);
            level_settings?: (POGOProtos.Settings.ILevelSettings|null);
            inventory_settings?: (POGOProtos.Settings.IInventorySettings|null);
            minimum_client_version?: (string|null);
            gps_settings?: (POGOProtos.Settings.IGpsSettings|null);
            festival_settings?: (POGOProtos.Settings.IFestivalSettings|null);
            event_settings?: (POGOProtos.Settings.IEventSettings|null);
            max_pokemon_types?: (number|null);
            sfida_settings?: (POGOProtos.Settings.ISfidaSettings|null);
            news_settings?: (POGOProtos.Settings.INewsSettings|null);
            translation_settings?: (POGOProtos.Settings.ITranslationSettings|null);
            passcode_settings?: (POGOProtos.Settings.IPasscodeSettings|null);
            notification_settings?: (POGOProtos.Settings.INotificationSettings|null);
            client_app_blacklist?: (string[]|null);
            client_perf_settings?: (POGOProtos.Settings.IClientPerformanceSettings|null);
            news_global_settings?: (POGOProtos.Settings.INewsGlobalSettings|null);
            quest_global_settings?: (POGOProtos.Settings.IQuestGlobalSettings|null);
            beluga_global_settings?: (POGOProtos.Settings.IBelugaGlobalSettings|null);
            telemetry_global_settings?: (POGOProtos.Settings.ITelemetryGlobalSettings|null);
            login_settings?: (POGOProtos.Settings.ILoginSettings|null);
            social_settings?: (POGOProtos.Settings.ISocialClientSettings|null);
            trading_global_settings?: (POGOProtos.Settings.ITradingGlobalSettings|null);
            additional_allowed_pokemon_ids?: (POGOProtos.Enums.PokemonId[]|null);
            upsight_logging_settings?: (POGOProtos.Settings.IUpsightLoggingSettings|null);
            combat_global_settings?: (POGOProtos.Settings.ICombatGlobalSettings|null);
            third_move_settings?: (POGOProtos.Settings.IThirdMoveGlobalSettings|null);
            combat_challenge_global_settings?: (POGOProtos.Settings.ICombatChallengeGlobalSettings|null);
            bgmode_global_settings?: (POGOProtos.Settings.IBackgroundModeGlobalSettings|null);
            probe_settings?: (POGOProtos.Settings.IProbeSettings|null);
            purchased_settings?: (POGOProtos.Settings.IPokecoinPurchaseDisplaySettings|null);
            helpshift_settings?: (POGOProtos.Settings.IHelpshiftSettings|null);
            ar_photo_settings?: (POGOProtos.Settings.IArPhotoGlobalSettings|null);
            poi_settings?: (POGOProtos.Settings.IPoiGlobalSettings|null);
            pokemon_settings?: (POGOProtos.Settings.IPokemonGlobalSettings|null);
        }

        class GlobalSettings implements IGlobalSettings {
            constructor(properties?: POGOProtos.Settings.IGlobalSettings);
            public fort_settings?: (POGOProtos.Settings.IFortSettings|null);
            public map_settings?: (POGOProtos.Settings.IMapSettings|null);
            public level_settings?: (POGOProtos.Settings.ILevelSettings|null);
            public inventory_settings?: (POGOProtos.Settings.IInventorySettings|null);
            public minimum_client_version: string;
            public gps_settings?: (POGOProtos.Settings.IGpsSettings|null);
            public festival_settings?: (POGOProtos.Settings.IFestivalSettings|null);
            public event_settings?: (POGOProtos.Settings.IEventSettings|null);
            public max_pokemon_types: number;
            public sfida_settings?: (POGOProtos.Settings.ISfidaSettings|null);
            public news_settings?: (POGOProtos.Settings.INewsSettings|null);
            public translation_settings?: (POGOProtos.Settings.ITranslationSettings|null);
            public passcode_settings?: (POGOProtos.Settings.IPasscodeSettings|null);
            public notification_settings?: (POGOProtos.Settings.INotificationSettings|null);
            public client_app_blacklist: string[];
            public client_perf_settings?: (POGOProtos.Settings.IClientPerformanceSettings|null);
            public news_global_settings?: (POGOProtos.Settings.INewsGlobalSettings|null);
            public quest_global_settings?: (POGOProtos.Settings.IQuestGlobalSettings|null);
            public beluga_global_settings?: (POGOProtos.Settings.IBelugaGlobalSettings|null);
            public telemetry_global_settings?: (POGOProtos.Settings.ITelemetryGlobalSettings|null);
            public login_settings?: (POGOProtos.Settings.ILoginSettings|null);
            public social_settings?: (POGOProtos.Settings.ISocialClientSettings|null);
            public trading_global_settings?: (POGOProtos.Settings.ITradingGlobalSettings|null);
            public additional_allowed_pokemon_ids: POGOProtos.Enums.PokemonId[];
            public upsight_logging_settings?: (POGOProtos.Settings.IUpsightLoggingSettings|null);
            public combat_global_settings?: (POGOProtos.Settings.ICombatGlobalSettings|null);
            public third_move_settings?: (POGOProtos.Settings.IThirdMoveGlobalSettings|null);
            public combat_challenge_global_settings?: (POGOProtos.Settings.ICombatChallengeGlobalSettings|null);
            public bgmode_global_settings?: (POGOProtos.Settings.IBackgroundModeGlobalSettings|null);
            public probe_settings?: (POGOProtos.Settings.IProbeSettings|null);
            public purchased_settings?: (POGOProtos.Settings.IPokecoinPurchaseDisplaySettings|null);
            public helpshift_settings?: (POGOProtos.Settings.IHelpshiftSettings|null);
            public ar_photo_settings?: (POGOProtos.Settings.IArPhotoGlobalSettings|null);
            public poi_settings?: (POGOProtos.Settings.IPoiGlobalSettings|null);
            public pokemon_settings?: (POGOProtos.Settings.IPokemonGlobalSettings|null);
            public static encode(message: POGOProtos.Settings.IGlobalSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.GlobalSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.GlobalSettings;
            public static toObject(message: POGOProtos.Settings.GlobalSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IGpsSettings {
            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);
        }

        class GpsSettings implements IGpsSettings {
            constructor(properties?: POGOProtos.Settings.IGpsSettings);
            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 static encode(message: POGOProtos.Settings.IGpsSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.GpsSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.GpsSettings;
            public static toObject(message: POGOProtos.Settings.GpsSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

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

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

        interface IInventorySettings {
            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);
        }

        class InventorySettings implements IInventorySettings {
            constructor(properties?: POGOProtos.Settings.IInventorySettings);
            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 static encode(message: POGOProtos.Settings.IInventorySettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.InventorySettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.InventorySettings;
            public static toObject(message: POGOProtos.Settings.InventorySettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ILevelSettings {
            trainer_cp_modifier?: (number|null);
            trainer_difficulty_modifier?: (number|null);
        }

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

        interface ILoginSettings {
            enable_multi_login_linking?: (boolean|null);
        }

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

        interface IMapSettings {
            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);
        }

        class MapSettings implements IMapSettings {
            constructor(properties?: POGOProtos.Settings.IMapSettings);
            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 static encode(message: POGOProtos.Settings.IMapSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.MapSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.MapSettings;
            public static toObject(message: POGOProtos.Settings.MapSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        namespace Master {

            interface IBackgroundModeSettings {
                weekly_fitness_goal_level1_distance_km?: (number|null);
                weekly_fitness_goal_level2_distance_km?: (number|null);
                weekly_fitness_goal_level3_distance_km?: (number|null);
            }

            class BackgroundModeSettings implements IBackgroundModeSettings {
                constructor(properties?: POGOProtos.Settings.Master.IBackgroundModeSettings);
                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 static encode(message: POGOProtos.Settings.Master.IBackgroundModeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.BackgroundModeSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.BackgroundModeSettings;
                public static toObject(message: POGOProtos.Settings.Master.BackgroundModeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBadgeSettings {
                badge_type?: (POGOProtos.Enums.BadgeType|null);
                badge_rank?: (number|null);
                targets?: (number[]|null);
                capture_reward?: (POGOProtos.Data.Badge.IBadgeCaptureReward[]|null);
                event_badge?: (boolean|null);
                event_badge_settings?: (POGOProtos.Settings.Master.IEventBadgeSettings|null);
                combat_league_template_id?: (string|null);
            }

            class BadgeSettings implements IBadgeSettings {
                constructor(properties?: POGOProtos.Settings.Master.IBadgeSettings);
                public badge_type: POGOProtos.Enums.BadgeType;
                public badge_rank: number;
                public targets: number[];
                public capture_reward: POGOProtos.Data.Badge.IBadgeCaptureReward[];
                public event_badge: boolean;
                public event_badge_settings?: (POGOProtos.Settings.Master.IEventBadgeSettings|null);
                public combat_league_template_id: string;
                public static encode(message: POGOProtos.Settings.Master.IBadgeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.BadgeSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.BadgeSettings;
                public static toObject(message: POGOProtos.Settings.Master.BadgeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IBelugaPokemonWhitelist {
                max_allowed_pokemon_pokedex_number?: (number|null);
                additional_pokemon_allowed?: (POGOProtos.Enums.PokemonId[]|null);
                forms_allowed?: (POGOProtos.Enums.Form[]|null);
                costumes_allowed?: (POGOProtos.Enums.Costume[]|null);
            }

            class BelugaPokemonWhitelist implements IBelugaPokemonWhitelist {
                constructor(properties?: POGOProtos.Settings.Master.IBelugaPokemonWhitelist);
                public max_allowed_pokemon_pokedex_number: number;
                public additional_pokemon_allowed: POGOProtos.Enums.PokemonId[];
                public forms_allowed: POGOProtos.Enums.Form[];
                public costumes_allowed: POGOProtos.Enums.Costume[];
                public static encode(message: POGOProtos.Settings.Master.IBelugaPokemonWhitelist, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.BelugaPokemonWhitelist;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.BelugaPokemonWhitelist;
                public static toObject(message: POGOProtos.Settings.Master.BelugaPokemonWhitelist, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICameraSettings {
                next_camera?: (string|null);
                interpolation?: (POGOProtos.Enums.CameraInterpolation[]|null);
                target_type?: (POGOProtos.Enums.CameraTarget[]|null);
                ease_in_speed?: (number[]|null);
                ease_out_speed?: (number[]|null);
                duration_seconds?: (number[]|null);
                wait_seconds?: (number[]|null);
                transition_seconds?: (number[]|null);
                angle_degree?: (number[]|null);
                angle_offset_degree?: (number[]|null);
                pitch_degree?: (number[]|null);
                pitch_offset_degree?: (number[]|null);
                roll_degree?: (number[]|null);
                distance_meters?: (number[]|null);
                height_percent?: (number[]|null);
                vert_ctr_ratio?: (number[]|null);
            }

            class CameraSettings implements ICameraSettings {
                constructor(properties?: POGOProtos.Settings.Master.ICameraSettings);
                public next_camera: string;
                public interpolation: POGOProtos.Enums.CameraInterpolation[];
                public target_type: POGOProtos.Enums.CameraTarget[];
                public ease_in_speed: number[];
                public ease_out_speed: number[];
                public duration_seconds: number[];
                public wait_seconds: number[];
                public transition_seconds: number[];
                public angle_degree: number[];
                public angle_offset_degree: number[];
                public pitch_degree: number[];
                public pitch_offset_degree: number[];
                public roll_degree: number[];
                public distance_meters: number[];
                public height_percent: number[];
                public vert_ctr_ratio: number[];
                public static encode(message: POGOProtos.Settings.Master.ICameraSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CameraSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CameraSettings;
                public static toObject(message: POGOProtos.Settings.Master.CameraSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatLeague {
                title?: (string|null);
                enabled?: (boolean|null);
                unlock_condition?: (POGOProtos.Data.Combat.IUnlockCondition[]|null);
                pokemon_condition?: (POGOProtos.Data.Combat.IPokemonCondition[]|null);
                icon_url?: (string|null);
                pokemon_count?: (number|null);
                banned_pokemon?: (POGOProtos.Enums.PokemonId[]|null);
                badge_type?: (POGOProtos.Enums.BadgeType|null);
                minigame_defense_chance_limit?: (number|null);
            }

            class CombatLeague implements ICombatLeague {
                constructor(properties?: POGOProtos.Settings.Master.ICombatLeague);
                public title: string;
                public enabled: boolean;
                public unlock_condition: POGOProtos.Data.Combat.IUnlockCondition[];
                public pokemon_condition: POGOProtos.Data.Combat.IPokemonCondition[];
                public icon_url: string;
                public pokemon_count: number;
                public banned_pokemon: POGOProtos.Enums.PokemonId[];
                public badge_type: POGOProtos.Enums.BadgeType;
                public minigame_defense_chance_limit: number;
                public static encode(message: POGOProtos.Settings.Master.ICombatLeague, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatLeague;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatLeague;
                public static toObject(message: POGOProtos.Settings.Master.CombatLeague, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatLeagueSettings {
                combat_league_template_id?: (string[]|null);
            }

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

            interface ICombatMoveSettings {
                unique_id?: (POGOProtos.Enums.PokemonMove|null);
                type?: (POGOProtos.Enums.PokemonType|null);
                power?: (number|null);
                vfx_name?: (string|null);
                duration_turns?: (number|null);
                energy_delta?: (number|null);
                buffs?: (POGOProtos.Data.Combat.ICombatMoveBuffs|null);
            }

            class CombatMoveSettings implements ICombatMoveSettings {
                constructor(properties?: POGOProtos.Settings.Master.ICombatMoveSettings);
                public unique_id: POGOProtos.Enums.PokemonMove;
                public type: POGOProtos.Enums.PokemonType;
                public power: number;
                public vfx_name: string;
                public duration_turns: number;
                public energy_delta: number;
                public buffs?: (POGOProtos.Data.Combat.ICombatMoveBuffs|null);
                public static encode(message: POGOProtos.Settings.Master.ICombatMoveSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatMoveSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatMoveSettings;
                public static toObject(message: POGOProtos.Settings.Master.CombatMoveSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatNpcPersonality {
                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 CombatNpcPersonality implements ICombatNpcPersonality {
                constructor(properties?: POGOProtos.Settings.Master.ICombatNpcPersonality);
                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.Settings.Master.ICombatNpcPersonality, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatNpcPersonality;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatNpcPersonality;
                public static toObject(message: POGOProtos.Settings.Master.CombatNpcPersonality, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatNpcTrainer {
                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.Data.Player.IPlayerAvatar|null);
                available_pokemon?: (POGOProtos.Data.INpcPokemon[]|null);
                trainer_title?: (string|null);
                trainer_quote?: (string|null);
            }

            class CombatNpcTrainer implements ICombatNpcTrainer {
                constructor(properties?: POGOProtos.Settings.Master.ICombatNpcTrainer);
                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.Data.Player.IPlayerAvatar|null);
                public available_pokemon: POGOProtos.Data.INpcPokemon[];
                public trainer_title: string;
                public trainer_quote: string;
                public static encode(message: POGOProtos.Settings.Master.ICombatNpcTrainer, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatNpcTrainer;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatNpcTrainer;
                public static toObject(message: POGOProtos.Settings.Master.CombatNpcTrainer, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ICombatSettings {
                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.Settings.Master.CombatSettings.ICombatOffensiveInputChallengeSettings|null);
                defensive_input_challenge_settings?: (POGOProtos.Settings.Master.CombatSettings.ICombatDefensiveInputChallengeSettings|null);
            }

            class CombatSettings implements ICombatSettings {
                constructor(properties?: POGOProtos.Settings.Master.ICombatSettings);
                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.Settings.Master.CombatSettings.ICombatOffensiveInputChallengeSettings|null);
                public defensive_input_challenge_settings?: (POGOProtos.Settings.Master.CombatSettings.ICombatDefensiveInputChallengeSettings|null);
                public static encode(message: POGOProtos.Settings.Master.ICombatSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatSettings;
                public static toObject(message: POGOProtos.Settings.Master.CombatSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace CombatSettings {

                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.Settings.Master.CombatSettings.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.Settings.Master.CombatSettings.ICombatOffensiveInputChallengeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatSettings.CombatOffensiveInputChallengeSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatSettings.CombatOffensiveInputChallengeSettings;
                    public static toObject(message: POGOProtos.Settings.Master.CombatSettings.CombatOffensiveInputChallengeSettings, 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.Settings.Master.CombatSettings.ICombatDefensiveInputChallengeSettings);
                    public full_rotations_for_max_score: number;
                    public static encode(message: POGOProtos.Settings.Master.CombatSettings.ICombatDefensiveInputChallengeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatSettings.CombatDefensiveInputChallengeSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatSettings.CombatDefensiveInputChallengeSettings;
                    public static toObject(message: POGOProtos.Settings.Master.CombatSettings.CombatDefensiveInputChallengeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface ICombatStatStageSettings {
                minimum_stat_stage?: (number|null);
                maximum_stat_stage?: (number|null);
                attack_buff_multiplier?: (number[]|null);
                defense_buff_multiplier?: (number[]|null);
            }

            class CombatStatStageSettings implements ICombatStatStageSettings {
                constructor(properties?: POGOProtos.Settings.Master.ICombatStatStageSettings);
                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.Settings.Master.ICombatStatStageSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.CombatStatStageSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.CombatStatStageSettings;
                public static toObject(message: POGOProtos.Settings.Master.CombatStatStageSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEncounterSettings {
                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);
            }

            class EncounterSettings implements IEncounterSettings {
                constructor(properties?: POGOProtos.Settings.Master.IEncounterSettings);
                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 static encode(message: POGOProtos.Settings.Master.IEncounterSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.EncounterSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.EncounterSettings;
                public static toObject(message: POGOProtos.Settings.Master.EncounterSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEquippedBadgeSettings {
                equip_badge_cooldown_ms?: (number|Long|null);
                catch_probability_bonus?: (number[]|null);
                flee_probability_bonus?: (number[]|null);
            }

            class EquippedBadgeSettings implements IEquippedBadgeSettings {
                constructor(properties?: POGOProtos.Settings.Master.IEquippedBadgeSettings);
                public equip_badge_cooldown_ms: (number|Long);
                public catch_probability_bonus: number[];
                public flee_probability_bonus: number[];
                public static encode(message: POGOProtos.Settings.Master.IEquippedBadgeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.EquippedBadgeSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.EquippedBadgeSettings;
                public static toObject(message: POGOProtos.Settings.Master.EquippedBadgeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IEventBadgeSettings {
                valid_from_ms?: (number|Long|null);
                valid_to_ms?: (number|Long|null);
                mutually_exclusive_badges?: (POGOProtos.Enums.BadgeType[]|null);
            }

            class EventBadgeSettings implements IEventBadgeSettings {
                constructor(properties?: POGOProtos.Settings.Master.IEventBadgeSettings);
                public valid_from_ms: (number|Long);
                public valid_to_ms: (number|Long);
                public mutually_exclusive_badges: POGOProtos.Enums.BadgeType[];
                public static encode(message: POGOProtos.Settings.Master.IEventBadgeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.EventBadgeSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.EventBadgeSettings;
                public static toObject(message: POGOProtos.Settings.Master.EventBadgeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IExRaidSettings {
                minimum_ex_raid_share_level?: (POGOProtos.Enums.FriendshipLevelMilestone|null);
            }

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

            interface IFormSettings {
                pokemon?: (POGOProtos.Enums.PokemonId|null);
                forms?: (POGOProtos.Settings.Master.FormSettings.IForm[]|null);
            }

            class FormSettings implements IFormSettings {
                constructor(properties?: POGOProtos.Settings.Master.IFormSettings);
                public pokemon: POGOProtos.Enums.PokemonId;
                public forms: POGOProtos.Settings.Master.FormSettings.IForm[];
                public static encode(message: POGOProtos.Settings.Master.IFormSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.FormSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.FormSettings;
                public static toObject(message: POGOProtos.Settings.Master.FormSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace FormSettings {

                interface IForm {
                    form?: (POGOProtos.Enums.Form|null);
                    asset_bundle_value?: (number|null);
                }

                class Form implements IForm {
                    constructor(properties?: POGOProtos.Settings.Master.FormSettings.IForm);
                    public form: POGOProtos.Enums.Form;
                    public asset_bundle_value: number;
                    public static encode(message: POGOProtos.Settings.Master.FormSettings.IForm, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.FormSettings.Form;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.FormSettings.Form;
                    public static toObject(message: POGOProtos.Settings.Master.FormSettings.Form, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IFriendshipLevelMilestoneSettings {
                min_points_to_reach?: (number|null);
                milestone_xp_reward?: (number|null);
                attack_bonus_percentage?: (number|null);
                raid_ball_bonus?: (number|null);
                unlocked_trading?: (POGOProtos.Enums.PokemonTradingType[]|null);
                trading_discount?: (number|null);
            }

            class FriendshipLevelMilestoneSettings implements IFriendshipLevelMilestoneSettings {
                constructor(properties?: POGOProtos.Settings.Master.IFriendshipLevelMilestoneSettings);
                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.Enums.PokemonTradingType[];
                public trading_discount: number;
                public static encode(message: POGOProtos.Settings.Master.IFriendshipLevelMilestoneSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.FriendshipLevelMilestoneSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.FriendshipLevelMilestoneSettings;
                public static toObject(message: POGOProtos.Settings.Master.FriendshipLevelMilestoneSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGenderSettings {
                pokemon?: (POGOProtos.Enums.PokemonId|null);
                gender?: (POGOProtos.Settings.Master.Pokemon.IPokemonGenderSettings|null);
            }

            class GenderSettings implements IGenderSettings {
                constructor(properties?: POGOProtos.Settings.Master.IGenderSettings);
                public pokemon: POGOProtos.Enums.PokemonId;
                public gender?: (POGOProtos.Settings.Master.Pokemon.IPokemonGenderSettings|null);
                public static encode(message: POGOProtos.Settings.Master.IGenderSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.GenderSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.GenderSettings;
                public static toObject(message: POGOProtos.Settings.Master.GenderSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymBadgeGmtSettings {
                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 GymBadgeGmtSettings implements IGymBadgeGmtSettings {
                constructor(properties?: POGOProtos.Settings.Master.IGymBadgeGmtSettings);
                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.Settings.Master.IGymBadgeGmtSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.GymBadgeGmtSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.GymBadgeGmtSettings;
                public static toObject(message: POGOProtos.Settings.Master.GymBadgeGmtSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymBattleSettings {
                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);
            }

            class GymBattleSettings implements IGymBattleSettings {
                constructor(properties?: POGOProtos.Settings.Master.IGymBattleSettings);
                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 static encode(message: POGOProtos.Settings.Master.IGymBattleSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.GymBattleSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.GymBattleSettings;
                public static toObject(message: POGOProtos.Settings.Master.GymBattleSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IGymLevelSettings {
                required_experience?: (number[]|null);
                leader_slots?: (number[]|null);
                trainer_slots?: (number[]|null);
                search_roll_bonus?: (number[]|null);
            }

            class GymLevelSettings implements IGymLevelSettings {
                constructor(properties?: POGOProtos.Settings.Master.IGymLevelSettings);
                public required_experience: number[];
                public leader_slots: number[];
                public trainer_slots: number[];
                public search_roll_bonus: number[];
                public static encode(message: POGOProtos.Settings.Master.IGymLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.GymLevelSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.GymLevelSettings;
                public static toObject(message: POGOProtos.Settings.Master.GymLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IIapItemCategoryDisplay {
                category?: (POGOProtos.Enums.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);
            }

            class IapItemCategoryDisplay implements IIapItemCategoryDisplay {
                constructor(properties?: POGOProtos.Settings.Master.IIapItemCategoryDisplay);
                public category: POGOProtos.Enums.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 static encode(message: POGOProtos.Settings.Master.IIapItemCategoryDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.IapItemCategoryDisplay;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.IapItemCategoryDisplay;
                public static toObject(message: POGOProtos.Settings.Master.IapItemCategoryDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IIapItemDisplay {
                sku?: (string|null);
                category?: (POGOProtos.Enums.HoloIapItemCategory|null);
                sort_order?: (number|null);
                hidden?: (boolean|null);
                sale?: (boolean|null);
                sprite_id?: (string|null);
                title?: (string|null);
                description?: (string|null);
            }

            class IapItemDisplay implements IIapItemDisplay {
                constructor(properties?: POGOProtos.Settings.Master.IIapItemDisplay);
                public sku: string;
                public category: POGOProtos.Enums.HoloIapItemCategory;
                public sort_order: number;
                public hidden: boolean;
                public sale: boolean;
                public sprite_id: string;
                public title: string;
                public description: string;
                public static encode(message: POGOProtos.Settings.Master.IIapItemDisplay, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.IapItemDisplay;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.IapItemDisplay;
                public static toObject(message: POGOProtos.Settings.Master.IapItemDisplay, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IIapSettings {
                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);
            }

            class IapSettings implements IIapSettings {
                constructor(properties?: POGOProtos.Settings.Master.IIapSettings);
                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 static encode(message: POGOProtos.Settings.Master.IIapSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.IapSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.IapSettings;
                public static toObject(message: POGOProtos.Settings.Master.IapSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Item {

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

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

                interface IEggIncubatorAttributes {
                    incubator_type?: (POGOProtos.Inventory.EggIncubatorType|null);
                    uses?: (number|null);
                    distance_multiplier?: (number|null);
                }

                class EggIncubatorAttributes implements IEggIncubatorAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Item.IEggIncubatorAttributes);
                    public incubator_type: POGOProtos.Inventory.EggIncubatorType;
                    public uses: number;
                    public distance_multiplier: number;
                    public static encode(message: POGOProtos.Settings.Master.Item.IEggIncubatorAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Item.EggIncubatorAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Item.EggIncubatorAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Item.EggIncubatorAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IExperienceBoostAttributes {
                    xp_multiplier?: (number|null);
                    boost_duration_ms?: (number|null);
                }

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

                interface IFoodAttributes {
                    item_effect?: (POGOProtos.Enums.ItemEffect[]|null);
                    item_effect_percent?: (number[]|null);
                    growth_percent?: (number|null);
                    berry_multiplier?: (number|null);
                    remote_berry_multiplier?: (number|null);
                }

                class FoodAttributes implements IFoodAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Item.IFoodAttributes);
                    public item_effect: POGOProtos.Enums.ItemEffect[];
                    public item_effect_percent: number[];
                    public growth_percent: number;
                    public berry_multiplier: number;
                    public remote_berry_multiplier: number;
                    public static encode(message: POGOProtos.Settings.Master.Item.IFoodAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Item.FoodAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Item.FoodAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Item.FoodAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IFortModifierAttributes {
                    modifier_lifetime_seconds?: (number|null);
                    troy_disk_num_pokemon_spawned?: (number|null);
                }

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

                interface IIncenseAttributes {
                    incense_lifetime_seconds?: (number|null);
                    pokemon_type?: (POGOProtos.Enums.PokemonType[]|null);
                    pokemon_incense_type_probability?: (number|null);
                    standing_time_between_encounters_seconds?: (number|null);
                    moving_time_between_encounter_seconds?: (number|null);
                    distance_required_for_shorter_interval_meters?: (number|null);
                    pokemon_attracted_length_sec?: (number|null);
                    spawn_table?: (POGOProtos.Settings.Master.Item.IncenseAttributes.IIncensedPokemon[]|null);
                    spawn_table_probability?: (number|null);
                }

                class IncenseAttributes implements IIncenseAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Item.IIncenseAttributes);
                    public incense_lifetime_seconds: number;
                    public pokemon_type: POGOProtos.Enums.PokemonType[];
                    public pokemon_incense_type_probability: number;
                    public standing_time_between_encounters_seconds: number;
                    public moving_time_between_encounter_seconds: number;
                    public distance_required_for_shorter_interval_meters: number;
                    public pokemon_attracted_length_sec: number;
                    public spawn_table: POGOProtos.Settings.Master.Item.IncenseAttributes.IIncensedPokemon[];
                    public spawn_table_probability: number;
                    public static encode(message: POGOProtos.Settings.Master.Item.IIncenseAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Item.IncenseAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Item.IncenseAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Item.IncenseAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                namespace IncenseAttributes {

                    interface IIncensedPokemon {
                        pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                        weight?: (number|null);
                    }

                    class IncensedPokemon implements IIncensedPokemon {
                        constructor(properties?: POGOProtos.Settings.Master.Item.IncenseAttributes.IIncensedPokemon);
                        public pokemon_id: POGOProtos.Enums.PokemonId;
                        public weight: number;
                        public static encode(message: POGOProtos.Settings.Master.Item.IncenseAttributes.IIncensedPokemon, writer?: $protobuf.Writer): $protobuf.Writer;
                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Item.IncenseAttributes.IncensedPokemon;
                        public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Item.IncenseAttributes.IncensedPokemon;
                        public static toObject(message: POGOProtos.Settings.Master.Item.IncenseAttributes.IncensedPokemon, options?: $protobuf.IConversionOptions): { [k: string]: any };
                        public toJSON(): { [k: string]: any };
                    }
                }

                interface IInventoryUpgradeAttributes {
                    additional_storage?: (number|null);
                    upgrade_type?: (POGOProtos.Inventory.InventoryUpgradeType|null);
                }

                class InventoryUpgradeAttributes implements IInventoryUpgradeAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Item.IInventoryUpgradeAttributes);
                    public additional_storage: number;
                    public upgrade_type: POGOProtos.Inventory.InventoryUpgradeType;
                    public static encode(message: POGOProtos.Settings.Master.Item.IInventoryUpgradeAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Item.InventoryUpgradeAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Item.InventoryUpgradeAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Item.InventoryUpgradeAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IPokeballAttributes {
                    item_effect?: (POGOProtos.Enums.ItemEffect|null);
                    capture_multi?: (number|null);
                    capture_multi_effect?: (number|null);
                    item_effect_mod?: (number|null);
                }

                class PokeballAttributes implements IPokeballAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Item.IPokeballAttributes);
                    public item_effect: POGOProtos.Enums.ItemEffect;
                    public capture_multi: number;
                    public capture_multi_effect: number;
                    public item_effect_mod: number;
                    public static encode(message: POGOProtos.Settings.Master.Item.IPokeballAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Item.PokeballAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Item.PokeballAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Item.PokeballAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IPotionAttributes {
                    sta_percent?: (number|null);
                    sta_amount?: (number|null);
                }

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

                interface IReviveAttributes {
                    sta_percent?: (number|null);
                }

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

                interface IStardustBoostAttributes {
                    stardust_multiplier?: (number|null);
                    boost_duration_ms?: (number|null);
                }

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

            interface IItemSettings {
                item_id?: (POGOProtos.Inventory.Item.ItemId|null);
                item_type?: (POGOProtos.Inventory.Item.ItemType|null);
                category?: (POGOProtos.Enums.ItemCategory|null);
                drop_freq?: (number|null);
                drop_trainer_level?: (number|null);
                pokeball?: (POGOProtos.Settings.Master.Item.IPokeballAttributes|null);
                potion?: (POGOProtos.Settings.Master.Item.IPotionAttributes|null);
                revive?: (POGOProtos.Settings.Master.Item.IReviveAttributes|null);
                battle?: (POGOProtos.Settings.Master.Item.IBattleAttributes|null);
                food?: (POGOProtos.Settings.Master.Item.IFoodAttributes|null);
                inventory_upgrade?: (POGOProtos.Settings.Master.Item.IInventoryUpgradeAttributes|null);
                xp_boost?: (POGOProtos.Settings.Master.Item.IExperienceBoostAttributes|null);
                incense?: (POGOProtos.Settings.Master.Item.IIncenseAttributes|null);
                egg_incubator?: (POGOProtos.Settings.Master.Item.IEggIncubatorAttributes|null);
                fort_modifier?: (POGOProtos.Settings.Master.Item.IFortModifierAttributes|null);
                stardust_boost?: (POGOProtos.Settings.Master.Item.IStardustBoostAttributes|null);
            }

            class ItemSettings implements IItemSettings {
                constructor(properties?: POGOProtos.Settings.Master.IItemSettings);
                public item_id: POGOProtos.Inventory.Item.ItemId;
                public item_type: POGOProtos.Inventory.Item.ItemType;
                public category: POGOProtos.Enums.ItemCategory;
                public drop_freq: number;
                public drop_trainer_level: number;
                public pokeball?: (POGOProtos.Settings.Master.Item.IPokeballAttributes|null);
                public potion?: (POGOProtos.Settings.Master.Item.IPotionAttributes|null);
                public revive?: (POGOProtos.Settings.Master.Item.IReviveAttributes|null);
                public battle?: (POGOProtos.Settings.Master.Item.IBattleAttributes|null);
                public food?: (POGOProtos.Settings.Master.Item.IFoodAttributes|null);
                public inventory_upgrade?: (POGOProtos.Settings.Master.Item.IInventoryUpgradeAttributes|null);
                public xp_boost?: (POGOProtos.Settings.Master.Item.IExperienceBoostAttributes|null);
                public incense?: (POGOProtos.Settings.Master.Item.IIncenseAttributes|null);
                public egg_incubator?: (POGOProtos.Settings.Master.Item.IEggIncubatorAttributes|null);
                public fort_modifier?: (POGOProtos.Settings.Master.Item.IFortModifierAttributes|null);
                public stardust_boost?: (POGOProtos.Settings.Master.Item.IStardustBoostAttributes|null);
                public static encode(message: POGOProtos.Settings.Master.IItemSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.ItemSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.ItemSettings;
                public static toObject(message: POGOProtos.Settings.Master.ItemSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ILuckyPokemonSettings {
                power_up_stardust_discount_percent?: (number|null);
            }

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

            interface IMoveSequenceSettings {
                sequence?: (string[]|null);
            }

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

            interface IMoveSettings {
                movement_id?: (POGOProtos.Enums.PokemonMove|null);
                animation_id?: (number|null);
                pokemon_type?: (POGOProtos.Enums.PokemonType|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);
            }

            class MoveSettings implements IMoveSettings {
                constructor(properties?: POGOProtos.Settings.Master.IMoveSettings);
                public movement_id: POGOProtos.Enums.PokemonMove;
                public animation_id: number;
                public pokemon_type: POGOProtos.Enums.PokemonType;
                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 static encode(message: POGOProtos.Settings.Master.IMoveSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.MoveSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.MoveSettings;
                public static toObject(message: POGOProtos.Settings.Master.MoveSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOnboardingSettings {
                skip_avatar_customization?: (boolean|null);
                disable_initial_ar_prompt?: (boolean|null);
                ar_prompt_player_level?: (number|null);
            }

            class OnboardingSettings implements IOnboardingSettings {
                constructor(properties?: POGOProtos.Settings.Master.IOnboardingSettings);
                public skip_avatar_customization: boolean;
                public disable_initial_ar_prompt: boolean;
                public ar_prompt_player_level: number;
                public static encode(message: POGOProtos.Settings.Master.IOnboardingSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.OnboardingSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.OnboardingSettings;
                public static toObject(message: POGOProtos.Settings.Master.OnboardingSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IOnboardingV2Settings {
                enable_onboarding_v2?: (boolean|null);
                pokedex_id?: (POGOProtos.Enums.PokemonId[]|null);
                onboarding_egg_pokemon?: (POGOProtos.Enums.PokemonId|null);
                egg_km_until_hatch?: (number|null);
            }

            class OnboardingV2Settings implements IOnboardingV2Settings {
                constructor(properties?: POGOProtos.Settings.Master.IOnboardingV2Settings);
                public enable_onboarding_v2: boolean;
                public pokedex_id: POGOProtos.Enums.PokemonId[];
                public onboarding_egg_pokemon: POGOProtos.Enums.PokemonId;
                public egg_km_until_hatch: number;
                public static encode(message: POGOProtos.Settings.Master.IOnboardingV2Settings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.OnboardingV2Settings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.OnboardingV2Settings;
                public static toObject(message: POGOProtos.Settings.Master.OnboardingV2Settings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IPartyRecommendationSettings {
                mode?: (POGOProtos.Settings.Master.PartyRecommendationSettings.PartyRcommendationMode|null);
                variance?: (number|null);
                third_move_weight?: (number|null);
            }

            class PartyRecommendationSettings implements IPartyRecommendationSettings {
                constructor(properties?: POGOProtos.Settings.Master.IPartyRecommendationSettings);
                public mode: POGOProtos.Settings.Master.PartyRecommendationSettings.PartyRcommendationMode;
                public variance: number;
                public third_move_weight: number;
                public static encode(message: POGOProtos.Settings.Master.IPartyRecommendationSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.PartyRecommendationSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.PartyRecommendationSettings;
                public static toObject(message: POGOProtos.Settings.Master.PartyRecommendationSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PartyRecommendationSettings {

                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 IPlayerLevelSettings {
                rank_num?: (number[]|null);
                required_experience?: (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);
            }

            class PlayerLevelSettings implements IPlayerLevelSettings {
                constructor(properties?: POGOProtos.Settings.Master.IPlayerLevelSettings);
                public rank_num: number[];
                public required_experience: 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 static encode(message: POGOProtos.Settings.Master.IPlayerLevelSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.PlayerLevelSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.PlayerLevelSettings;
                public static toObject(message: POGOProtos.Settings.Master.PlayerLevelSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Pokemon {

                interface IAnimationOverride {
                    animation?: (POGOProtos.Settings.Master.Pokemon.AnimationOverride.PokemonAnim|null);
                    blacklist?: (boolean|null);
                    anim_min?: (number|null);
                    anim_max?: (number|null);
                }

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

                namespace AnimationOverride {

                    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 ICameraAttributes {
                    disk_radius_m?: (number|null);
                    cylinder_radius_m?: (number|null);
                    cylinder_height_m?: (number|null);
                    cylinder_ground_m?: (number|null);
                    shoulder_mode_scale?: (number|null);
                }

                class CameraAttributes implements ICameraAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Pokemon.ICameraAttributes);
                    public disk_radius_m: number;
                    public cylinder_radius_m: number;
                    public cylinder_height_m: number;
                    public cylinder_ground_m: number;
                    public shoulder_mode_scale: number;
                    public static encode(message: POGOProtos.Settings.Master.Pokemon.ICameraAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Pokemon.CameraAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Pokemon.CameraAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Pokemon.CameraAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IEncounterAttributes {
                    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.Enums.PokemonMovementType|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);
                }

                class EncounterAttributes implements IEncounterAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Pokemon.IEncounterAttributes);
                    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.Enums.PokemonMovementType;
                    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 static encode(message: POGOProtos.Settings.Master.Pokemon.IEncounterAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Pokemon.EncounterAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Pokemon.EncounterAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Pokemon.EncounterAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IEvolutionBranch {
                    evolution?: (POGOProtos.Enums.PokemonId|null);
                    evolution_item_requirement?: (POGOProtos.Inventory.Item.ItemId|null);
                    candy_cost?: (number|null);
                    km_buddy_distance_requirement?: (number|null);
                    form?: (POGOProtos.Enums.Form|null);
                    gender_requirement?: (POGOProtos.Enums.Gender|null);
                }

                class EvolutionBranch implements IEvolutionBranch {
                    constructor(properties?: POGOProtos.Settings.Master.Pokemon.IEvolutionBranch);
                    public evolution: POGOProtos.Enums.PokemonId;
                    public evolution_item_requirement: POGOProtos.Inventory.Item.ItemId;
                    public candy_cost: number;
                    public km_buddy_distance_requirement: number;
                    public form: POGOProtos.Enums.Form;
                    public gender_requirement: POGOProtos.Enums.Gender;
                    public static encode(message: POGOProtos.Settings.Master.Pokemon.IEvolutionBranch, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Pokemon.EvolutionBranch;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Pokemon.EvolutionBranch;
                    public static toObject(message: POGOProtos.Settings.Master.Pokemon.EvolutionBranch, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IPokemonGenderSettings {
                    male_percent?: (number|null);
                    female_percent?: (number|null);
                    genderless_percent?: (number|null);
                }

                class PokemonGenderSettings implements IPokemonGenderSettings {
                    constructor(properties?: POGOProtos.Settings.Master.Pokemon.IPokemonGenderSettings);
                    public male_percent: number;
                    public female_percent: number;
                    public genderless_percent: number;
                    public static encode(message: POGOProtos.Settings.Master.Pokemon.IPokemonGenderSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Pokemon.PokemonGenderSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Pokemon.PokemonGenderSettings;
                    public static toObject(message: POGOProtos.Settings.Master.Pokemon.PokemonGenderSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }

                interface IStatsAttributes {
                    base_stamina?: (number|null);
                    base_attack?: (number|null);
                    base_defense?: (number|null);
                    dodge_energy_delta?: (number|null);
                }

                class StatsAttributes implements IStatsAttributes {
                    constructor(properties?: POGOProtos.Settings.Master.Pokemon.IStatsAttributes);
                    public base_stamina: number;
                    public base_attack: number;
                    public base_defense: number;
                    public dodge_energy_delta: number;
                    public static encode(message: POGOProtos.Settings.Master.Pokemon.IStatsAttributes, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Pokemon.StatsAttributes;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Pokemon.StatsAttributes;
                    public static toObject(message: POGOProtos.Settings.Master.Pokemon.StatsAttributes, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IPokemonScaleSetting {
                pokemon_scale_mode?: (POGOProtos.Settings.Master.PokemonScaleSetting.PokemonScaleMode|null);
                min_height?: (number|null);
                max_height?: (number|null);
            }

            class PokemonScaleSetting implements IPokemonScaleSetting {
                constructor(properties?: POGOProtos.Settings.Master.IPokemonScaleSetting);
                public pokemon_scale_mode: POGOProtos.Settings.Master.PokemonScaleSetting.PokemonScaleMode;
                public min_height: number;
                public max_height: number;
                public static encode(message: POGOProtos.Settings.Master.IPokemonScaleSetting, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.PokemonScaleSetting;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.PokemonScaleSetting;
                public static toObject(message: POGOProtos.Settings.Master.PokemonScaleSetting, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PokemonScaleSetting {

                enum PokemonScaleMode {
                    NaturalScale = 0,
                    GuiScale = 1,
                    BattlePokemonScale = 2,
                    RaidBossScale = 3,
                    GymTopperScale = 4,
                    MapPokemonScale = 5
                }
            }

            interface IPokemonSettings {
                pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                model_scale?: (number|null);
                type?: (POGOProtos.Enums.PokemonType|null);
                type_2?: (POGOProtos.Enums.PokemonType|null);
                camera?: (POGOProtos.Settings.Master.Pokemon.ICameraAttributes|null);
                encounter?: (POGOProtos.Settings.Master.Pokemon.IEncounterAttributes|null);
                stats?: (POGOProtos.Settings.Master.Pokemon.IStatsAttributes|null);
                quick_moves?: (POGOProtos.Enums.PokemonMove[]|null);
                cinematic_moves?: (POGOProtos.Enums.PokemonMove[]|null);
                animation_time?: (number[]|null);
                evolution_ids?: (POGOProtos.Enums.PokemonId[]|null);
                evolution_pips?: (number|null);
                rarity?: (POGOProtos.Enums.PokemonRarity|null);
                pokedex_height_m?: (number|null);
                pokedex_weight_kg?: (number|null);
                parent_pokemon_id?: (POGOProtos.Enums.PokemonId|null);
                height_std_dev?: (number|null);
                weight_std_dev?: (number|null);
                km_distance_to_hatch?: (number|null);
                family_id?: (POGOProtos.Enums.PokemonFamilyId|null);
                candy_to_evolve?: (number|null);
                km_buddy_distance?: (number|null);
                buddy_size?: (POGOProtos.Enums.BuddySize|null);
                model_height?: (number|null);
                evolution_branch?: (POGOProtos.Settings.Master.Pokemon.IEvolutionBranch[]|null);
                model_scale_v2?: (number|null);
                form?: (POGOProtos.Enums.Form|null);
                event_quick_move?: (POGOProtos.Enums.PokemonMove|null);
                event_cinematic_move?: (POGOProtos.Enums.PokemonMove|null);
                buddy_offset_male?: (number[]|null);
                buddy_offset_female?: (number[]|null);
                buddy_scale?: (number|null);
                buddy_portrait_offset?: (number[]|null);
                parent_form?: (POGOProtos.Enums.Form|null);
                third_move?: (POGOProtos.Settings.Master.PokemonSettings.IPokemonThirdMoveAttributes|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.Settings.Master.Pokemon.IAnimationOverride[]|null);
            }

            class PokemonSettings implements IPokemonSettings {
                constructor(properties?: POGOProtos.Settings.Master.IPokemonSettings);
                public pokemon_id: POGOProtos.Enums.PokemonId;
                public model_scale: number;
                public type: POGOProtos.Enums.PokemonType;
                public type_2: POGOProtos.Enums.PokemonType;
                public camera?: (POGOProtos.Settings.Master.Pokemon.ICameraAttributes|null);
                public encounter?: (POGOProtos.Settings.Master.Pokemon.IEncounterAttributes|null);
                public stats?: (POGOProtos.Settings.Master.Pokemon.IStatsAttributes|null);
                public quick_moves: POGOProtos.Enums.PokemonMove[];
                public cinematic_moves: POGOProtos.Enums.PokemonMove[];
                public animation_time: number[];
                public evolution_ids: POGOProtos.Enums.PokemonId[];
                public evolution_pips: number;
                public rarity: POGOProtos.Enums.PokemonRarity;
                public pokedex_height_m: number;
                public pokedex_weight_kg: number;
                public parent_pokemon_id: POGOProtos.Enums.PokemonId;
                public height_std_dev: number;
                public weight_std_dev: number;
                public km_distance_to_hatch: number;
                public family_id: POGOProtos.Enums.PokemonFamilyId;
                public candy_to_evolve: number;
                public km_buddy_distance: number;
                public buddy_size: POGOProtos.Enums.BuddySize;
                public model_height: number;
                public evolution_branch: POGOProtos.Settings.Master.Pokemon.IEvolutionBranch[];
                public model_scale_v2: number;
                public form: POGOProtos.Enums.Form;
                public event_quick_move: POGOProtos.Enums.PokemonMove;
                public event_cinematic_move: POGOProtos.Enums.PokemonMove;
                public buddy_offset_male: number[];
                public buddy_offset_female: number[];
                public buddy_scale: number;
                public buddy_portrait_offset: number[];
                public parent_form: POGOProtos.Enums.Form;
                public third_move?: (POGOProtos.Settings.Master.PokemonSettings.IPokemonThirdMoveAttributes|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.Settings.Master.Pokemon.IAnimationOverride[];
                public static encode(message: POGOProtos.Settings.Master.IPokemonSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.PokemonSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.PokemonSettings;
                public static toObject(message: POGOProtos.Settings.Master.PokemonSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace PokemonSettings {

                interface IPokemonThirdMoveAttributes {
                    stardust_to_unlock?: (number|null);
                    candy_to_unlock?: (number|null);
                }

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

            interface IPokemonUpgradeSettings {
                upgrades_per_level?: (number|null);
                allowed_levels_above_player?: (number|null);
                candy_cost?: (number[]|null);
                stardust_cost?: (number[]|null);
            }

            class PokemonUpgradeSettings implements IPokemonUpgradeSettings {
                constructor(properties?: POGOProtos.Settings.Master.IPokemonUpgradeSettings);
                public upgrades_per_level: number;
                public allowed_levels_above_player: number;
                public candy_cost: number[];
                public stardust_cost: number[];
                public static encode(message: POGOProtos.Settings.Master.IPokemonUpgradeSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.PokemonUpgradeSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.PokemonUpgradeSettings;
                public static toObject(message: POGOProtos.Settings.Master.PokemonUpgradeSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            namespace Quest {

                interface IDailyQuestSettings {
                    buckets_per_day?: (number|null);
                    streak_length?: (number|null);
                    bonus_multiplier?: (number|null);
                    streak_bonus_multiplier?: (number|null);
                }

                class DailyQuestSettings implements IDailyQuestSettings {
                    constructor(properties?: POGOProtos.Settings.Master.Quest.IDailyQuestSettings);
                    public buckets_per_day: number;
                    public streak_length: number;
                    public bonus_multiplier: number;
                    public streak_bonus_multiplier: number;
                    public static encode(message: POGOProtos.Settings.Master.Quest.IDailyQuestSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.Quest.DailyQuestSettings;
                    public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.Quest.DailyQuestSettings;
                    public static toObject(message: POGOProtos.Settings.Master.Quest.DailyQuestSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                    public toJSON(): { [k: string]: any };
                }
            }

            interface IQuestSettings {
                quest_type?: (POGOProtos.Enums.QuestType|null);
                daily_quest?: (POGOProtos.Settings.Master.Quest.IDailyQuestSettings|null);
            }

            class QuestSettings implements IQuestSettings {
                constructor(properties?: POGOProtos.Settings.Master.IQuestSettings);
                public quest_type: POGOProtos.Enums.QuestType;
                public daily_quest?: (POGOProtos.Settings.Master.Quest.IDailyQuestSettings|null);
                public static encode(message: POGOProtos.Settings.Master.IQuestSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.QuestSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.QuestSettings;
                public static toObject(message: POGOProtos.Settings.Master.QuestSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ISmeargleMovesSettings {
                quick_moves?: (POGOProtos.Enums.PokemonMove[]|null);
                cinematic_moves?: (POGOProtos.Enums.PokemonMove[]|null);
            }

            class SmeargleMovesSettings implements ISmeargleMovesSettings {
                constructor(properties?: POGOProtos.Settings.Master.ISmeargleMovesSettings);
                public quick_moves: POGOProtos.Enums.PokemonMove[];
                public cinematic_moves: POGOProtos.Enums.PokemonMove[];
                public static encode(message: POGOProtos.Settings.Master.ISmeargleMovesSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.SmeargleMovesSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.SmeargleMovesSettings;
                public static toObject(message: POGOProtos.Settings.Master.SmeargleMovesSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface ITypeEffectiveSettings {
                attack_scalar?: (number[]|null);
                attack_type?: (POGOProtos.Enums.PokemonType|null);
            }

            class TypeEffectiveSettings implements ITypeEffectiveSettings {
                constructor(properties?: POGOProtos.Settings.Master.ITypeEffectiveSettings);
                public attack_scalar: number[];
                public attack_type: POGOProtos.Enums.PokemonType;
                public static encode(message: POGOProtos.Settings.Master.ITypeEffectiveSettings, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.TypeEffectiveSettings;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.TypeEffectiveSettings;
                public static toObject(message: POGOProtos.Settings.Master.TypeEffectiveSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWeatherAffinity {
                weather_condition?: (POGOProtos.Enums.WeatherCondition|null);
                pokemon_type?: (POGOProtos.Enums.PokemonType[]|null);
            }

            class WeatherAffinity implements IWeatherAffinity {
                constructor(properties?: POGOProtos.Settings.Master.IWeatherAffinity);
                public weather_condition: POGOProtos.Enums.WeatherCondition;
                public pokemon_type: POGOProtos.Enums.PokemonType[];
                public static encode(message: POGOProtos.Settings.Master.IWeatherAffinity, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.WeatherAffinity;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.WeatherAffinity;
                public static toObject(message: POGOProtos.Settings.Master.WeatherAffinity, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }

            interface IWeatherBonus {
                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);
            }

            class WeatherBonus implements IWeatherBonus {
                constructor(properties?: POGOProtos.Settings.Master.IWeatherBonus);
                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 static encode(message: POGOProtos.Settings.Master.IWeatherBonus, writer?: $protobuf.Writer): $protobuf.Writer;
                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.Master.WeatherBonus;
                public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.Master.WeatherBonus;
                public static toObject(message: POGOProtos.Settings.Master.WeatherBonus, options?: $protobuf.IConversionOptions): { [k: string]: any };
                public toJSON(): { [k: string]: any };
            }
        }

        interface INewsGlobalSettings {
            enable_news?: (boolean|null);
        }

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

        interface INewsSettings {
            news?: (POGOProtos.Settings.NewsSettings.INews[]|null);
        }

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

        namespace NewsSettings {

            interface INews {
                news_bundle_id?: (string|null);
                exclusive_countries?: (string[]|null);
            }

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

        interface INotificationSettings {
            pull_notifications?: (boolean|null);
            show_notifications?: (boolean|null);
        }

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

        interface IPasscodeSettings {
            show_passcode_in_store?: (boolean|null);
        }

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

        interface IPoiGlobalSettings {
            is_enabled?: (boolean|null);
        }

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

        interface IPokecoinPurchaseDisplaySettings {
            feature_enabled?: (boolean|null);
            enabled_countries?: (string[]|null);
        }

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

        interface IPokemonGlobalSettings {
            enable_camo_shader?: (boolean|null);
        }

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

        interface IProbeSettings {
            enable_sidechannel?: (boolean|null);
            enable_adhoc?: (boolean|null);
            adhoc_frequency_sec?: (number|null);
        }

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

        interface IQuestGlobalSettings {
            enable_quests?: (boolean|null);
            max_challenge_quests?: (number|null);
        }

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

        interface ISfidaSettings {
            low_battery_threshold?: (number|null);
        }

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

        interface ISocialClientSettings {
            enable_social?: (boolean|null);
            max_friend_details?: (number|null);
            player_level_gate?: (number|null);
            max_friend_nickname_length?: (number|null);
            enable_add_friend_via_qr_code?: (boolean|null);
            enable_share_ex_pass?: (boolean|null);
            enable_facebook_friends?: (boolean|null);
            facebook_friend_limit_per_request?: (number|null);
            disable_facebook_friends_opening_prompt?: (boolean|null);
        }

        class SocialClientSettings implements ISocialClientSettings {
            constructor(properties?: POGOProtos.Settings.ISocialClientSettings);
            public enable_social: boolean;
            public max_friend_details: number;
            public player_level_gate: number;
            public max_friend_nickname_length: number;
            public enable_add_friend_via_qr_code: boolean;
            public enable_share_ex_pass: boolean;
            public enable_facebook_friends: boolean;
            public facebook_friend_limit_per_request: number;
            public disable_facebook_friends_opening_prompt: boolean;
            public static encode(message: POGOProtos.Settings.ISocialClientSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.SocialClientSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.SocialClientSettings;
            public static toObject(message: POGOProtos.Settings.SocialClientSettings, 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.Settings.ISocialGiftCountTelemetry);
            public unopened_gift_count: number;
            public unsent_gift_count: number;
            public static encode(message: POGOProtos.Settings.ISocialGiftCountTelemetry, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.SocialGiftCountTelemetry;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.SocialGiftCountTelemetry;
            public static toObject(message: POGOProtos.Settings.SocialGiftCountTelemetry, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface ITelemetryGlobalSettings {
            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);
        }

        class TelemetryGlobalSettings implements ITelemetryGlobalSettings {
            constructor(properties?: POGOProtos.Settings.ITelemetryGlobalSettings);
            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 static encode(message: POGOProtos.Settings.ITelemetryGlobalSettings, writer?: $protobuf.Writer): $protobuf.Writer;
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): POGOProtos.Settings.TelemetryGlobalSettings;
            public static fromObject(object: { [k: string]: any }): POGOProtos.Settings.TelemetryGlobalSettings;
            public static toObject(message: POGOProtos.Settings.TelemetryGlobalSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };
            public toJSON(): { [k: string]: any };
        }

        interface IThirdMoveGlobalSettings {
            unlock_enabled?: (boolean|null);
        }

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

        interface ITradingGlobalSettings {
            enable_trading?: (boolean|null);
            min_player_level?: (number|null);
        }

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

        interface ITranslationSettings {
            translation_bundle_ids?: (string[]|null);
        }

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

        interface IUpsightLoggingSettings {
            use_verbose_logging?: (boolean|null);
            logging_percentage?: (number|null);
            disable_logging?: (boolean|null);
        }

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