import type { Collection } from '@discordjs/collection';
import type { PathLike } from 'fs';
import type defaultPartyMeta from './defaultPartyMeta.json';
import type defaultPartyMemberMeta from './defaultPartyMemberMeta.json';
import type EpicgamesAPIError from '../src/exceptions/EpicgamesAPIError';
import type BlockedUser from '../src/structures/user/BlockedUser';
import type ClientParty from '../src/structures/party/ClientParty';
import type ClientPartyMember from '../src/structures/party/ClientPartyMember';
import type ClientUser from '../src/structures/user/ClientUser';
import type Friend from '../src/structures/friend/Friend';
import type FriendPresence from '../src/structures/friend/FriendPresence';
import type IncomingPendingFriend from '../src/structures/friend/IncomingPendingFriend';
import type OutgoingPendingFriend from '../src/structures/friend/OutgoingPendingFriend';
import type ReceivedPartyJoinRequest from '../src/structures/party/ReceivedPartyJoinRequest';
import type PartyMember from '../src/structures/party/PartyMember';
import type PartyMemberConfirmation from '../src/structures/party/PartyMemberConfirmation';
import type PartyMessage from '../src/structures/party/PartyMessage';
import type ReceivedPartyInvitation from '../src/structures/party/ReceivedPartyInvitation';
import type User from '../src/structures/user/User';
import type { EpicgamesOAuthData } from './httpResponses';
import type ReceivedFriendMessage from '../src/structures/friend/ReceivedFriendMessage';
import type { AuthSessionStoreKey } from './enums';
import type FortniteAuthSession from '../src/auth/FortniteAuthSession';
import type LauncherAuthSession from '../src/auth/LauncherAuthSession';
import type FortniteClientCredentialsAuthSession from '../src/auth/FortniteClientCredentialsAuthSession';
import type EOSAuthSession from '../src/auth/EOSAuthSession';
export type PartyMemberSchema = Partial<typeof defaultPartyMemberMeta>;
export type PartySchema = Partial<typeof defaultPartyMeta> & {
    'urn:epic:cfg:presence-perm_s'?: string;
    'urn:epic:cfg:accepting-members_b'?: string;
    'urn:epic:cfg:invite-perm_s'?: string;
    'urn:epic:cfg:not-accepting-members'?: string;
    'urn:epic:cfg:not-accepting-members-reason_i'?: string;
};
export type Schema = Record<string, string | undefined>;
export type Language = 'de' | 'ru' | 'ko' | 'zh-hant' | 'pt-br' | 'en' | 'it' | 'fr' | 'zh-cn' | 'es' | 'ar' | 'ja' | 'pl' | 'es-419' | 'tr';
export type StringFunction = () => string;
export type StringFunctionAsync = () => Promise<string>;
export interface DeviceAuth {
    /**
     * The device auth's account ID
     */
    accountId: string;
    /**
     * The device auth's device ID (that does not mean it can only be used on a single device)
     */
    deviceId: string;
    /**
     * The device auth's secret
     */
    secret: string;
}
export interface DeviceAuthWithSnakeCaseSupport extends DeviceAuth {
    /**
     * The device auth's account ID
     */
    account_id?: string;
    /**
     * The device auth's device ID (that does not mean it can only be used on a single device)
     */
    device_id?: string;
}
export type DeviceAuthFunction = () => DeviceAuth;
export type DeviceAuthFunctionAsync = () => Promise<DeviceAuth>;
export type DeviceAuthResolveable = DeviceAuth | PathLike | DeviceAuthFunction | DeviceAuthFunctionAsync;
export type AuthStringResolveable = string | PathLike | StringFunction | StringFunctionAsync;
export type Platform = 'WIN' | 'MAC' | 'PSN' | 'XBL' | 'SWT' | 'IOS' | 'AND' | 'PS5' | 'XSX';
export type AuthClient = 'fortnitePCGameClient' | 'fortniteIOSGameClient' | 'fortniteAndroidGameClient' | 'fortniteSwitchGameClient' | 'fortniteCNGameClient' | 'launcherAppClient2' | 'Diesel - Dauntless';
export interface RefreshTokenData {
    /**
     * The refresh token
     */
    token: string;
    /**
     * The refresh token's expiration time in seconds
     */
    expiresIn: number;
    /**
     * The refresh token's expiration date
     */
    expiresAt: string;
    /**
     * The ID of the account the refresh token belongs to
     */
    accountId: string;
    /**
     * The display name of the account the refresh token belongs to
     */
    displayName: string;
    /**
     * The refresh token's client ID (will always be the ID of launcherAppClient2)
     */
    clientId: string;
}
export interface CacheSetting {
    /**
     * How long the data should stay in the cache until it is considered sweepable (in seconds, 0 for no cache, Infinity for infinite)
     */
    maxLifetime: number;
    /**
     * How frequently to remove cached data that is older than the lifetime (in seconds, 0 for never)
     */
    sweepInterval: number;
}
export interface CacheSettings {
    /**
     * The presence cache settings
     */
    presences?: CacheSetting;
    /**
     * The user cache settings
     */
    users?: CacheSetting;
}
export interface AuthOptions {
    /**
     * A device auth object, a function that returns a device auth object or a path to a file containing a device auth object
     */
    deviceAuth?: DeviceAuthResolveable;
    /**
     * An exchange code, a function that returns an exchange code or a path to a file containing an exchange code
     */
    exchangeCode?: AuthStringResolveable;
    /**
     * An authorization code, a function that returns an authorization code or a path to a file containing an authorization code
     */
    authorizationCode?: AuthStringResolveable;
    /**
     * A refresh token, a function that returns a refresh token or a path to a file containing a refresh token
     */
    refreshToken?: AuthStringResolveable;
    /**
     * A launcher refresh token, a function that returns a launcher refresh token or a path to a file containing a launcher refresh token
     */
    launcherRefreshToken?: AuthStringResolveable;
    /**
     * Whether the client should check whether the EULA has been accepted.
     * Do not modify this unless you know what you're doing
     */
    checkEULA?: boolean;
    /**
     * Whether the client should kill other active Fortnite auth sessions on startup
     */
    killOtherTokens?: boolean;
    /**
     * Whether the client should create a launcher auth session and keep it alive.
     * The launcher auth session can be accessed via `client.auth.auths.get('launcher')`
     */
    createLauncherSession?: boolean;
    /**
     * The Fortnite auth client (eg. 'fortnitePCGameClient' or 'fortniteAndroidGameClient')
     */
    authClient?: AuthClient;
}
export interface PartyPrivacy {
    partyType: 'Public' | 'FriendsOnly' | 'Private';
    inviteRestriction: 'AnyMember' | 'LeaderOnly';
    onlyLeaderFriendsCanJoin: boolean;
    presencePermission: 'Anyone' | 'Leader' | 'Noone';
    invitePermission: 'Anyone' | 'AnyMember' | 'Leader';
    acceptingMembers: boolean;
}
export interface PartyOptions {
    joinConfirmation?: boolean;
    joinability?: 'OPEN' | 'INVITE_AND_FORMER';
    discoverability?: 'ALL' | 'INVITED_ONLY';
    privacy?: PartyPrivacy;
    maxSize?: number;
    intentionTtl?: number;
    inviteTtl?: number;
    chatEnabled?: boolean;
}
export interface PartyConfig {
    type: 'DEFAULT';
    joinability: 'OPEN' | 'INVITE_AND_FORMER';
    discoverability: 'ALL' | 'INVITED_ONLY';
    subType: 'default';
    maxSize: number;
    inviteTtl: number;
    intentionTtl: number;
    joinConfirmation: boolean;
    privacy: PartyPrivacy;
}
export type PresenceOnlineType = 'online' | 'away' | 'chat' | 'dnd' | 'xa';
export type StatsPlaylistType = 'other' | 'solo' | 'duo' | 'squad' | 'ltm';
export interface ClientConfig {
    /**
     * Whether the party member meta (outfit, emote, etc) should be saved so they are kept when joining a new party
     */
    savePartyMemberMeta: boolean;
    /**
     * Debug function used for general debugging purposes
     */
    debug?: (message: string) => void;
    /**
     * Debug function used for http requests
     */
    httpDebug?: (message: string) => void;
    /**
     * Debug function used for incoming and outgoing xmpp xml payloads
     */
    xmppDebug?: (message: string) => void;
    /**
     * Debug function used for incoming and outgoing stomp eos connect messages
     */
    stompEosConnectDebug?: (message: string) => void;
    /**
     * Default friend presence of the bot (eg. "Playing Battle Royale")
     */
    defaultStatus?: string;
    /**
     * Default online type of the bot (eg "away"). None for online
     */
    defaultOnlineType: PresenceOnlineType;
    /**
     * The client's platform (WIN by default)
     */
    platform: Platform;
    defaultHeaders?: Record<string, string>;
    /**
     * The client's default party member meta (can be used to set a custom default skin, etc)
     */
    defaultPartyMemberMeta: Schema;
    /**
     * Custom keep alive interval for the xmpp websocket connection.
     * You should lower this value if the client randomly reconnects
     */
    xmppKeepAliveInterval: number;
    /**
     * The maximum amount of times the client should try to reconnect to XMPP before giving up
     */
    xmppMaxConnectionRetries: number;
    /**
     * Settings that affect the way the client caches certain data
     */
    cacheSettings: CacheSettings;
    /**
     * Client authentication options. By default the client will ask you for an authorization code
     */
    auth: AuthOptions;
    /**
     * Default config used for creating parties
     */
    partyConfig: PartyOptions;
    /**
     * Whether the client should create a party on startup
     */
    createParty: boolean;
    /**
     * Whether a new party should be force created on start (even if the client is already member of a party)
     */
    forceNewParty: boolean;
    /**
     * Whether to completely disable all party related functionality
     */
    disablePartyService: boolean;
    /**
     * Whether the client should connect via XMPP.
     * NOTE: If you disable this, almost all features related to friend caching will no longer work.
     * Do not disable this unless you know what you're doing
     */
    connectToXMPP: boolean;
    /**
     * Whether the client should connect to eos connect stomp
     * NOTE: If you disable this, receiving party or private messages will no longer work.
     * Do not disable this unless you know what you're doing
     */
    connectToStompEOSConnect: boolean;
    /**
     * Whether the client should fetch all friends on startup.
     * NOTE: If you disable this, almost all features related to friend caching will no longer work.
     * Do not disable this unless you know what you're doing
     */
    fetchFriends: boolean;
    /**
     * Timeout (in ms) for how long a friend is considered online after the last presence was received.
     * Note: Usually the client will receive a presence when the friend goes offline, when that does not happen, this timeout will be used
     */
    friendOfflineTimeout: number;
    /**
     * How many times to retry on HTTP 5xx errors
     */
    restRetryLimit: number;
    restTransformURL?: (url: string) => string;
    restFetchAdapter?: (url: string, init: RequestInit) => Promise<Response>;
    /**
     * Whether the client should handle rate limits (429 status code responses)
     */
    handleRatelimits: boolean;
    /**
     * The party build id (does not change very often, don't change this unless you know what you're doing)
     */
    partyBuildId: string;
    /**
     * Whether the client should restart if a refresh token is invalid.
     * Refresh tokens can be invalid if you logged in with another client on the same account.
     * By default, this is set to false because two clients attempting to log into one account could result in an endless loop
     */
    restartOnInvalidRefresh: boolean;
    /**
     * The default language for all http requests.
     * Will be overwritten by a method's language parameter
     */
    language: Language;
    /**
     * Amount of time (in ms) to wait after the initial xmpp connection before emitting friend:online events
     */
    friendOnlineConnectionTimeout: number;
    /**
     * A custom parser for resolving the stats playlist type (ie. "solo", "duo", "ltm").
     * Can be useful if you want to use data in the game files to determine the stats playlist type
     */
    statsPlaylistTypeParser?: (playlistId: string) => StatsPlaylistType;
    /**
     * fortnite deployment id (eos)
     */
    eosDeploymentId: string;
}
export interface MatchMeta {
    location?: 'PreLobby' | 'InGame' | 'ReturningToFrontEnd';
    hasPreloadedAthena?: boolean;
    isSpectatable?: boolean;
    playerCount?: number;
    matchStartedAt?: Date;
}
export interface ClientOptions extends Partial<ClientConfig> {
}
export interface ClientEvents {
    /**
     * Emitted when the client is ready
     */
    ready: () => void;
    /**
     * Emitted when the client got shut down
     */
    disconnected: (isLogout: boolean) => void;
    /**
     * Emitted when a device auth got created
     * @param deviceAuth The device auth
     */
    'deviceauth:created': (deviceAuth: DeviceAuth) => void;
    /**
     * Emitted when a refresh token got created
     * @param refreshTokenData The refresh token data
     */
    'refreshtoken:created': (refreshTokenData: RefreshTokenData) => void;
    /**
     * Emitted when the client received a friend whisper message
     * @param message The received friend whipser message
     */
    'friend:message': (message: ReceivedFriendMessage) => void;
    /**
     * Emitted when the client recieved a friend presence
     * @param before The friend's previous presence
     * @param after The friend's current presence
     */
    'friend:presence': (before: FriendPresence | undefined, after: FriendPresence) => void;
    /**
     * Emitted when a friend becomes online
     * @param friend The friend that became online
     */
    'friend:online': (friend: Friend) => void;
    /**
     * Emitted when a friend goes offline
     * @param friend The friend that went offline
     */
    'friend:offline': (friend: Friend) => void;
    /**
     * Emitted when a member in the client's party sent a message in the party chat
     * @param message The received message
     */
    'party:member:message': (message: PartyMessage) => void;
    /**
     * Emitted when a user got added to the client's friend list
     * @param friend The new friend
     */
    'friend:added': (friend: Friend) => void;
    /**
     * Emitted when the client recieved a friendship request
     * @param pendingFriend The pending friend
     */
    'friend:request': (pendingFriend: IncomingPendingFriend) => void;
    /**
     * Emitted when the client sent a friendship request
     * @param pendingFriend The pending friend
     */
    'friend:request:sent': (pendingFriend: OutgoingPendingFriend) => void;
    /**
     * Emitted when the client aborted an outgoing friendship request or when someone aborted an incoming friendship request
     * @param pendingFriend The previously pending friend
     */
    'friend:request:aborted': (pendingFriend: IncomingPendingFriend | OutgoingPendingFriend) => void;
    /**
     * Emitted when the client declined an incoming friendship request or when someone declined an outgoing friendship request
     * @param pendingFriend The previously pending friend
     */
    'friend:request:declined': (pendingFriend: IncomingPendingFriend | OutgoingPendingFriend) => void;
    /**
     * Emitted when a user got removed from the client's friend list
     * @param friend The friend
     */
    'friend:removed': (friend: Friend) => void;
    /**
     * Emitted when a user got added to the client's block list
     * @param blockedUser The user that got blocked
     */
    'user:blocked': (blockedUser: BlockedUser) => void;
    /**
     * Emitted when a user got removed from the client's block list
     * @param blockedUser The user that got unblocked
     */
    'user:unblocked': (blockedUser: BlockedUser) => void;
    /**
     * Emitted when an error occures while processing an incoming xmpp message
     * @param error The error that occurred
     */
    'xmpp:message:error': (error: Error) => void;
    /**
     * Emitted when an error occures while processing an incoming xmpp presence
     * @param error The error that occurred
     */
    'xmpp:presence:error': (error: Error) => void;
    /**
     * Emitted when an error occures while processing an incoming xmpp chat message (either a friend or party message)
     * @param error The error that occurred
     */
    'xmpp:chat:error': (error: Error) => void;
    /**
     * Emitted when the client recieved a party invitation
     * @param invitation The received party invitation
     */
    'party:invite': (invitation: ReceivedPartyInvitation) => void;
    /**
     * Emitted when a party member joined the client party
     * @param member The member who joined the client's party
     */
    'party:member:joined': (member: PartyMember | ClientPartyMember) => void;
    /**
     * Emitted when a party member got updated
     * @param member The updated party member
     */
    'party:member:updated': (member: PartyMember | ClientPartyMember) => void;
    /**
     * Emitted when a party member left the party
     * @param member The party member
     */
    'party:member:left': (member: PartyMember) => void;
    /**
     * Emitted when a party member expired
     * @param member The party member
     */
    'party:member:expired': (member: PartyMember) => void;
    /**
     * Emitted when a party member gets kicked
     * @param member The party member
     */
    'party:member:kicked': (member: PartyMember) => void;
    /**
     * Emitted when a party member disconnected
     * @param member The party member
     */
    'party:member:disconnected': (member: PartyMember) => void;
    /**
     * Emitted when a party member gets promoted
     * @param member The party member
     */
    'party:member:promoted': (member: PartyMember | ClientPartyMember) => void;
    /**
     * Emitted when the client's party gets updated
     * @param party The party which got updated
     */
    'party:updated': (party: ClientParty) => void;
    /**
     * Emitted when a party member requires confirmation
     * @param confirmation The pending party member confirmation
     */
    'party:member:confirmation': (confirmation: PartyMemberConfirmation) => void;
    /**
     * Emitted when a friend requests to join the bots party
     * @param request The recieved join request
     */
    'party:joinrequest': (request: ReceivedPartyJoinRequest) => void;
    /**
     * Emitted when a party member updated their outfit
     * @param member The member
     * @param value The new outfit
     * @param previousValue The previous outfit
     */
    'party:member:outfit:updated': (member: PartyMember | ClientPartyMember, value?: string, previousValue?: string) => void;
    /**
     * Emitted when a party member updated their emote
     * @param member The member
     * @param value The new emote
     * @param previousValue The previous emote
     */
    'party:member:emote:updated': (member: PartyMember | ClientPartyMember, value?: string, previousValue?: string) => void;
    /**
     * Emitted when a party member updated their backpack
     * @param member The member
     * @param value The new backpack
     * @param previousValue The previous backpack
     */
    'party:member:backpack:updated': (member: PartyMember | ClientPartyMember, value?: string, previousValue?: string) => void;
    /**
     * Emitted when a party member updated their pickaxe
     * @param member The member
     * @param value The new pickaxe
     * @param previousValue The previous pickaxe
     */
    'party:member:pickaxe:updated': (member: PartyMember | ClientPartyMember, value?: string, previousValue?: string) => void;
    /**
     * Emitted when a party member updated their readiness state
     * @param member The member
     * @param value The new readiness state
     * @param previousValue The previous readiness state
     */
    'party:member:readiness:updated': (member: PartyMember | ClientPartyMember, value?: boolean, previousValue?: boolean) => void;
    /**
     * Emitted when a party member updated their match state
     * @param member The member
     * @param value The new match state
     * @param previousValue The previous match state
     */
    'party:member:matchstate:updated': (member: PartyMember | ClientPartyMember, value?: MatchMeta, previousValue?: MatchMeta) => void;
}
export type AuthType = 'fortnite' | 'fortniteClientCredentials' | 'launcher';
export interface AuthResponse {
    response?: EpicgamesOAuthData;
    error?: EpicgamesAPIError | Error;
}
export interface ReauthResponse {
    response?: {
        success: boolean;
    };
    error?: EpicgamesAPIError;
}
export interface FriendConnection {
    name?: string;
}
export interface FriendConnections {
    epic?: FriendConnection;
    psn?: FriendConnection;
    nintendo?: FriendConnection;
}
export interface PresenceGameplayStats {
    kills?: number;
    fellToDeath?: boolean;
    serverPlayerCount?: number;
}
export type PendingFriendDirection = 'INCOMING' | 'OUTGOING';
export interface StatsPlaylistTypeData {
    score: number;
    scorePerMin: number;
    scorePerMatch: number;
    wins: number;
    top3: number;
    top5: number;
    top6: number;
    top10: number;
    top12: number;
    top25: number;
    kills: number;
    killsPerMin: number;
    killsPerMatch: number;
    deaths: number;
    kd: number;
    matches: number;
    winRate: number;
    minutesPlayed: number;
    playersOutlived: number;
    lastModified?: Date;
}
export interface StatsInputTypeData {
    overall: StatsPlaylistTypeData;
    solo: StatsPlaylistTypeData;
    duo: StatsPlaylistTypeData;
    squad: StatsPlaylistTypeData;
    ltm: StatsPlaylistTypeData;
}
export interface StatsData {
    all: StatsInputTypeData;
    keyboardmouse: StatsInputTypeData;
    gamepad: StatsInputTypeData;
    touch: StatsInputTypeData;
}
export interface NewsMOTD {
    entryType: string;
    image: string;
    tileImage: string;
    videoMute: boolean;
    hidden: boolean;
    tabTitleOverride: string;
    _type: string;
    title: string;
    body: string;
    offerAction: string;
    videoLoop: boolean;
    videoStreamingEnabled: boolean;
    sortingPriority: number;
    buttonTextOverride?: string;
    offerId?: string;
    id: string;
    videoAutoplay: boolean;
    videoFullscreen: boolean;
    spotlight: boolean;
    videoUID?: string;
    videoVideoString?: string;
    playlistId?: string;
}
export interface NewsMessageData {
    image: string;
    hidden: boolean;
    _type: string;
    adspace: string;
    title: string;
    body: string;
    spotlight: boolean;
}
export interface LightswitchLauncherInfo {
    appName: string;
    catalogItemId: string;
    namespace: string;
}
export interface LightswitchData {
    serviceInstanceId: string;
    status: string;
    message: string;
    maintenanceUri?: string;
    overrideCatalogIds: string[];
    allowedActions: string[];
    banned: boolean;
    launcherInfoDTO: LightswitchLauncherInfo;
}
export interface EpicgamesServerStatusData {
    page: {
        id: string;
        name: string;
        url: string;
        time_zone: string;
        updated_at: string;
    };
    components: {
        id: string;
        name: string;
        status: string;
        created_at: Date;
        updated_at: Date;
        position: number;
        description?: any;
        showcase: boolean;
        start_date: string;
        group_id: string;
        page_id: string;
        group: boolean;
        only_show_if_degraded: boolean;
        components: string[];
    }[];
    incidents: any[];
    scheduled_maintenances: any[];
    status: {
        indicator: string;
        description: string;
    };
}
export interface EpicgamesServerStatusIncidentUpdate {
    id: string;
    body: string;
    createdAt: Date;
    displayAt: Date;
    status: string;
    updatedAt: Date;
}
export interface MessageData {
    content: string;
    author: Friend | PartyMember | ClientPartyMember | ClientUser;
    id: string;
    sentAt?: Date;
}
export interface FriendMessageData extends MessageData {
    author: Friend | ClientUser;
}
export interface PartyMessageData extends MessageData {
    author: PartyMember | ClientPartyMember;
    party: ClientParty;
}
export interface PendingFriendData {
    accountId: string;
    created: string;
    favorite: boolean;
    displayName: string;
}
export interface ExternalAuth {
    accountId: string;
    type: string;
    externalAuthId: string;
    externalAuthIdType: string;
    externalDisplayName?: string;
    authIds: {
        id: string;
        type: string;
    }[];
}
export interface ExternalAuths {
    github?: ExternalAuth;
    twitch?: ExternalAuth;
    steam?: ExternalAuth;
    psn?: ExternalAuth;
    xbl?: ExternalAuth;
    nintendo?: ExternalAuth;
}
export interface UserData {
    id: string;
    displayName?: string;
    externalAuths?: ExternalAuths;
}
export interface ClientUserData extends UserData {
    name: string;
    email: string;
    failedLoginAttempts: number;
    lastLogin: string;
    numberOfDisplayNameChanges: number;
    ageGroup: string;
    headless: boolean;
    country: string;
    lastName: string;
    phoneNumber: string;
    preferredLanguage: string;
    lastDisplayNameChange: string;
    canUpdateDisplayName: boolean;
    tfaEnabled: boolean;
    emailVerified: boolean;
    minorVerified: boolean;
    minorExpected: boolean;
    minorStatus: string;
}
export interface CreatorCodeData {
    slug: string;
    owner: User;
    status: 'ACTIVE' | 'DISABLED';
    verified: boolean;
}
export interface FriendData extends UserData {
    created: string;
    favorite: boolean;
    displayName?: string;
    connections?: FriendConnections;
    mutual?: number;
    alias: string;
    note: string;
}
export interface FriendPresenceData {
    Status?: string;
    bIsPlaying?: boolean;
    bIsJoinable?: boolean;
    bHasVoiceSupport?: boolean;
    SessionId?: string;
    ProductName?: string;
    Properties?: {
        FortBasicInfo_j?: {
            homeBaseRating?: number;
        };
        FortLFG_I?: string;
        FortPartySize_i?: number;
        FortSubGame_i?: number;
        InUnjoinableMatch_b?: boolean;
        FortGameplayStats_j?: {
            state: string;
            playlist: string;
            numKills: number;
            bFellToDeath: boolean;
        };
        'party.joininfodata.286331153_j'?: {
            bIsPrivate?: boolean;
        };
        GamePlaylistName_s?: string;
        Event_PlayersAlive_s?: string;
        Event_PartySize_s?: string;
        Event_PartyMaxSize_s?: string;
        GameSessionJoinKey_s?: string;
        ServerPlayerCount_i?: string;
    };
}
export interface PartyMemberData {
    id: string;
    account_id: string;
    account_dn?: string;
    meta: Schema;
    revision: number;
    updated_at: string;
    joined_at: string;
    role: string;
}
export interface PartyMemberUpdateData {
    account_id: string;
    account_dn?: string;
    revision: number;
    member_state_updated: Schema;
    member_state_removed: string[];
}
export interface PartyData {
    id: string;
    created_at: string;
    updated_at: string;
    config: {
        type: string;
        joinability: string;
        discoverability: string;
        sub_type: string;
        max_size: number;
        invite_ttl: number;
        join_confirmation: boolean;
        intention_ttl: number;
    };
    members: PartyMemberData[];
    meta: PartySchema;
    invites: any[];
    revision: number;
}
export interface PartyUpdateData {
    revision: number;
    party_state_updated: Schema;
    party_state_removed: string[];
    party_privacy_type: 'OPEN' | 'INVITE_AND_FORMER';
    max_number_of_members: number;
    party_sub_type: 'default';
    party_type: 'DEFAULT';
    invite_ttl_seconds: number;
    discoverability: 'ALL' | 'INVITED_ONLY';
}
export interface Island {
    linkId?: {
        mnemonic?: string;
        version?: number;
    };
    woldId?: {
        iD?: string;
        ownerId?: string;
        name?: string;
    };
    sessionId?: string;
    joinInfo?: {
        islandJoinability?: string;
        bIsWorldJoinable?: boolean;
        sessionKey?: string;
    };
}
export interface Cosmetics {
    outfit?: {
        id: string;
        variants?: CosmeticVariant[];
        enlightment?: CosmeticEnlightment;
    };
    backpack?: {
        id: string;
        variants?: CosmeticVariant[];
        path?: string;
    } | null;
    pickaxe?: {
        id: string;
        variants?: CosmeticVariant[];
        path?: string;
    };
    shoes?: {
        id: string;
        variants?: CosmeticVariant[];
        path?: string;
    } | null;
}
export interface CosmeticVariant {
    channel: string;
    variant: string;
    dE?: number;
}
export interface CosmeticVariantMeta {
    i: {
        v: string;
        c: string;
        dE: number;
    }[];
}
export interface CosmeticsVariantMeta {
    athenaCharacter?: CosmeticVariantMeta;
    athenaBackpack?: CosmeticVariantMeta;
    athenaPickaxe?: CosmeticVariantMeta;
    athenaShoes?: CosmeticVariantMeta;
    athenaSkyDiveContrail?: CosmeticVariantMeta;
}
export type CosmeticEnlightment = [number, number];
export interface BannerMeta {
    bannerIconId: string;
    bannerColorId: string;
}
export interface BattlePassMeta {
    bHasPurchasedPass: boolean;
    passLevel: number;
    selfBoostXp: number;
    friendBoostXp: number;
}
export interface AssistedChallengeMeta {
    questItemDef: string;
    objectivesCompleted: number;
}
export type Region = 'EU' | 'NAE' | 'NAW' | 'BR' | 'ME' | 'ASIA' | 'OCE';
export type FullPlatform = 'Windows' | 'Android' | 'PS4' | 'XboxOne' | 'XSX' | 'PS5' | 'Switch' | 'Windows' | 'Mac';
export type SentMessageType = 'PARTY' | 'FRIEND';
export interface PresencePartyData {
    bIsPrivate?: boolean;
    sourceId?: string;
    sourceDisplayName?: string;
    sourcePlatform?: string;
    partyId?: string;
    partyTypeId?: number;
    key?: 'k';
    appId?: string;
    buildId?: string;
    partyFlags?: number;
    notAcceptingReason?: number;
    pc?: number;
}
export type UserSearchPlatform = 'epic' | 'psn' | 'xbl' | 'steam';
export type UserSearchMatchType = 'exact' | 'prefix';
export interface UserSearchResultMatch {
    value: string;
    platform: UserSearchPlatform;
}
export interface BlurlStream {
    languages: {
        language: string;
        url: string;
        variants: {
            data: {
                codecs: string[];
                bandwidth: number;
                resolution: string;
            };
            type: 'video' | 'audio';
            url: string;
            stream: Buffer;
        }[];
    }[];
    data: {
        subtitles: any;
        ucp?: string;
        audioonly: boolean;
        aspectratio?: string;
        partysync: boolean;
        lrcs: any;
        duration?: number;
    };
}
export interface ReplayEvent {
    Id: string;
    Group: string;
    Metadata: string;
    Time1: number;
    Time2: number;
    data: Buffer;
}
export interface ReplayDataChunk {
    Id: string;
    Time1: number;
    Time2: number;
    SizeInBytes: number;
    data: Buffer;
}
export interface ReplayCheckpoint {
    Id: string;
    Group: string;
    Metadata: string;
    Time1: number;
    Time2: number;
    data: Buffer;
}
export interface ReplayData {
    ReplayName: string;
    LengthInMS: number;
    NetworkVersion: number;
    Changelist: number;
    FriendlyName: string;
    Timestamp: Date;
    bIsLive: boolean;
    bCompressed: boolean;
    DesiredDelayInSeconds: number;
    Checkpoints?: ReplayCheckpoint[];
    Events?: ReplayEvent[];
    DataChunks?: ReplayDataChunk[];
    Header: Buffer;
}
export type ReplayDataType = 'EVENT' | 'DATACHUNK' | 'CHECKPOINT';
export interface ReplayDownloadConfig {
    /**
     * Which replay data types to download.
     * EVENT data contains basic information like eliminations, you will only need EVENT data for ThisNils/node-replay-reader.
     * DATACHUNK data contains information that is required for most parsing libraries.
     * CHECKPOINT data contains information that is pretty much only useful if you want to use the replay ingame.
     * By default, only events and data chunks are downloaded
     */
    dataTypes: ReplayDataType[];
    /**
     * Whether a placeholder for AthenaMatchStats and AthenaMatchTeamStats should be added.
     * Required if you want to use the replay ingame, otherwise useless.
     * By default, this is set to false
     */
    addStatsPlaceholder: boolean;
}
export interface ReplayDownloadOptions extends Partial<ReplayDownloadConfig> {
}
export interface BRAccountLevel {
    level: number;
    progress: number;
}
export interface BRAccountLevelData {
    user: User;
    level: BRAccountLevel;
}
export interface StatsLevelData {
    [key: string]: {
        level: number;
        progress: number;
    };
}
export interface ArenaDivisionData {
    [key: string]: number;
}
export interface NewsMessageVideoData {
    videoAutoplay: boolean;
    videoFullscreen: boolean;
    videoLoop: boolean;
    videoMute: boolean;
    videoStreamingEnabled: boolean;
    videoVideoString: string;
    videoUID: string;
}
export interface NewsMessagePlaylist {
    id: string;
}
export interface NewsMessageOffer {
    id: string;
    action: string;
}
export interface ImageData {
    url: string;
    width?: number;
    height?: number;
}
export interface AuthData {
    access_token: string;
    account_id: string;
    client_id: string;
    expires_at: string;
    expires_in: number;
    token_type: string;
}
export interface LauncherAuthData extends AuthData {
    refresh_expires: number;
    refresh_expires_at: string;
    refresh_token: string;
    internal_client: boolean;
    client_service: string;
    scope: string[];
    displayName: string;
    app: string;
    in_app_id: string;
}
export interface FortniteAuthData extends AuthData {
    refresh_expires: number;
    refresh_expires_at: string;
    refresh_token: string;
    internal_client: boolean;
    client_service: string;
    displayName: string;
    app: string;
    in_app_id: string;
    device_id: string;
}
export interface FortniteClientCredentialsAuthData extends AuthData {
    internal_client: boolean;
    client_service: string;
    product_id: string;
    application_id: string;
}
export interface EOSAuthData extends AuthData {
    refresh_expires: number;
    refresh_expires_at: string;
    refresh_token: string;
    application_id: string;
    merged_accounts: string[];
    scope: string;
}
export interface EOSAuthData extends AuthData {
    refresh_expires: number;
    refresh_expires_at: string;
    refresh_token: string;
    application_id: string;
    merged_accounts: string[];
    scope: string;
}
export interface AuthSessionStore<K, V> extends Collection<K, V> {
    get(key: AuthSessionStoreKey.Fortnite): FortniteAuthSession | undefined;
    get(key: AuthSessionStoreKey.Launcher): LauncherAuthSession | undefined;
    get(key: AuthSessionStoreKey.FortniteEOS): EOSAuthSession | undefined;
    get(key: AuthSessionStoreKey.FortniteClientCredentials): FortniteClientCredentialsAuthSession | undefined;
    get(key: K): V | undefined;
}
/**
 * Represents a chat message data
 */
