import type { QueueId } from "@valapi/lib";
import type { PromiseResponse, ClientPlatfrom } from "@valapi/auth";
import { WebClientService } from "../client/WebClientService";
export declare namespace Party {
    namespace CustomGame {
        interface Settings {
            Map: string;
            Mode: string;
            UseBots: boolean;
            GamePod: string;
            GameRules: {
                AllowGameModifiers: `${boolean}`;
                PlayOutAllRounds: `${boolean}`;
                SkipMatchHistory: `${boolean}`;
                TournamentMode: `${boolean}`;
                IsOvertimeWinByTwo: `${boolean}`;
            };
        }
        type Team = "TeamTwo" | "TeamOne" | "TeamSpectate" | "TeamOneCoaches" | "TeamTwoCoaches";
        interface Member {
            Subject: string;
        }
        interface Config {
            Enabled: boolean;
            EnabledMaps: Array<string>;
            EnabledModes: Array<string>;
            Queues: Array<{
                QueueID: QueueId.ID;
                Enabled: boolean;
                TeamSize: number;
                NumTeams: number;
                MaxPartySize: number;
                MinPartySize: number;
                InvalidPartySizes: Array<number>;
                MaxPartySizeHighSkill: number;
                HighSkillTier: number;
                MaxSkillTier: number;
                AllowFullPartyBypassSkillRestrictions: boolean;
                ApplyRRPenaltyToFullParty: boolean;
                AllowFiveStackRestrictions: boolean;
                Mode: string;
                IsRanke: boolean;
                IsTournament: boolean;
                IsTournamentV2: boolean;
                RequireRoster: boolean;
                Priority: number;
                PartyMaxCompetitiveTierRange: number;
                PartyMaxCompetitiveTierRangePlacementBuffer: number;
                FullPartyMaxCompetitiveTierRange: number;
                PartySkillDisparityCompetitiveTiersCeilings: Record<`${number}`, number>;
                PartySkillDisparityPartySizeCompetitiveTiersCeilings: Record<`${number}`, Record<`${number}`, number>>;
                UseAccountLevelRequirement: boolean;
                MinimumAccountLevelRequired: number;
                GameRules: {
                    IsOvertimeWinByTwo: boolean;
                };
                SupportedPlatformTypes: Array<string>;
                DisabledContent: Array<any>;
                queueFieldA: Array<any>;
                NextScheduleChangeSeconds: number;
                TimeUntilNextScheduleChangeSeconds: number;
                MapWeights: Array<`${string}:${1 | 0}`>;
            }>;
        }
    }
    type Accessibility = "OPEN" | "CLOSED";
    interface GetPlayer {
        Subject: string;
        Version: number;
        CurrentPartyID: string;
        Invites: any;
        Requests: Array<any>;
        PlatformInfo: ClientPlatfrom;
    }
    interface Party {
        ID: string;
        MUCName: string;
        VoiceRoomID: string;
        Version: number;
        ClientVersion: string;
        Members: Array<{
            Subject: string;
            CompetitiveTier: number;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: any;
            IsOwner: boolean;
            QueueEligibleRemainingAccountLevels: number;
            Pings: Array<{
                Ping: number;
                GamePodID: string;
            }>;
            IsReady: boolean;
            IsModerator: boolean;
            UseBroadcastHUD: boolean;
            PlatformType: string;
        }>;
        State: string;
        PreviousState: string;
        StateTransitionReason: string;
        Accessibility: Party.Accessibility;
        CustomGameData: {
            Settings: Party.CustomGame.Settings;
            Membership: {
                teamOne: Array<Party.CustomGame.Member>;
                teamTwo: Array<Party.CustomGame.Member>;
                teamSpectate: Array<Party.CustomGame.Member>;
                teamOneCoaches: Array<Party.CustomGame.Member>;
                teamTwoCoaches: Array<Party.CustomGame.Member>;
            };
            MaxPartySize: number;
            AutobalanceEnabled: boolean;
            AutobalanceMinPlayers: number;
            HasRecoveryData: boolean;
        };
        MatchmakingData: {
            QueueID: QueueId.ID;
            PreferredGamePods: Array<string>;
            SkillDisparityRRPenalty: number;
        };
        Invites: any;
        Requests: Array<any>;
        QueueEntryTime: Date;
        ErrorNotification: {
            ErrorType: string;
            ErroredPlayers: any;
        };
        RestrictedSeconds: number;
        EligibleQueues: Array<QueueId.ID>;
        QueueIneligibilities: Array<any>;
        CheatData: {
            GamePodOverride: string;
            ForcePostGameProcessing: boolean;
        };
        XPBonuses: Array<{
            ID: string;
            Applied: boolean;
        }>;
        InviteCode: string;
    }
}
export declare class Party extends WebClientService {
    refreshCompetitiveTier(subject: string, partyId: string): PromiseResponse<any>;
    refreshPlayerIdentity(subject: string, partyId: string): PromiseResponse<any>;
    refreshPings(subject: string, partyId: string): PromiseResponse<any>;
    get(partyId: string): PromiseResponse<Party.Party>;
    getMUCToken(partyId: string): PromiseResponse<any>;
    getVoiceToken(partyId: string): PromiseResponse<any>;
    setAccessibility(partyId: string, accessibility: Party.Accessibility): PromiseResponse<any>;
    inviteByDisplayName(partyId: string, gameName: string, tagLine: string): PromiseResponse<any>;
    declineJoinRequest(partyId: string, requestId: string): PromiseResponse<any>;
    get MatchMaking(): MatchMaking;
    get Player(): Player;
    get CustomGame(): CustomGame;
    get PartyCode(): PartyCode;
}
export declare class MatchMaking extends WebClientService {
    /**
     * @param queueId Queue (EligibleQueues)
     */
    changeQueue(partyId: string, queueId: QueueId.ID): PromiseResponse<Party.Party>;
    makeDefaultQueue(partyId: string, queueId: QueueId.ID): PromiseResponse<Party.Party>;
    /**
     * ! Careful to use, Riot will immediately shut down your Project.
     * @deprecated Please, Contact us if you find out how its works
     */
    startSoloExperience(subject: string): PromiseResponse<any>;
    start(partyId: string): PromiseResponse<Party.Party>;
    leave(partyId: string): PromiseResponse<Party.Party>;
}
export declare class Player extends WebClientService {
    get(subject: string): PromiseResponse<Party.GetPlayer>;
    remove(subject: string): PromiseResponse<any>;
    joinParty(subject: string, partyId: string): PromiseResponse<any>;
    leaveParty(subject: string, partyId: string): PromiseResponse<any>;
    setReady(subject: string, partyId: string, isReady: boolean): PromiseResponse<Party.Party>;
    leaveFromParty(subject: string, partyId: string): PromiseResponse<any>;
    transferOwner(subject: string, partyId: string): PromiseResponse<any>;
}
export declare class CustomGame extends WebClientService {
    makeInto(partyId: string): PromiseResponse<Party.Party>;
    start(partyId: string): PromiseResponse<Party.Party>;
    changeSettings(partyId: string, settings: Party.CustomGame.Settings): PromiseResponse<Party.Party>;
    changeTeam(partyId: string, team: Party.CustomGame.Team, subject: string): PromiseResponse<Party.Party>;
    setBalance(partyId: string): PromiseResponse<any>;
    getConfig(): PromiseResponse<Party.CustomGame.Config>;
}
export declare class PartyCode extends WebClientService {
    create(partyId: string): PromiseResponse<Party.Party>;
    delete(partyId: string): PromiseResponse<Party.Party>;
    join(partyCode: string): PromiseResponse<Party.GetPlayer>;
}