declare global {
    interface Window {
        FarcadeSDK: typeof sdk;
        RemixSDK: typeof sdk;
    }
}
type ViewContext = 'feed' | 'full_screen' | 'challenge' | 'tournament';
type SafeAreaInset = {
    top: number;
    right: number;
    bottom: number;
    left: number;
};
declare const ZERO_SAFE_AREA_INSET: SafeAreaInset;
type GameState = Record<string, unknown>;
type Player = {
    id: string;
    name: string;
    purchasedItems: string[];
    imageUrl?: string;
};
type InventoryItem = {
    slug: string;
    quantity: number;
};
type ShopItem = {
    slug: string;
    name: string;
    itemType?: string;
    bitsCost?: number | null;
    description?: string | null;
    iconUrl?: string | null;
    tier?: number | null;
};
type GameInfo = {
    players: Player[];
    player: Player;
    shopItems?: ShopItem[];
    viewContext: ViewContext;
    contentSafeAreaInset: SafeAreaInset;
    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;
        item?: string;
    };
};
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 RemixSDK {
    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 inventory(): InventoryItem[];
    get shopItems(): ShopItem[];
    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;
    getItemPurchaseCount: (item: string) => number;
    getShopItem: (slug: string) => ShopItem | undefined;
    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;
    private applyPurchaseToCurrentPlayer;
}
declare const sdk: RemixSDK;

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