import { z } from 'zod';
export declare const weakUUIDSchema: z.ZodString;
export declare const stringBooleanSchema: z.ZodEffects<z.ZodString, boolean, string>;
export declare const playerUUIDSchema: z.ZodString;
export declare const matchIDSchema: z.ZodString;
export declare const pregameIDSchema: z.ZodString;
export declare const currentGameIDSchema: z.ZodString;
export declare const partyIDSchema: z.ZodString;
export declare const gameModeSchema: z.ZodString;
export declare const dateSchema: z.ZodEffects<z.ZodString, Date, string>;
export declare const millisSchema: z.ZodEffects<z.ZodNumber, Date, number>;
export declare const seasonIDSchema: z.ZodString;
export declare const queueIDSchema: z.ZodString;
export declare const mapIDSchema: z.ZodString;
export declare const characterIDSchema: z.ZodString;
export declare const cardIDSchema: z.ZodString;
export declare const titleIDSchema: z.ZodString;
export declare const preferredLevelBorderIDSchema: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
export declare const xpModificationIDSchema: z.ZodString;
export declare const itemIDSchema: z.ZodString;
export declare const itemTypeIDSchema: z.ZodString;
export declare const armorIDSchema: z.ZodString;
export declare const currencyIDSchema: z.ZodString;
export declare const platformSchema: z.ZodObject<{
    platformType: z.ZodLiteral<"PC">;
    platformOS: z.ZodLiteral<"Windows">;
    platformOSVersion: z.ZodString;
    platformChipset: z.ZodLiteral<"Unknown">;
}, "strip", z.ZodTypeAny, {
    platformType: "PC";
    platformOS: "Windows";
    platformOSVersion: string;
    platformChipset: "Unknown";
}, {
    platformType: "PC";
    platformOS: "Windows";
    platformOSVersion: string;
    platformChipset: "Unknown";
}>;
export declare const partySchema: z.ZodObject<{
    ID: z.ZodString;
    MUCName: z.ZodString;
    VoiceRoomID: z.ZodString;
    Version: z.ZodNumber;
    ClientVersion: z.ZodString;
    Members: z.ZodArray<z.ZodObject<{
        Subject: z.ZodString;
        CompetitiveTier: z.ZodNumber;
        PlayerIdentity: z.ZodObject<{
            Subject: z.ZodString;
            PlayerCardID: z.ZodString;
            PlayerTitleID: z.ZodString;
            AccountLevel: z.ZodNumber;
            PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
            Incognito: z.ZodBoolean;
            HideAccountLevel: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        }, {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        }>;
        SeasonalBadgeInfo: z.ZodNull;
        IsOwner: z.ZodOptional<z.ZodBoolean>;
        QueueEligibleRemainingAccountLevels: z.ZodNumber;
        Pings: z.ZodArray<z.ZodObject<{
            Ping: z.ZodNumber;
            GamePodID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            Ping: number;
            GamePodID: string;
        }, {
            Ping: number;
            GamePodID: string;
        }>, "many">;
        IsReady: z.ZodBoolean;
        IsModerator: z.ZodBoolean;
        UseBroadcastHUD: z.ZodBoolean;
        PlatformType: z.ZodLiteral<"PC">;
    }, "strip", z.ZodTypeAny, {
        IsOwner?: boolean | undefined;
        Subject: string;
        CompetitiveTier: number;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            Ping: number;
            GamePodID: string;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
    }, {
        IsOwner?: boolean | undefined;
        Subject: string;
        CompetitiveTier: number;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            Ping: number;
            GamePodID: string;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
    }>, "many">;
    State: z.ZodString;
    PreviousState: z.ZodString;
    StateTransitionReason: z.ZodString;
    Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
    CustomGameData: z.ZodObject<{
        Settings: z.ZodObject<{
            Map: z.ZodString;
            Mode: z.ZodString;
            UseBots: z.ZodBoolean;
            GamePod: z.ZodString;
            GameRules: z.ZodNullable<z.ZodObject<{
                AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
            }, "strip", z.ZodTypeAny, {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            }, {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            } | null;
        }, {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            } | null;
        }>;
        Membership: z.ZodObject<{
            teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        }, {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        }>;
        MaxPartySize: z.ZodNumber;
        AutobalanceEnabled: z.ZodBoolean;
        AutobalanceMinPlayers: z.ZodNumber;
        HasRecoveryData: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        Settings: {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            } | null;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        MaxPartySize: number;
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    }, {
        Settings: {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            } | null;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        MaxPartySize: number;
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    }>;
    MatchmakingData: z.ZodObject<{
        QueueID: z.ZodString;
        PreferredGamePods: z.ZodArray<z.ZodString, "many">;
        SkillDisparityRRPenalty: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    }, {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    }>;
    Invites: z.ZodNull;
    Requests: z.ZodArray<z.ZodUnknown, "many">;
    QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
    ErrorNotification: z.ZodObject<{
        ErrorType: z.ZodString;
        ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
        }, {
            Subject: string;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    }, {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    }>;
    RestrictedSeconds: z.ZodNumber;
    EligibleQueues: z.ZodArray<z.ZodString, "many">;
    QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
    CheatData: z.ZodObject<{
        GamePodOverride: z.ZodString;
        ForcePostGameProcessing: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    }, {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    }>;
    XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
    InviteCode: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ID: string;
    MUCName: string;
    VoiceRoomID: string;
    Version: number;
    ClientVersion: string;
    Members: {
        IsOwner?: boolean | undefined;
        Subject: string;
        CompetitiveTier: number;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            Ping: number;
            GamePodID: string;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
    }[];
    State: string;
    PreviousState: string;
    StateTransitionReason: string;
    Accessibility: "OPEN" | "CLOSED";
    CustomGameData: {
        Settings: {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            } | null;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        MaxPartySize: number;
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    };
    MatchmakingData: {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    };
    Invites: null;
    Requests: unknown[];
    QueueEntryTime: Date;
    ErrorNotification: {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    };
    RestrictedSeconds: number;
    EligibleQueues: string[];
    QueueIneligibilities: string[];
    CheatData: {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    };
    XPBonuses: unknown[];
    InviteCode: string;
}, {
    ID: string;
    MUCName: string;
    VoiceRoomID: string;
    Version: number;
    ClientVersion: string;
    Members: {
        IsOwner?: boolean | undefined;
        Subject: string;
        CompetitiveTier: number;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            Ping: number;
            GamePodID: string;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
    }[];
    State: string;
    PreviousState: string;
    StateTransitionReason: string;
    Accessibility: "OPEN" | "CLOSED";
    CustomGameData: {
        Settings: {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            } | null;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        MaxPartySize: number;
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    };
    MatchmakingData: {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    };
    Invites: null;
    Requests: unknown[];
    QueueEntryTime: string;
    ErrorNotification: {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    };
    RestrictedSeconds: number;
    EligibleQueues: string[];
    QueueIneligibilities: string[];
    CheatData: {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    };
    XPBonuses: unknown[];
    InviteCode: string;
}>;
export declare const offerSchema: z.ZodObject<{
    OfferID: z.ZodString;
    IsDirectPurchase: z.ZodBoolean;
    StartDate: z.ZodEffects<z.ZodString, Date, string>;
    Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
    Rewards: z.ZodArray<z.ZodObject<{
        ItemTypeID: z.ZodString;
        ItemID: z.ZodString;
        Quantity: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        ItemTypeID: string;
        ItemID: string;
        Quantity: number;
    }, {
        ItemTypeID: string;
        ItemID: string;
        Quantity: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    OfferID: string;
    IsDirectPurchase: boolean;
    StartDate: Date;
    Cost: Record<string, number>;
    Rewards: {
        ItemTypeID: string;
        ItemID: string;
        Quantity: number;
    }[];
}, {
    OfferID: string;
    IsDirectPurchase: boolean;
    StartDate: string;
    Cost: Record<string, number>;
    Rewards: {
        ItemTypeID: string;
        ItemID: string;
        Quantity: number;
    }[];
}>;
export declare const pregameMatchSchema: z.ZodObject<{
    ID: z.ZodString;
    Version: z.ZodNumber;
    Teams: z.ZodArray<z.ZodObject<{
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        Players: z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
            CharacterID: z.ZodString;
            CharacterSelectionState: z.ZodEnum<["", "selected", "locked"]>;
            PregamePlayerState: z.ZodEnum<["joined"]>;
            CompetitiveTier: z.ZodNumber;
            PlayerIdentity: z.ZodObject<{
                Subject: z.ZodString;
                PlayerCardID: z.ZodString;
                PlayerTitleID: z.ZodString;
                AccountLevel: z.ZodNumber;
                PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                Incognito: z.ZodBoolean;
                HideAccountLevel: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }>;
            SeasonalBadgeInfo: z.ZodObject<{
                SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                NumberOfWins: z.ZodNumber;
                WinsByTier: z.ZodNull;
                Rank: z.ZodNumber;
                LeaderboardRank: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }>;
            IsCaptain: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }, {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }, {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }>, "many">;
    AllyTeam: z.ZodNullable<z.ZodObject<{
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        Players: z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
            CharacterID: z.ZodString;
            CharacterSelectionState: z.ZodEnum<["", "selected", "locked"]>;
            PregamePlayerState: z.ZodEnum<["joined"]>;
            CompetitiveTier: z.ZodNumber;
            PlayerIdentity: z.ZodObject<{
                Subject: z.ZodString;
                PlayerCardID: z.ZodString;
                PlayerTitleID: z.ZodString;
                AccountLevel: z.ZodNumber;
                PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                Incognito: z.ZodBoolean;
                HideAccountLevel: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }>;
            SeasonalBadgeInfo: z.ZodObject<{
                SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                NumberOfWins: z.ZodNumber;
                WinsByTier: z.ZodNull;
                Rank: z.ZodNumber;
                LeaderboardRank: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }>;
            IsCaptain: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }, {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }, {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }>>;
    EnemyTeam: z.ZodNullable<z.ZodObject<{
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        Players: z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
            CharacterID: z.ZodString;
            CharacterSelectionState: z.ZodEnum<["", "selected", "locked"]>;
            PregamePlayerState: z.ZodEnum<["joined"]>;
            CompetitiveTier: z.ZodNumber;
            PlayerIdentity: z.ZodObject<{
                Subject: z.ZodString;
                PlayerCardID: z.ZodString;
                PlayerTitleID: z.ZodString;
                AccountLevel: z.ZodNumber;
                PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                Incognito: z.ZodBoolean;
                HideAccountLevel: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }>;
            SeasonalBadgeInfo: z.ZodObject<{
                SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                NumberOfWins: z.ZodNumber;
                WinsByTier: z.ZodNull;
                Rank: z.ZodNumber;
                LeaderboardRank: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }>;
            IsCaptain: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }, {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }, {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }>>;
    ObserverSubjects: z.ZodArray<z.ZodUnknown, "many">;
    MatchCoaches: z.ZodArray<z.ZodUnknown, "many">;
    EnemyTeamSize: z.ZodNumber;
    EnemyTeamLockCount: z.ZodNumber;
    PregameState: z.ZodEnum<["character_select_active", "provisioned"]>;
    LastUpdated: z.ZodEffects<z.ZodString, Date, string>;
    MapID: z.ZodString;
    MapSelectPool: z.ZodArray<z.ZodUnknown, "many">;
    BannedMapIDs: z.ZodArray<z.ZodUnknown, "many">;
    CastedVotes: z.ZodUnknown;
    MapSelectSteps: z.ZodArray<z.ZodUnknown, "many">;
    MapSelectStep: z.ZodNumber;
    Team1: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
    GamePodID: z.ZodString;
    Mode: z.ZodString;
    VoiceSessionID: z.ZodString;
    MUCName: z.ZodString;
    TeamMatchToken: z.ZodString;
    QueueID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
    ProvisioningFlowID: z.ZodEnum<["Matchmaking", "CustomGame"]>;
    IsRanked: z.ZodBoolean;
    PhaseTimeRemainingNS: z.ZodNumber;
    StepTimeRemainingNS: z.ZodNumber;
    altModesFlagADA: z.ZodBoolean;
    TournamentMetadata: z.ZodNull;
    RosterMetadata: z.ZodNull;
}, "strip", z.ZodTypeAny, {
    CastedVotes?: unknown;
    ID: string;
    MUCName: string;
    Version: number;
    GamePodID: string;
    Mode: string;
    QueueID: string;
    Teams: {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }[];
    AllyTeam: {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    } | null;
    EnemyTeam: {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    } | null;
    ObserverSubjects: unknown[];
    MatchCoaches: unknown[];
    EnemyTeamSize: number;
    EnemyTeamLockCount: number;
    PregameState: "character_select_active" | "provisioned";
    LastUpdated: Date;
    MapID: string;
    MapSelectPool: unknown[];
    BannedMapIDs: unknown[];
    MapSelectSteps: unknown[];
    MapSelectStep: number;
    Team1: string;
    VoiceSessionID: string;
    TeamMatchToken: string;
    ProvisioningFlowID: "Matchmaking" | "CustomGame";
    IsRanked: boolean;
    PhaseTimeRemainingNS: number;
    StepTimeRemainingNS: number;
    altModesFlagADA: boolean;
    TournamentMetadata: null;
    RosterMetadata: null;
}, {
    CastedVotes?: unknown;
    ID: string;
    MUCName: string;
    Version: number;
    GamePodID: string;
    Mode: string;
    QueueID: string;
    Teams: {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    }[];
    AllyTeam: {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    } | null;
    EnemyTeam: {
        TeamID: string;
        Players: {
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CharacterID: string;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
    } | null;
    ObserverSubjects: unknown[];
    MatchCoaches: unknown[];
    EnemyTeamSize: number;
    EnemyTeamLockCount: number;
    PregameState: "character_select_active" | "provisioned";
    LastUpdated: string;
    MapID: string;
    MapSelectPool: unknown[];
    BannedMapIDs: unknown[];
    MapSelectSteps: unknown[];
    MapSelectStep: number;
    Team1: string;
    VoiceSessionID: string;
    TeamMatchToken: string;
    ProvisioningFlowID: "Matchmaking" | "CustomGame";
    IsRanked: boolean;
    PhaseTimeRemainingNS: number;
    StepTimeRemainingNS: number;
    altModesFlagADA: boolean;
    TournamentMetadata: null;
    RosterMetadata: null;
}>;
export declare const contractsResponse: z.ZodObject<{
    Version: z.ZodNumber;
    Subject: z.ZodString;
    Contracts: z.ZodArray<z.ZodObject<{
        ContractDefinitionID: z.ZodString;
        ContractProgression: z.ZodObject<{
            TotalProgressionEarned: z.ZodNumber;
            TotalProgressionEarnedVersion: z.ZodNumber;
            HighestRewardedLevel: z.ZodRecord<z.ZodString, z.ZodObject<{
                Amount: z.ZodNumber;
                Version: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                Version: number;
                Amount: number;
            }, {
                Version: number;
                Amount: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        }, {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        }>;
        ProgressionLevelReached: z.ZodNumber;
        ProgressionTowardsNextLevel: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }, {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }>, "many">;
    ProcessedMatches: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        StartTime: z.ZodEffects<z.ZodNumber, Date, number>;
        XPGrants: z.ZodNullable<z.ZodObject<{
            GamePlayed: z.ZodNumber;
            GameWon: z.ZodNumber;
            RoundPlayed: z.ZodNumber;
            RoundWon: z.ZodNumber;
            Missions: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
            Modifier: z.ZodObject<{
                Value: z.ZodNumber;
                BaseMultiplierValue: z.ZodNumber;
                Modifiers: z.ZodArray<z.ZodObject<{
                    Value: z.ZodNumber;
                    Name: z.ZodEnum<["RESTRICTIONS_XP", "PREMIUM_CONTRACT_XP"]>;
                    BaseOnly: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }, {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            }, {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            }>;
            NumAFKRounds: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        }, {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        }>>;
        RewardGrants: z.ZodNullable<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
        MissionDeltas: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
            ID: z.ZodString;
            Objectives: z.ZodRecord<z.ZodString, z.ZodNumber>;
            ObjectiveDeltas: z.ZodRecord<z.ZodString, z.ZodObject<{
                ID: z.ZodString;
                ProgressBefore: z.ZodNumber;
                ProgressAfter: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }>>>;
        ContractDeltas: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
            ID: z.ZodString;
            TotalXPBefore: z.ZodNumber;
            TotalXPAfter: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }>>>;
        CouldProgressMissions: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        StartTime: Date;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }, {
        ID: string;
        StartTime: number;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }>, "many">;
    ActiveSpecialContract: z.ZodString;
    Missions: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        Objectives: z.ZodRecord<z.ZodString, z.ZodNumber>;
        Complete: z.ZodBoolean;
        ExpirationTime: z.ZodEffects<z.ZodString, Date, string>;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: Date;
    }, {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: string;
    }>, "many">;
    MissionMetadata: z.ZodObject<{
        NPECompleted: z.ZodBoolean;
        WeeklyCheckpoint: z.ZodEffects<z.ZodString, Date, string>;
        WeeklyRefillTime: z.ZodEffects<z.ZodString, Date, string>;
    }, "strip", z.ZodTypeAny, {
        NPECompleted: boolean;
        WeeklyCheckpoint: Date;
        WeeklyRefillTime: Date;
    }, {
        NPECompleted: boolean;
        WeeklyCheckpoint: string;
        WeeklyRefillTime: string;
    }>;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    Contracts: {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }[];
    ProcessedMatches: {
        ID: string;
        StartTime: Date;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }[];
    Missions: {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: Date;
    }[];
    ActiveSpecialContract: string;
    MissionMetadata: {
        NPECompleted: boolean;
        WeeklyCheckpoint: Date;
        WeeklyRefillTime: Date;
    };
}, {
    Subject: string;
    Version: number;
    Contracts: {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }[];
    ProcessedMatches: {
        ID: string;
        StartTime: number;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }[];
    Missions: {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: string;
    }[];
    ActiveSpecialContract: string;
    MissionMetadata: {
        NPECompleted: boolean;
        WeeklyCheckpoint: string;
        WeeklyRefillTime: string;
    };
}>;
export declare const conversationsSchema: z.ZodObject<{
    conversations: z.ZodArray<z.ZodObject<{
        cid: z.ZodString;
        direct_messages: z.ZodBoolean;
        global_readership: z.ZodBoolean;
        message_history: z.ZodBoolean;
        mid: z.ZodString;
        muted: z.ZodBoolean;
        mutedRestriction: z.ZodBoolean;
        type: z.ZodEnum<["groupchat", "chat"]>;
        uiState: z.ZodObject<{
            changedSinceHidden: z.ZodBoolean;
            hidden: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            changedSinceHidden: boolean;
            hidden: boolean;
        }, {
            changedSinceHidden: boolean;
            hidden: boolean;
        }>;
        unread_count: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        type: "groupchat" | "chat";
        cid: string;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        muted: boolean;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }, {
        type: "groupchat" | "chat";
        cid: string;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        muted: boolean;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    conversations: {
        type: "groupchat" | "chat";
        cid: string;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        muted: boolean;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }[];
}, {
    conversations: {
        type: "groupchat" | "chat";
        cid: string;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        muted: boolean;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }[];
}>;
export declare const chatMessagesSchema: z.ZodObject<{
    messages: z.ZodArray<z.ZodObject<{
        body: z.ZodString;
        cid: z.ZodString;
        game_name: z.ZodString;
        game_tag: z.ZodString;
        id: z.ZodString;
        mid: z.ZodString;
        name: z.ZodString;
        pid: z.ZodString;
        puuid: z.ZodString;
        read: z.ZodBoolean;
        region: z.ZodString;
        time: z.ZodEffects<z.ZodString, Date, string>;
        type: z.ZodEnum<["chat", "groupchat"]>;
    }, "strip", z.ZodTypeAny, {
        type: "groupchat" | "chat";
        cid: string;
        mid: string;
        body: string;
        game_name: string;
        game_tag: string;
        id: string;
        name: string;
        pid: string;
        puuid: string;
        read: boolean;
        region: string;
        time: Date;
    }, {
        type: "groupchat" | "chat";
        cid: string;
        mid: string;
        body: string;
        game_name: string;
        game_tag: string;
        id: string;
        name: string;
        pid: string;
        puuid: string;
        read: boolean;
        region: string;
        time: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    messages: {
        type: "groupchat" | "chat";
        cid: string;
        mid: string;
        body: string;
        game_name: string;
        game_tag: string;
        id: string;
        name: string;
        pid: string;
        puuid: string;
        read: boolean;
        region: string;
        time: Date;
    }[];
}, {
    messages: {
        type: "groupchat" | "chat";
        cid: string;
        mid: string;
        body: string;
        game_name: string;
        game_tag: string;
        id: string;
        name: string;
        pid: string;
        puuid: string;
        read: boolean;
        region: string;
        time: string;
    }[];
}>;
export declare const loadoutsSchema: z.ZodObject<{
    Subject: z.ZodString;
    Sprays: z.ZodObject<{
        SpraySelections: z.ZodArray<z.ZodObject<{
            SocketID: z.ZodString;
            SprayID: z.ZodString;
            LevelID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            SocketID: string;
            SprayID: string;
            LevelID: string;
        }, {
            SocketID: string;
            SprayID: string;
            LevelID: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        SpraySelections: {
            SocketID: string;
            SprayID: string;
            LevelID: string;
        }[];
    }, {
        SpraySelections: {
            SocketID: string;
            SprayID: string;
            LevelID: string;
        }[];
    }>;
    Expressions: z.ZodObject<{
        AESSelections: z.ZodArray<z.ZodObject<{
            SocketID: z.ZodString;
            AssetID: z.ZodString;
            TypeID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            SocketID: string;
            AssetID: string;
            TypeID: string;
        }, {
            SocketID: string;
            AssetID: string;
            TypeID: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        AESSelections: {
            SocketID: string;
            AssetID: string;
            TypeID: string;
        }[];
    }, {
        AESSelections: {
            SocketID: string;
            AssetID: string;
            TypeID: string;
        }[];
    }>;
    Items: z.ZodRecord<z.ZodString, z.ZodObject<{
        ID: z.ZodString;
        TypeID: z.ZodString;
        Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
            ID: z.ZodString;
            Item: z.ZodObject<{
                ID: z.ZodString;
                TypeID: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                TypeID: string;
            }, {
                ID: string;
                TypeID: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Item: {
                ID: string;
                TypeID: string;
            };
        }, {
            ID: string;
            Item: {
                ID: string;
                TypeID: string;
            };
        }>>;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        TypeID: string;
        Sockets: Record<string, {
            ID: string;
            Item: {
                ID: string;
                TypeID: string;
            };
        }>;
    }, {
        ID: string;
        TypeID: string;
        Sockets: Record<string, {
            ID: string;
            Item: {
                ID: string;
                TypeID: string;
            };
        }>;
    }>>;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Sprays: {
        SpraySelections: {
            SocketID: string;
            SprayID: string;
            LevelID: string;
        }[];
    };
    Expressions: {
        AESSelections: {
            SocketID: string;
            AssetID: string;
            TypeID: string;
        }[];
    };
    Items: Record<string, {
        ID: string;
        TypeID: string;
        Sockets: Record<string, {
            ID: string;
            Item: {
                ID: string;
                TypeID: string;
            };
        }>;
    }>;
}, {
    Subject: string;
    Sprays: {
        SpraySelections: {
            SocketID: string;
            SprayID: string;
            LevelID: string;
        }[];
    };
    Expressions: {
        AESSelections: {
            SocketID: string;
            AssetID: string;
            TypeID: string;
        }[];
    };
    Items: Record<string, {
        ID: string;
        TypeID: string;
        Sockets: Record<string, {
            ID: string;
            Item: {
                ID: string;
                TypeID: string;
            };
        }>;
    }>;
}>;