pogo-protos/compiled.d.ts

Pokémon Go Protobuf files from POGOProtos, wrapped up in a Node module

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