import { MediaConnection, PeerError } from "peerjs";
export interface AvailableLobbyMetadata {
    name: string;
    p2p: boolean;
    players: Array<string>;
    private: boolean;
}
export interface AvailableLobby {
    id: string;
    maxPlayers: number;
    name: string;
    players: Array<string>;
    private: boolean;
}
export interface PlayerList {
    [sessionId: string]: {
        sessionId: string;
        username: string;
        team: string;
    };
}
export interface Lobby {
    actions: {
        abandon(): void;
        destroy(): void;
        disconnect(): void;
        listPlayers(): Promise<PlayerList>;
        reconnect(): Promise<Lobby>;
    };
    commands: {
        kickPlayer(username: string): Promise<string>;
        banPlayer(username: string): Promise<string>;
        unbanPlayer(username: string): Promise<string>;
    };
    communications: {
        allChat(message: string): Promise<string>;
        teamChat(message: string, team: string): Promise<string>;
        whisper(message: string, username: string): Promise<string>;
        mute(username: string): Promise<string>;
        unmute(username: string): Promise<string>;
        call(): void;
        hangUp(): void;
        onMessage(callback: (input: {
            message: string;
            senderId: string;
            senderUsername: string;
            whisper: boolean;
            team: boolean;
        }) => void): void;
    };
    data: {
        sendToAll(data: any): void;
        sendToTeam(data: any, team: string): void;
        onReceiveAll(callback: (payload: any) => void): void;
        onReceiveTeam(callback: (payload: any) => void): void;
    };
    events: {
        onDisconnect(callback: (code: number) => void): void;
        onError(callback: (code: number, message?: string) => void): void;
        onMessage(callback: (code: string, message: string) => void): void;
        onPlayerSync(callback: (result: {
            event: 'join' | 'leave';
            username: string;
            sessionId: string;
        }) => void): void;
    };
    session: {
        userId: string;
        lobbyId: string;
        username: string;
    };
    state: {
        current: void;
        onChange(callback: (state: any) => void): void;
    };
}
export interface LobbyP2P {
    actions: {
        abandon(): void;
        disconnect(): void;
        listPlayers(): Promise<Array<string>>;
        reconnect(): Promise<LobbyP2P>;
    };
    communications: {
        chat(message: string): Promise<string>;
        call(): Promise<MediaConnection>;
        onCall(callback: (accept: () => void, decline: () => void) => void): void;
        hangUp(): Promise<void>;
        onMessage(callback: (message: string) => void): void;
    };
    data: {
        send(data: any): void;
        onReceive(callback: (payload: any) => void): void;
    };
    events: {
        onConnect(callback: () => void): void;
        onDisconnect(callback: () => void): void;
        onAbandon(callback: () => void): void;
        onError(callback: (error: PeerError<any>, fatal: boolean) => void): void;
        onMatchFound(callback: (opponent: string) => void): void;
    };
    session: {
        username: string;
        opponent: string;
        isConnected: boolean;
    };
}
export interface ArenaCommandResult {
    code: 'success' | string;
    payload: string;
    reason?: string;
    success: boolean;
}
export type ArenaConfiguration = {
    room: string | null;
    lobby: string | null;
    name: string | null;
    team: string;
    password: string;
    token: string;
    p2p?: boolean;
    game: string;
};
export interface ArenaSDK {
    createLobby(options: Pick<ArenaConfiguration, 'room' | 'password' | 'team' | 'name' | 'p2p'>): Promise<Lobby>;
    duel(room: string): Promise<LobbyP2P>;
    getLobby(): Promise<Lobby>;
    getLobbyP2P(): Promise<LobbyP2P>;
    joinLobby(options: Pick<ArenaConfiguration, 'lobby' | 'room' | 'team' | 'password'>): Promise<Lobby>;
    lobbies(roomId: string): Promise<Array<AvailableLobby>>;
    p2p(id: string): Promise<LobbyP2P>;
}