export interface ChatMessagePayload {
    /**
     * The message body, should not be empty and not exceed the limit of 256 characters. Please note that emojis count as 2 characters.
     */
    body: string;
}
interface BaseEOSConnectMessage {
    correlationId: string;
    timestamp: number;
    id?: string;
    connectionId?: string;
}
export interface EOSConnectCoreConnected extends BaseEOSConnectMessage {
    type: 'core.connect.v1.connected';
}
export interface EOSConnectCoreConnectFailed extends BaseEOSConnectMessage {
    message: string;
    statusCode: number;
    type: 'core.connect.v1.connect-failed';
}
export interface EOSConnectChatMemberLeftMessage extends BaseEOSConnectMessage {
    payload: {
        namespace: string;
        conversationId: string;
        members: string[];
    };
    type: 'social.chat.v1.MEMBERS_LEFT';
}
export interface EOSConnectChatNewMsgMessage extends BaseEOSConnectMessage {
    payload: {
        namespace: string;
        conversation: {
            conversationId: string;
            type: string;
        };
        message: {
            body: string;
            senderId: string;
            time: number;
        };
    };
    type: 'social.chat.v1.NEW_MESSAGE';
}
export interface EOSConnectChatConversionCreatedMessage extends BaseEOSConnectMessage {
    payload: {
        namespace: string;
        conversationId: string;
        type: string;
        members: string[];
    };
    type: 'social.chat.v1.CONVERSATION_CREATED';
}
export interface EOSConnectChatNewWhisperMessage extends BaseEOSConnectMessage {
    payload: {
        namespace: string;
        message: {
            body: string;
            senderId: string;
            time: number;
        };
    };
    type: 'social.chat.v1.NEW_WHISPER';
}
export type EOSConnectMessage = EOSConnectCoreConnected | EOSConnectCoreConnectFailed | EOSConnectChatConversionCreatedMessage | EOSConnectChatNewMsgMessage | EOSConnectChatMemberLeftMessage | EOSConnectChatNewWhisperMessage;
export {};