declare global {
    interface Window {
        FarcadeSDK: typeof sdk;
    }
}
type ViewContext = 'feed' | 'full_screen' | 'challenge' | 'tournament';
type GameState = Record<string, unknown>;
type Player = {
    id: string;
    name: string;
    purchasedItems: string[];
    imageUrl?: string;
};
type GameInfo = {
    players: Player[];
    player: Player;
    viewContext: ViewContext;
    initialGameState: {
        id: string;
        gameState: GameState;
    } | null;
};
type ReadyEvent = {
    type: 'ready';
    data: undefined;
};
type PlayAgainEvent = {
    type: 'play_again';
    data: undefined;
};
type SinglePlayerGameOverEvent = {
    type: 'game_over';
    data: {
        score: number;
    };
};
type MultiplayerGameOverEvent = {
    type: 'multiplayer_game_over';
    data: {
        scores: {
            playerId: string;
            score: number;
        }[];
    };
};
type HapticFeedbackEvent = {
    type: 'haptic_feedback';
    data: undefined;
};
type ToggleMuteEvent = {
    type: 'toggle_mute';
    data: {
        isMuted: boolean;
    };
};
type GameErrorEvent = {
    type: 'error';
    data: {
        message: string;
        source?: string;
        lineno?: number;
        colno?: number;
        error?: Error;
    };
};
type GameInfoEvent = {
    type: 'game_info';
    data: GameInfo;
};
type MultiplayerSaveGameStateEvent = {
    type: 'multiplayer_save_game_state';
    data: {
        gameState: GameState;
        alertUserIds?: string[];
    };
};
type GameStateUpdatedEvent = {
    type: 'game_state_updated';
    data: {
        id: string;
        gameState: GameState;
    } | null;
};
type RefuteGameStateEvent = {
    type: 'refute_game_state';
    data: {
        gameStateId: string;
    };
};
type SaveGameStateEvent = {
    type: 'save_game_state';
    data: {
        gameState: GameState;
    };
};
type PurchaseEvent = {
    type: 'purchase';
    data: {
        item: string;
    };
};
type PurchaseCompleteEvent = {
    type: 'purchase_complete';
    data: {
        success: boolean;
    };
};
type GameEvent = PlayAgainEvent | SinglePlayerGameOverEvent | ReadyEvent | HapticFeedbackEvent | ToggleMuteEvent | GameErrorEvent | SaveGameStateEvent | RefuteGameStateEvent | GameInfoEvent | GameStateUpdatedEvent | MultiplayerGameOverEvent | MultiplayerSaveGameStateEvent | PurchaseEvent | PurchaseCompleteEvent;
type GameEventMessage<T extends GameEvent['type']> = {
    type: 'game_event';
    event: Extract<GameEvent, {
        type: T;
    }>;
};
/**
 * Messages from the game host to the game client
 */
type IncomingGameEvent = GameEventMessage<'play_again' | 'toggle_mute' | 'game_info' | 'game_state_updated' | 'purchase_complete'>;
type OutgoingGameEvent = GameEventMessage<'game_over' | 'ready' | 'haptic_feedback' | 'error' | 'save_game_state' | 'refute_game_state' | 'multiplayer_game_over' | 'multiplayer_save_game_state' | 'purchase'>;
type EventCallback = (data: unknown) => void;
declare class FarcadeSDK {
    private isClient;
    private target;
    private eventListeners;
    private readyPromiseResolve;
    private purchasePromiseResolve;
    private _gameInfo?;
    private _gameState?;
    constructor();
    on(eventType: IncomingGameEvent['event']['type'], callback: EventCallback): void;
    off(eventType: IncomingGameEvent['event']['type'], callback: EventCallback): void;
    onPlayAgain(callback: () => void): void;
    onToggleMute(callback: (data: ToggleMuteEvent['data']) => void): void;
    onGameStateUpdated(callback: (data: GameStateUpdatedEvent['data']) => void): void;
    onGameInfo(callback: (data: GameInfoEvent['data']) => void): void;
    onPurchaseComplete(callback: (data: PurchaseCompleteEvent['data']) => void): void;
    setTarget(target: Window): void;
    get purchasedItems(): string[];
    get gameInfo(): GameInfo | undefined;
    get gameState(): GameState | null | undefined;
    get players(): Player[] | undefined;
    get player(): Player | undefined;
    get isReady(): boolean;
    ready: () => Promise<GameInfo>;
    purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
    reportError: (data: GameErrorEvent["data"]) => void;
    hapticFeedback: () => void;
    hasItem: (item: string) => boolean;
    singlePlayer: {
        actions: {
            ready: () => Promise<GameInfo>;
            hapticFeedback: () => void;
            reportError: (data: GameErrorEvent["data"]) => void;
            purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
            gameOver: (data: SinglePlayerGameOverEvent["data"]) => void;
            saveGameState: (data: SaveGameStateEvent["data"]) => void;
        };
    };
    multiplayer: {
        actions: {
            gameOver: (data: MultiplayerGameOverEvent["data"]) => void;
            refuteGameState: (data: RefuteGameStateEvent["data"]) => void;
            saveGameState: (data: MultiplayerSaveGameStateEvent["data"]) => void;
            ready: () => Promise<GameInfo>;
            hapticFeedback: () => void;
            reportError: (data: GameErrorEvent["data"]) => void;
            purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
        };
    };
    private emit;
    private handleMessage;
    private sendMessage;
    private handleGlobalError;
    private handleUnhandledRejection;
}
declare const sdk: FarcadeSDK;

export { FarcadeSDK, type GameErrorEvent, type GameEvent, type GameEventMessage, type GameInfo, type GameInfoEvent, type GameState, type GameStateUpdatedEvent, type HapticFeedbackEvent, type IncomingGameEvent, type MultiplayerGameOverEvent, type MultiplayerSaveGameStateEvent, type OutgoingGameEvent, type PlayAgainEvent, type Player, type PurchaseCompleteEvent, type PurchaseEvent, type ReadyEvent, type RefuteGameStateEvent, type SaveGameStateEvent, type SinglePlayerGameOverEvent, type ToggleMuteEvent, type ViewContext, sdk };