@indiegems/gem-web-sdk 23.3.0 → 24.0.1

package/dist/sdk.d.ts

@@ -922,6 +922,7 @@ declare class OrdersApi {
 interface GamePass {
     readonly pass: string;
     readonly held: boolean;
+    readonly daysLeft: number;
     readonly endsAt: string | null;
 }
 type PassesEvent = "changed";
@@ -1157,1458 +1158,1773 @@ declare class TransfersApi {
     cancel(transferId: string, signal?: AbortSignal): Promise<Transfer>;
     private resolve;
 }
-interface GameConfig extends GameConfigSnapshot {
-    items: GameConfigSnapshot["items"];
-    currencies: GameConfigSnapshot["currencies"];
-    catalogs: GameConfigSnapshot["catalogs"];
-    loot_tables: GameConfigSnapshot["loot_tables"];
-    affix_pools?: GameConfigSnapshot["affix_pools"];
-    progressions: GameConfigSnapshot["progressions"];
-    game_room_templates: GameConfigSnapshot["game_room_templates"];
-    kv: GameConfigSnapshot["kv"];
-    run_types?: GameConfigSnapshot["run_types"];
-    leaderboards?: GameConfigSnapshot["leaderboards"];
-    async_opponent_types?: GameConfigSnapshot["async_opponent_types"];
-    analytics_events?: GameConfigSnapshot["analytics_events"];
-    analytics_funnels?: GameConfigSnapshot["analytics_funnels"];
-    "rewarded_placements"?: SnapshotRewardedPlacement[];
-    version: GameConfigSnapshot["version"];
-    hash: GameConfigSnapshot["hash"];
-    item(idOrSlug: string): SnapshotItem | null;
-    currency(idOrSlug: string): SnapshotCurrency | null;
-}
-declare class GemConfigError extends Error {
-    readonly reason: "config_unreachable" | "config_too_large" | "config_malformed" | "config_timeout" | "config_channel_unknown";
-    constructor(reason: "config_unreachable" | "config_too_large" | "config_malformed" | "config_timeout" | "config_channel_unknown", message: string);
+declare const PROTOCOL: "gem-web-bridge";
+type GemErrorCode = "version_mismatch" | "handshake_timeout" | "handshake_duplicate" | "invalid_message" | "rate_limited" | "token_unavailable" | "unsupported" | "unsupported_capability" | "internal";
+interface GemToken {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.token";
+    readonly token: string;
+    readonly requestId?: string;
+    readonly generation: number;
+    readonly apiBaseUrl?: string;
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: "dev" | "test" | "release";
+    readonly gameVersion?: string;
+    readonly expiresAt: number;
+    readonly chainEndsAt: number;
+    readonly allowDevTools?: boolean;
 }
-interface GameConfigOptions {
-    readonly fetch?: typeof globalThis.fetch;
-    readonly timeoutMs?: number;
+interface GemTokenDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.token.denied";
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly reason: "chain_exhausted" | "unavailable";
+    readonly correlationId: string;
 }
-interface DropRateEntry$1 {
-    readonly entryId: string;
-    readonly weight: number;
-    readonly dropRate: number;
-    readonly rarityTier?: string;
+interface GemPause {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.pause";
+    readonly paused: boolean;
 }
-interface DropRates {
-    readonly lootTableId: string;
-    readonly name: string;
-    readonly rollCount: number;
-    readonly allowDuplicateRolls: boolean;
-    readonly totalWeight: number;
-    readonly entries: readonly DropRateEntry$1[];
+interface GemPrefs$1 {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.prefs";
+    readonly reducedMotion: boolean;
+    readonly muted: boolean;
+    readonly showFrameStats?: boolean;
+    readonly music?: boolean;
+    readonly sounds?: boolean;
+    readonly locale: string;
+    readonly recommended?: {
+        volume: number;
+        batterySaver: boolean;
+        keyboardLayout: "wasd" | "arrows";
+        gamepadConfirm: "south" | "east";
+        vibration: boolean;
+        lookSensitivity?: number;
+        gamepadLookSensitivity?: number;
+        invertLookY?: boolean;
+        touchMovement?: string;
+        graphicsQuality?: string;
+        graphicsQualityAuto?: boolean;
+        colorHelp?: boolean;
+        textScale?: number;
+    };
 }
-declare class GameConfigApi {
-    private readonly api;
-    private readonly channel;
-    private readonly options;
-    private loaded;
-    private inFlight;
-    private generation;
-    private readonly dropRatesByConfig;
-    constructor(api: GameApi$1, channel: () => string, options?: GameConfigOptions);
-    load(): Promise<GameConfig | null>;
-    refresh(): void;
-    dropRates(lootTableId: string, signal?: AbortSignal): Promise<DropRates>;
-    private fetchConfig;
+interface GemCohorts$1 {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.cohorts";
+    readonly cohorts: {
+        experimentId: string;
+        variantKey: string;
+    }[];
 }
-declare const MAX_PERIODS_BACK = 400;
-type ChallengeWindow = "daily" | "weekly" | "monthly" | "cron" | (string & {});
-interface Challenge {
-    readonly id: string;
-    readonly slug?: string;
-    readonly window: ChallengeWindow;
-    readonly periodStartAt: number;
-    readonly periodEndsAt: number;
-    readonly periodLocalDate?: string;
-    readonly boundary: string;
-    readonly resetTime: string;
-    readonly seed: string;
-    readonly data?: string;
-    readonly dataHash?: string;
+interface GemInventoryChanged {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.inventoryChanged";
 }
-interface ListChallengesOptions {
-    readonly periodsBack?: number;
-    readonly signal?: AbortSignal;
+interface GemViewport$1 {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.viewport";
+    readonly insets: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    readonly reserved?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        control?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    }[];
 }
-declare class ChallengesApi {
-    #private;
-    constructor(api: GameApi$1);
-    list(options?: ListChallengesOptions): Promise<Challenge[]>;
+interface GemDeviceSettings {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings";
+    readonly settings?: unknown;
 }
-interface PlayerBadge$1 {
-    readonly itemId: string;
-    readonly iconUrl: string;
+interface GemWillTerminate {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.willTerminate";
+    readonly reason: "grant_expiring" | "session_ended" | "navigating" | "kill_switch";
+    readonly graceMs: number;
 }
-type Avatar3dFamily = "small_human" | "adult_human" | (string & {});
-interface WornAvatar3d$1 {
-    readonly family: Avatar3dFamily;
-    readonly id: string;
-    readonly modelUrl: string;
-    readonly iconUrl: string;
+interface GemRoomEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.roomEvent";
+    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
+    readonly roomId: string;
+    readonly matchId?: string;
+    readonly version?: number;
+    readonly reason?: string;
+    readonly platform?: "universal" | "mobile";
 }
-interface PlayerIdentity {
-    readonly playerId?: string;
-    readonly displayName?: PlayerText;
-    readonly discriminator?: string;
-    readonly displayTag?: PlayerText;
-    readonly avatarIconId?: string;
-    readonly avatarIconUrl?: string;
-    readonly avatar3dId?: string;
-    readonly avatar3dModelUrl?: string;
-    readonly avatar3dIconUrl?: string;
-    readonly avatars3d?: readonly WornAvatar3d$1[];
-    readonly badges: readonly PlayerBadge$1[];
+interface GemSocketState {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.socketState";
+    readonly connected: boolean;
+    readonly reason?: "connecting" | "dropped" | "watchdog" | "terminal";
 }
-declare function mapIdentity(row: unknown): PlayerIdentity;
-declare function platformIconUrl(url: string | undefined): string | undefined;
-interface LeaderboardPeriod {
-    readonly id: string;
-    readonly localDate?: string;
-    readonly startAt?: number;
-    readonly endsAt?: number;
-    readonly opensAt: number;
-    readonly closesAt: number;
-    readonly final: boolean;
+interface GemSeatedEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.seatedEvent";
+    readonly roomId: string;
 }
-interface LeaderboardEntry extends RankedRow, PlayerIdentity {
-    readonly rank: number;
-    readonly occurredAt: number;
-    readonly entityId?: string;
-    readonly entityType?: EntityType$1;
-    readonly stats?: Readonly<Record<string, number>>;
-    readonly properties?: Readonly<Record<string, unknown>>;
-    readonly isViewer?: boolean;
+interface GemAutoStartFailedEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.autoStartFailedEvent";
+    readonly roomId: string;
+    readonly code: string;
 }
-interface Leaderboard {
-    readonly leaderboardType: string;
-    readonly runType: string;
-    readonly bucket1?: string;
-    readonly bucket2?: string;
-    readonly entries: readonly LeaderboardEntry[];
-    readonly generatedAt: number;
-    readonly updateFrequencySeconds?: number;
-    readonly period?: LeaderboardPeriod;
+interface GemTicketEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.ticketEvent";
+    readonly event: "queued" | "matched" | "expired" | "cancelled" | "failed";
+    readonly ticketId: string;
+    readonly partySize?: number;
+    readonly queuedAt?: number;
+    readonly expiresAt?: number;
+    readonly reason?: string;
+    readonly roomId?: string;
 }
-interface RankedRow {
-    readonly rank: number;
-    readonly occurredAt: number;
-    readonly stats?: Readonly<Record<string, number>>;
-    readonly properties?: Readonly<Record<string, unknown>>;
+interface GemSignalEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.signalEvent";
+    readonly event: "hello" | "offer" | "answer" | "ice" | "peerJoined" | "peerLeft" | "migration" | "matchEnded" | "error";
+    readonly matchId: string;
+    readonly data: unknown;
 }
-interface EntityLeaderboardEntry extends RankedRow {
-    readonly rank: number;
-    readonly stats?: Readonly<Record<string, number>>;
+interface GemRelayDraining {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.relayDraining";
+    readonly matchId: string;
+    readonly clusterTargetId: string;
+    readonly relayIps: string[];
+    readonly drainingSince: string;
+    readonly deadline: string;
 }
-interface EntityLeaderboard {
-    readonly leaderboardType: string;
-    readonly runType: string;
-    readonly entityType: EntityType$1;
-    readonly entityId: string;
-    readonly bucket1?: string;
-    readonly bucket2?: string;
-    readonly entries: readonly EntityLeaderboardEntry[];
-    readonly personalBest: EntityLeaderboardEntry | null;
-    readonly totalRuns: number;
-    readonly totalRunsExact: boolean;
-    readonly generatedAt: number;
-    readonly period?: LeaderboardPeriod;
+interface GemDedicatedEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.dedicatedEvent";
+    readonly event: "answer" | "error" | "matchEnded";
+    readonly matchId: string;
+    readonly sdp?: string;
+    readonly sessionId?: string;
+    readonly code?: string;
+    readonly message?: string;
+    readonly reason?: string;
 }
-interface PeriodOptions {
-    readonly periodsBack?: number;
-    readonly period?: string;
-    readonly playerId?: string;
+interface GemPartyResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.partyResult";
+    readonly requestId: string;
+    readonly partyId?: string;
 }
-interface EntityLeaderboardOptions extends PeriodOptions {
-    readonly bucket1?: string;
-    readonly bucket2?: string;
-    readonly limit?: number;
-    readonly signal?: AbortSignal;
+interface GemClusterTarget {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.clusterTarget";
+    readonly clusterTargetId: string;
+    readonly clusterTargetIds?: string[];
 }
-interface GetLeaderboardOptions extends PeriodOptions {
-    readonly bucket1?: string;
-    readonly bucket2?: string;
-    readonly signal?: AbortSignal;
+interface GemGraphicsRoutes {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.graphicsRoutes";
+    readonly entries: {
+        gpu: string;
+        route?: string;
+        host?: string;
+    }[];
 }
-declare class LeaderboardsApi {
-    #private;
-    constructor(api: GameApi$1);
-    get(leaderboardType: string, options?: GetLeaderboardOptions): Promise<Leaderboard>;
-    friends(leaderboardType: string, options?: GetLeaderboardOptions): Promise<Leaderboard>;
-    mine(leaderboardType: string, options?: EntityLeaderboardOptions): Promise<EntityLeaderboard>;
-    character(leaderboardType: string, characterId: string, options?: EntityLeaderboardOptions): Promise<EntityLeaderboard>;
+interface GemScreenshotDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.screenshot.denied";
+    readonly reason: "not_wired" | "no_source" | "unsupported" | "unreadable" | "tainted" | "too_large" | "busy" | "declined" | "failed";
+    readonly retryable: boolean;
 }
-interface ShowcaseValue {
-    readonly playerId: string;
-    readonly key: string;
-    readonly value: unknown;
-    readonly updatedAt: number;
+interface GemDedicatedOffer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.dedicatedOffer";
+    readonly matchId: string;
+    readonly sdp: string;
+    readonly intent: "initial" | "ice_restart" | "full_reconnect";
 }
-interface ShowcaseFriendEntry extends PlayerIdentity {
-    readonly playerId: string;
-    readonly value: unknown;
-    readonly isViewer: boolean;
-    readonly updatedAt: number;
+interface GemLocalServer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.localServer";
+    readonly requestId: string;
+    readonly serverId?: string;
 }
-interface ShowcaseFriends {
-    readonly key: string;
-    readonly entries: readonly ShowcaseFriendEntry[];
-    readonly generatedAt: number;
+interface GemLocalServerDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.localServer.denied";
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly reason: "refused" | "unavailable";
 }
-interface ShowcaseCallOptions {
-    readonly signal?: AbortSignal;
+interface GemMenuSelect {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.menuSelect";
+    readonly entry: "settings" | "item";
+    readonly id?: string;
 }
-declare class ShowcaseApi {
-    private readonly api;
-    private readonly selfPlayerId;
-    constructor(api: GameApi$1, selfPlayerId: () => Promise<string>);
-    friends(key: string, options?: ShowcaseCallOptions): Promise<ShowcaseFriends>;
-    of(playerId: string, key: string, options?: ShowcaseCallOptions): Promise<ShowcaseValue | null>;
-    set(key: string, value: unknown, options?: ShowcaseCallOptions): Promise<ShowcaseValue>;
-    clear(key: string, options?: ShowcaseCallOptions): Promise<void>;
+interface GemSettingsDeclare {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.settingsDeclare";
+    readonly settings: {
+        id: string;
+        label: string;
+        kind: "toggle" | "slider" | "choice";
+        value: boolean | number | string;
+        quick?: boolean;
+        icon?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+        options?: {
+            id: string;
+            label: string;
+        }[];
+    }[];
 }
-interface Friend extends PlayerIdentity {
-    readonly playerId: string;
+interface GemSettingChange {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.settingChange";
+    readonly id: string;
+    readonly value: boolean | number | string;
 }
-interface FriendsPage {
-    readonly friends: readonly Friend[];
-    readonly nextCursor?: string;
+interface GemShareResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.shareResult";
+    readonly requestId: string;
+    readonly outcome: "accepted" | "refused";
+    readonly reason?: string;
+    readonly key?: string;
 }
-interface ListFriendsOptions {
-    readonly limit?: number;
-    readonly cursor?: string;
-    readonly signal?: AbortSignal;
+interface GemPurchaseResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.purchaseResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
+    readonly purchaseId?: string;
 }
-interface FriendChallenge {
-    readonly id: string;
-    readonly from: Friend;
-    readonly template: string;
-    readonly params: Readonly<Record<string, string | number>>;
-    readonly createdAt: number;
-    readonly openedAt?: number;
-    readonly answeredAt?: number;
+interface GemPurchaseSettled {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.purchaseSettled";
+    readonly purchaseKind: "item" | "recipe";
+    readonly targetId: string;
+    readonly catalogId?: string;
+    readonly quantity: number;
+    readonly purchaseId?: string;
 }
-interface FriendChallengesPage {
-    readonly challenges: readonly FriendChallenge[];
-    readonly nextCursor?: string;
+interface GemDeviceSettingsResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings.result";
+    readonly requestId: string;
+    readonly outcome: "stored" | "too_large" | "unavailable";
 }
-interface ListFriendChallengesOptions {
-    readonly limit?: number;
-    readonly cursor?: string;
-    readonly signal?: AbortSignal;
+interface GemAdResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.adResult";
+    readonly requestId: string;
+    readonly outcome: "shown" | "no_ad" | "unavailable";
 }
-interface FriendChallengeRequest {
-    readonly playerId: string;
-    readonly template: string;
-    readonly params?: Readonly<Record<string, string | number>>;
+interface GemMomentResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.momentResult";
+    readonly requestId: string;
+    readonly shown: boolean;
 }
-type FriendChallengeOutcomeKind = "accepted" | "cancelled" | "refused" | "unavailable";
-interface FriendChallengeOutcome {
-    readonly outcome: FriendChallengeOutcomeKind;
+interface GemSignInResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.signInResult";
+    readonly requestId: string;
+    readonly outcome: "signed_in" | "declined" | "unavailable";
 }
-type FriendChallengeErrorCode = "unknown_template" | "template_not_on_channel" | "param_invalid" | "param_undeclared" | "recipient_invalid" | (string & {});
-declare class FriendChallengeError extends GemApiError {
-    readonly code?: FriendChallengeErrorCode;
+interface GemFriendChallengeResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.friendChallengeResult";
+    readonly requestId: string;
+    readonly outcome: "accepted" | "cancelled" | "refused" | "unavailable" | "rate_limited" | "invalid";
+    readonly code?: string;
     readonly param?: string;
     readonly channel?: string;
     readonly configVersion?: number;
-    constructor(source: GemApiError, extra?: {
-        readonly param?: string;
-        readonly channel?: string;
-        readonly configVersion?: number;
-    });
+    readonly retryAfterMs?: number;
+    readonly detail?: string;
 }
-interface PlayInviteRequest {
-    readonly params?: Readonly<Record<string, string>>;
+interface GemRequestPlayInvite {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestPlayInvite";
+    readonly requestId: string;
+    readonly params?: {
+        key: string;
+        value: string;
+    }[];
 }
-interface FriendsApiDependencies {
-    readonly challenge?: (request: FriendChallengeRequest) => Promise<FriendChallengeOutcome>;
-    readonly inviteToPlay?: (request?: PlayInviteRequest) => Promise<boolean>;
-    readonly setInviteParams?: (params: Readonly<Record<string, string>> | null) => boolean;
-    readonly launchedChallengeId?: string;
+interface GemPlayInviteResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.playInviteResult";
+    readonly requestId: string;
+    readonly shown: boolean;
 }
-declare class FriendsApi {
-    #private;
-    constructor(api: GameApi$1, dependencies?: FriendsApiDependencies);
-    list(options?: ListFriendsOptions): Promise<FriendsPage>;
-    challenge(request: FriendChallengeRequest): Promise<FriendChallengeOutcome>;
-    inviteToPlay(request?: PlayInviteRequest): Promise<boolean>;
-    setInviteParams(params: Readonly<Record<string, string>> | null): boolean;
-    inbox(options?: ListFriendChallengesOptions): Promise<FriendChallengesPage>;
-    launchedChallenge(options?: {
-        readonly signal?: AbortSignal;
-    }): Promise<FriendChallenge | null>;
-    markAnswered(id: string): Promise<void>;
+interface GemInviteParams {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.inviteParams";
+    readonly params?: {
+        key: string;
+        value: string;
+    }[];
 }
-type PlatformCurrencyAccess = "read" | "spend";
-interface PlatformCurrency {
-    readonly slug: string;
-    readonly currencyId: string;
-    readonly balance: number;
-    readonly access: PlatformCurrencyAccess;
+interface GemRequestAppLinks {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestAppLinks";
+    readonly requestId: string;
 }
-interface PlatformCurrencyReadOptions {
-    readonly signal?: AbortSignal;
+interface GemAppLinksResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.appLinksResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
+    readonly arcade?: {
+        store: "app_store" | "google_play";
+    };
+    readonly game?: {
+        store: "app_store" | "google_play";
+    };
 }
-declare class PlatformCurrenciesApi {
-    #private;
-    constructor(api: GameApi$1);
-    get(options?: PlatformCurrencyReadOptions): Promise<readonly PlatformCurrency[]>;
+interface GemRequestOpenApp {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestOpenApp";
+    readonly requestId: string;
+    readonly target: "arcade" | "game";
 }
-type EarnAllowancePeriod = "day" | "window";
-interface EarnAllowance {
-    readonly currencySlug: string;
-    readonly currencyId: string;
-    readonly limit: number;
-    readonly earned: number;
-    readonly remaining: number;
-    readonly period: EarnAllowancePeriod;
-    readonly periodDays: number;
-    readonly resetsAt?: number;
+interface GemOpenAppResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.openAppResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
 }
-interface EarnAllowanceReadOptions {
-    readonly signal?: AbortSignal;
+interface GemRequestOpenGame {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestOpenGame";
+    readonly requestId: string;
+    readonly ref: string;
 }
-interface EarnAllowanceSignal {
-    on(listener: () => void): () => void;
-    emit(): void;
+interface GemOpenGameResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.openGameResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
 }
-type EarnAllowanceEvent = "changed";
-declare class PlatformEarnAllowanceApi {
-    #private;
-    constructor(api: GameApi$1, signal?: EarnAllowanceSignal, log?: ((line: string) => void) | null);
-    get(options?: EarnAllowanceReadOptions): Promise<readonly EarnAllowance[]>;
-    on(event: EarnAllowanceEvent, listener: () => void): () => void;
+interface GemRequestSimilarGames {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestSimilarGames";
+    readonly requestId: string;
+    readonly limit?: number;
 }
-declare class PlatformApi {
-    readonly currencies: PlatformCurrenciesApi;
-    readonly earnAllowance: PlatformEarnAllowanceApi;
-    constructor(api: GameApi$1, earnAllowanceSignal?: EarnAllowanceSignal, log?: ((line: string) => void) | null);
+interface GemSimilarGamesResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.similarGamesResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
+    readonly games: {
+        gameId: string;
+        slug?: string;
+        iconUrl: string;
+        capsuleLandscapeUrl: string;
+        capsulePortraitUrl: string;
+        previewVideoUrl?: string;
+        previewPosterUrl?: string;
+        untrusted: {
+            name: string;
+            tagline: string;
+            shortDescription: string;
+            tags: string[];
+        };
+    }[];
 }
-interface ProfileShowcaseEntry$1 {
-    readonly key: string;
-    readonly visibility: string;
-    readonly value: unknown;
-    readonly updatedAt: number;
+interface GemRequestStoreOffers {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestStoreOffers";
+    readonly requestId: string;
 }
-interface PlayerProfile extends PlayerIdentity {
-    readonly playerId: string;
-    readonly showcase: readonly ProfileShowcaseEntry$1[];
-    readonly generatedAt: number;
+interface GemStoreOffersResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.storeOffersResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
+    readonly offers: {
+        skuId: string;
+        kind: "gem_pack" | "boost" | "pass" | "bundle";
+        name: string;
+        description: string;
+        imageUrl?: string;
+        priceDisplay: string;
+        grant?: {
+            currency: string;
+            amount: number;
+        };
+        pass?: string;
+        earnMultipliers?: {
+            currencySlug: string;
+            multiplierBp: number;
+        }[];
+    }[];
 }
-interface ProfileCallOptions {
-    readonly signal?: AbortSignal;
+interface GemRequestStorePurchase {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestStorePurchase";
+    readonly requestId: string;
+    readonly skuId: string;
 }
-declare class ProfilesApi {
-    #private;
-    constructor(api: GameApi$1);
-    of(playerId: string, options?: ProfileCallOptions): Promise<PlayerProfile | null>;
+interface GemStorePurchaseResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.storePurchaseResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
 }
-interface FunctionInvokeOptions {
-    readonly signal?: AbortSignal;
-    readonly cueId?: string;
+interface GemStorePurchaseSettled {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.storePurchaseSettled";
+    readonly skuId: string;
 }
-interface FunctionResult {
-    readonly bytes: Uint8Array;
-    readonly invocationId?: string;
-    text(): string;
-    json<T = unknown>(): T;
+interface GemRequestStoreOfferSheet {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestStoreOfferSheet";
+    readonly requestId: string;
+    readonly skuId: string;
 }
-type FunctionFailure = "trap" | "memory_exceeded" | "cpu_budget_exceeded" | "host_call_limit" | "output_too_large" | "argument_too_large";
-declare class GemFunctionError extends GemApiError {
-    readonly invocationId?: string;
-    readonly functionMessage?: string;
-    readonly failure?: FunctionFailure | (string & {});
-    constructor(source: GemApiError, extra: {
-        readonly invocationId?: string;
-        readonly functionMessage?: string;
-        readonly failure?: string;
-    });
-    get retryable(): boolean;
+interface GemStoreOfferSheetResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.storeOfferSheetResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly reason?: string;
 }
-declare class FunctionsApi {
-    #private;
-    constructor(invoke: (body: Uint8Array, options?: {
-        signal?: AbortSignal;
-        cue_id?: string;
-    }) => Promise<BytesResponse>);
-    invoke(input: unknown, options?: FunctionInvokeOptions): Promise<FunctionResult>;
+interface PlayerBoostMultiplier {
+    readonly currencyId: string;
+    readonly currencySlug: string;
+    readonly multiplier: number;
 }
-type SessionEndReason = "grant_expiring" | "session_ended" | "navigating" | "kill_switch" | "pagehide";
-type MatchTransport = "dedicated" | "p2p";
-type PlatformEventName = "gem_session_start" | "gem_session_end" | "gem_pause" | "gem_resume" | "gem_boot_ready" | "gem_match_started" | "gem_match_ended" | "gem_auth_lost" | "gem_graphics_context_lost";
-declare const PLATFORM_EVENTS: readonly PlatformEventName[];
-type AnalyticsValue = string | number;
-interface AnalyticsRejection$1 {
-    readonly index: number;
-    readonly code: string;
+interface PlayerBoost {
+    readonly active: boolean;
+    readonly multipliers: readonly PlayerBoostMultiplier[];
+    readonly expiresInDays?: number;
 }
-interface AnalyticsFlushResult {
-    readonly accepted: number;
-    readonly rejected: readonly AnalyticsRejection$1[];
-    readonly dropped: number;
-    readonly duplicate: boolean;
+interface PlayerBadge$1 {
+    readonly itemId: string;
+    readonly iconUrl: string;
 }
-interface AnalyticsFlushOptions {
-    readonly keepalive?: boolean;
-    readonly signal?: AbortSignal;
+type Avatar3dFamily = "small_human" | "adult_human" | (string & {});
+interface WornAvatar3d$1 {
+    readonly family: Avatar3dFamily;
+    readonly id: string;
+    readonly modelUrl: string;
+    readonly iconUrl: string;
 }
-interface AnalyticsOptions {
-    readonly enabled?: boolean;
-    readonly flushIntervalMs?: number;
-    readonly maxQueue?: number;
+interface PlayerIdentity {
+    readonly playerId?: string;
+    readonly displayName?: PlayerText;
+    readonly discriminator?: string;
+    readonly displayTag?: PlayerText;
+    readonly avatarIconId?: string;
+    readonly avatarIconUrl?: string;
+    readonly avatar3dId?: string;
+    readonly avatar3dModelUrl?: string;
+    readonly avatar3dIconUrl?: string;
+    readonly avatars3d?: readonly WornAvatar3d$1[];
+    readonly badges: readonly PlayerBadge$1[];
 }
-interface AnalyticsApiOptions {
-    readonly environment?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
-    readonly client: () => GemClient;
-    readonly clock: Clock;
-    readonly gameId: () => string | null;
-    readonly playerId: () => string | null;
-    readonly awaitPlayerId?: () => Promise<string>;
-    readonly declarations?: () => Promise<readonly {
+declare function mapIdentity(row: unknown): PlayerIdentity;
+declare function platformIconUrl(url: string | undefined): string | undefined;
+interface RewardCue {
+    currencySlug: string;
+    cueId?: string;
+    expected?: number;
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+type GemCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+type RewardPresentation = "arcade" | "game";
+interface MenuStyle {
+    readonly ground: string;
+    readonly accent: string;
+}
+type FrameState = "waiting" | "connected" | "refused" | "closed";
+interface FramePlayer extends PlayerIdentity {
+    readonly displayName: PlayerText;
+    readonly displayHandle: PlayerText;
+    readonly avatarUrl?: string;
+    readonly boost: PlayerBoost;
+}
+type GemArcadeAsk = Omit<GemRequestAppLinks, "gem"> | Omit<GemRequestOpenApp, "gem"> | Omit<GemRequestOpenGame, "gem"> | Omit<GemRequestSimilarGames, "gem"> | Omit<GemRequestStoreOffers, "gem"> | Omit<GemRequestStorePurchase, "gem"> | Omit<GemRequestStoreOfferSheet, "gem">;
+type GemFriendsWindowAsk = Omit<GemRequestPlayInvite, "gem"> | Omit<GemInviteParams, "gem">;
+type GemArcadeAnswer = GemAppLinksResult | GemOpenAppResult | GemOpenGameResult | GemSimilarGamesResult | GemStoreOffersResult | GemStorePurchaseResult | GemStorePurchaseSettled | GemStoreOfferSheetResult;
+interface FrameCallbacks {
+    onToken?(msg: GemToken): void;
+    onPause?(msg: GemPause): void;
+    onMenuSelect?(msg: GemMenuSelect): void;
+    onSettingChange?(msg: GemSettingChange): void;
+    onPrefs?(msg: GemPrefs$1): void;
+    onCohorts?(msg: GemCohorts$1): void;
+    onEarnAllowanceChanged?(): void;
+    onInventoryChanged?(msg: GemInventoryChanged): void;
+    onViewport?(msg: GemViewport$1): void;
+    onWillTerminate?(msg: GemWillTerminate): void;
+    onDevtools?(action: "open" | "close" | "toggle"): void;
+    onScreenshot?(request: {
+        maxWidth: number;
+        maxHeight: number;
+    }, port: MessagePort, deny: (reason: GemScreenshotDenied["reason"], retryable: boolean) => void): void;
+    onRequestContext?(): void;
+    onTokenDenied?(msg: GemTokenDenied): void;
+    onLocalServer?(msg: GemLocalServer): void;
+    onLocalServerDenied?(msg: GemLocalServerDenied): void;
+    onPlayer?(player: FramePlayer, signInAvailable?: boolean): void;
+    onRoomEvent?(msg: GemRoomEvent): void;
+    onSeatedEvent?(msg: GemSeatedEvent): void;
+    onAutoStartFailedEvent?(msg: GemAutoStartFailedEvent): void;
+    onTicketEvent?(msg: GemTicketEvent): void;
+    onSocketState?(msg: GemSocketState): void;
+    onSignalEvent?(msg: GemSignalEvent): void;
+    onRelayDraining?(msg: GemRelayDraining): void;
+    onDedicatedEvent?(msg: GemDedicatedEvent): void;
+    onClusterTarget?(msg: GemClusterTarget): void;
+    onGraphicsRoutes?(msg: GemGraphicsRoutes): void;
+    onPartyResult?(msg: GemPartyResult): void;
+    onPurchaseResult?(msg: GemPurchaseResult): void;
+    onPurchaseSettled?(msg: GemPurchaseSettled): void;
+    onShareResult?(msg: GemShareResult): void;
+    onDeviceSettings?(msg: GemDeviceSettings): void;
+    onDeviceSettingsResult?(msg: GemDeviceSettingsResult): void;
+    onAdResult?(msg: GemAdResult): void;
+    onMomentResult?(msg: GemMomentResult): void;
+    onSignInResult?(msg: GemSignInResult): void;
+    onFriendChallengeResult?(msg: GemFriendChallengeResult): void;
+    onArcadeAnswer?(msg: GemArcadeAnswer): void;
+    onPlayInviteResult?(msg: GemPlayInviteResult): void;
+    onError?(code: GemErrorCode, message?: string): void;
+    onDropped?(code: GemErrorCode, message?: string): void;
+    onStateChange?(state: FrameState): void;
+    onRefused?(reason: string): void;
+}
+interface FrameOptions extends FrameCallbacks {
+    allowedEmbedders: readonly string[];
+    selfOrigin?: string;
+    expectedSource: unknown;
+    capabilities?: readonly string[];
+    clock?: Clock;
+}
+declare class GemFrame {
+    private readonly options;
+    private state;
+    private port;
+    private version;
+    private peerCapabilities;
+    private unbidden;
+    private engagedSent;
+    private readyPending;
+    private readySent;
+    private settleWaiters;
+    private readonly clock;
+    private readonly inbound;
+    private readonly outbound;
+    private readonly expectedSource;
+    constructor(options: FrameOptions);
+    get currentState(): FrameState;
+    get parentCapabilities(): readonly string[];
+    parentSupports(capability: string): boolean;
+    get protocolVersion(): number | null;
+    get unbiddenLaunch(): boolean;
+    handleWindowMessage(event: HandshakeEvent): boolean;
+    ready(): void;
+    settled(timeoutMs?: number): Promise<FrameState>;
+    progress(loaded: number, total: number): void;
+    requestToken(requestId: string, reason: "initial" | "expiring" | "rejected"): void;
+    requestLocalServer(requestId: string, gameRoomId: string): boolean;
+    exit(reason?: string): void;
+    openExternal(url: string): void;
+    requestFullscreen(enabled: boolean): void;
+    reportMuted(muted: boolean): boolean;
+    reportEngaged(): boolean;
+    cueReward(cue: RewardCue): boolean;
+    showPortraitBorders(name: string | null): boolean;
+    setWalletVisible(visible: boolean, options?: {
+        only?: readonly string[];
+    }): boolean;
+    setMenu(items?: ReadonlyArray<{
         readonly id: string;
-        readonly dimensions?: Readonly<Record<string, unknown>> | null;
-    }[] | null | undefined>;
-    readonly options?: AnalyticsOptions;
-    readonly log?: ((message: string) => void) | null;
+        readonly label: string;
+    }>): boolean;
+    declareSettings(settings: GemSettingsDeclare["settings"]): boolean;
+    setGemCorner(corner: GemCorner): boolean;
+    setRewardPresentation(mode: RewardPresentation): boolean;
+    setMenuStyle(style: MenuStyle | null): boolean;
+    requestShare(params: ReadonlyArray<{
+        readonly key: string;
+        readonly value: string;
+    }>, requestId?: string): boolean;
+    requestAvatarPicker(tab?: "2d" | "3d"): boolean;
+    requestVibrate(pattern: readonly number[]): boolean;
+    reportFrameStats(stats: {
+        fps: number;
+        frameTimeP95Ms: number;
+        counts?: "pageFrames" | "gameDraws";
+    }): boolean;
+    sendGameContext(context: Record<string, unknown>): boolean;
+    signal(signal: string, matchId: string, data: Record<string, unknown>): void;
+    dedicatedOffer(matchId: string, sdp: string, intent: GemDedicatedOffer["intent"]): void;
+    requestParty(requestId: string): boolean;
+    requestPurchase(requestId: string, purchaseKind: "item" | "recipe", targetId: string, currencySlug: string, quantity?: number, catalogId?: string, origin?: "sheet" | "direct_refused"): boolean;
+    requestAvatar3dPurchase(requestId: string, itemId: string, currencySlug: string): boolean;
+    putDeviceSettings(requestId: string, settings: Readonly<Record<string, unknown>>): boolean;
+    requestAd(requestId: string, placement: string, format: "interstitial" | "rewarded"): boolean;
+    signalMoment(requestId: string, kind: string, placement?: string, wall?: boolean): boolean;
+    readyCalled(): boolean;
+    requestSignIn(requestId: string): boolean;
+    requestFriendChallenge(requestId: string, playerId: string, template: string, params?: Readonly<Record<string, string | number>>): boolean;
+    requestArcade(msg: GemArcadeAsk | GemFriendsWindowAsk): boolean;
+    close(): void;
+    private transition;
+    private refuseMalformed;
+    private dropUnknownType;
+    private refuse;
+    private fail;
+    private gated;
+    private send;
+    private receive;
+    private dispatchInbound;
+    private screenshotDenied;
 }
-declare class AnalyticsApi {
-    #private;
-    constructor(options: AnalyticsApiOptions);
-    track(name: string, props?: Readonly<Record<string, AnalyticsValue>>): void;
-    setContext(props: Readonly<Record<string, AnalyticsValue>>): void;
-    experiment(key: string, count: number): Promise<number>;
-    experiment<T extends string>(key: string, options: readonly T[]): Promise<T>;
-    get environment(): Readonly<Record<string, string>>;
-    flush(options?: AnalyticsFlushOptions): Promise<AnalyticsFlushResult>;
-    trackPlatform(name: PlatformEventName, props?: Readonly<Record<string, AnalyticsValue>>): void;
-    hold(): void;
-    release(): void;
-    get held(): boolean;
-    startSession(): void;
-    endSession(reason: SessionEndReason): void;
-    setPaused(paused: boolean): void;
-    setHidden(hidden: boolean): void;
-    dispose(): void;
-    get pending(): number;
+type ArcadeOutcomeKind = "ok" | "declined" | "unavailable";
+interface ArcadeOutcome {
+    readonly outcome: ArcadeOutcomeKind;
+    readonly reason?: string;
 }
-interface BootMark {
+interface ArcadeOffer {
+    readonly skuId: string;
+    readonly kind: ArcadeOfferKind;
     readonly name: string;
-    readonly at: number;
+    readonly description: string;
+    readonly imageUrl?: string;
+    readonly priceDisplay: string;
+    readonly grant?: {
+        readonly currency: string;
+        readonly amount: number;
+    };
+    readonly pass?: string;
+    readonly earnMultipliers: readonly ArcadeOfferEarnMultiplier[];
 }
-interface BootTimeline {
-    mark(name: string, at?: number): boolean;
-    timeline(): string;
-    readonly marks: readonly BootMark[];
+type ArcadeOfferKind = "coin_pack" | "gem_pack" | "boost" | "pass" | "bundle";
+interface ArcadeOfferEarnMultiplier {
+    readonly currencySlug: string;
+    readonly multiplierBp: number;
 }
-interface BootTimelineOptions {
-    readonly now?: () => number;
+interface ShowPassOutcome extends ArcadeOutcome {
+    readonly held: boolean;
 }
-declare function markOnResolve<T>(boot: BootTimeline, name: string, work: Promise<T>, log?: ((message: string) => void) | null): Promise<T>;
-declare function reportOnResolve(boot: BootTimeline, log?: ((message: string) => void) | null): <T>(work: Promise<T>) => Promise<T>;
-declare function createBootTimeline(options?: BootTimelineOptions): BootTimeline;
-type GemGraphicsRoute = "webgpu" | "webgl";
-interface GemPreferredRoute {
-    readonly route: GemGraphicsRoute;
-    readonly listed: boolean;
+interface StoreOffersOutcome extends ArcadeOutcome {
+    readonly offers: readonly ArcadeOffer[];
 }
-interface GemGraphicsRouteEntry {
-    readonly gpu: string;
-    readonly route?: string;
-    readonly host?: string;
+interface StoreSettlement {
+    readonly skuId: string;
 }
-interface PreferredRouteOptions {
-    readonly timeoutMs?: number;
+interface StoreApi {
+    readonly available: boolean;
+    readonly showOfferAvailable: boolean;
+    offers(): Promise<StoreOffersOutcome>;
+    purchase(skuId: string): Promise<ArcadeOutcome>;
+    showOffer(skuId: string): Promise<ArcadeOutcome>;
+    showPass(slug: string): Promise<ShowPassOutcome>;
+    passOnSale(slug: string): Promise<boolean>;
+    onSettled(listener: (settlement: StoreSettlement) => void): () => void;
 }
-interface GraphicsApi {
-    preferredRoute(options?: PreferredRouteOptions): Promise<GemPreferredRoute>;
+type PlatformGrantSource = {
+    readonly source: "pass";
+    readonly pass: string;
+    readonly amount: number;
+} | {
+    readonly source: "boost";
+    readonly amount: number;
+};
+interface PlatformGrantPreview {
+    readonly currencySlug?: string;
+    readonly currencyId?: string;
+    readonly base: number;
+    readonly total: number;
+    readonly breakdown: readonly PlatformGrantSource[];
+    readonly ifComplete?: true;
 }
-type DevToolsOpener = "game" | "platform";
-interface GemDevTools {
-    open(): Promise<boolean>;
-    close(): void;
-    readonly isOpen: boolean;
+interface EarningsApi {
+    fromReceipt(change: unknown): Promise<PlatformGrantPreview | null>;
 }
-type ClusterTargetLike = string | null | undefined;
-declare const CLIENT_PLATFORMS: readonly [
-    "universal",
-    "mobile",
-    "web"
-];
-type ClientPlatform$1 = (typeof CLIENT_PLATFORMS)[number];
-interface ClientVersion {
-    readonly platform?: ClientPlatform$1;
-    readonly gameVersion: string;
-    readonly engineVersion?: string;
+type PreviewTarget = {
+    readonly recipe: string;
+} | {
+    readonly progression: string;
+    readonly add?: number;
+};
+type PreviewGrant = {
+    readonly kind: "item";
+    readonly itemId: string;
+    readonly quantity: number;
+} | {
+    readonly kind: "currency";
+    readonly currencyId: string;
+    readonly amount: number;
+} | {
+    readonly kind: "roll";
+    readonly lootTableId: string;
+    readonly count: number;
+};
+interface UnmetRequirement {
+    readonly index: number;
+    readonly kind: string;
 }
-interface ReadyMatch {
-    readonly status: "ready";
-    readonly matchId: string;
-    readonly protocol: string;
-    readonly joinCredential?: string;
-    readonly credentialExpiresAt?: number;
-    readonly host?: string;
-    readonly port?: number;
+interface BonusPreview {
+    readonly id: string;
+    readonly grants: readonly PreviewGrant[];
+    readonly eligible: boolean | "unknown";
+    readonly unmet: readonly UnmetRequirement[];
 }
-interface StartMatchWaiting {
-    readonly attempt: number;
-    readonly elapsedMs: number;
-    readonly budgetMs: number;
-    readonly nextAttemptInMs: number;
-    readonly status: number;
-    readonly message: string;
+interface PassUpsell {
+    readonly pass: string;
+    readonly name: string;
+    readonly offer: ArcadeOffer;
+    readonly platformGrants: readonly {
+        readonly currencySlug?: string;
+        readonly currencyId?: string;
+        readonly total: number;
+        readonly extra: number;
+        readonly ifComplete?: true;
+    }[];
+    readonly bonuses: readonly {
+        readonly id: string;
+        readonly grants: readonly PreviewGrant[];
+    }[];
 }
-interface StartMatchRetryOptions {
-    readonly budgetMs?: number;
-    readonly initialDelayMs?: number;
-    readonly maxDelayMs?: number;
-    readonly onWaiting?: (waiting: StartMatchWaiting) => void;
+interface ConfigPreview {
+    readonly grants: readonly PreviewGrant[];
+    readonly platformGrants: readonly PlatformGrantPreview[];
+    readonly bonuses: readonly BonusPreview[];
+    readonly upsells: readonly PassUpsell[];
+}
+interface PreviewHoldings {
+    readonly items: ReadonlyMap<string, number> | null;
+    readonly currencies: ReadonlyMap<string, number> | null;
+    readonly progressions: ReadonlyMap<string, {
+        readonly value: number;
+        readonly completed: boolean;
+    }> | null;
+    readonly passes: ReadonlyMap<string, boolean> | null;
+}
+interface PreviewBoost {
+    readonly currencyId?: string;
+    readonly currencySlug?: string;
+    readonly multiplierBp: number;
+}
+declare class PreviewError extends Error {
+    readonly code: "not_found" | "invalid_argument" | "unsupported";
+    constructor(code: "not_found" | "invalid_argument" | "unsupported", message: string);
 }
-interface ClusterTarget {
-    readonly id: string;
-    readonly pressure: string;
+interface GameConfig extends GameConfigSnapshot {
+    items: GameConfigSnapshot["items"];
+    currencies: GameConfigSnapshot["currencies"];
+    catalogs: GameConfigSnapshot["catalogs"];
+    loot_tables: GameConfigSnapshot["loot_tables"];
+    affix_pools?: GameConfigSnapshot["affix_pools"];
+    progressions: GameConfigSnapshot["progressions"];
+    game_room_templates: GameConfigSnapshot["game_room_templates"];
+    kv: GameConfigSnapshot["kv"];
+    run_types?: GameConfigSnapshot["run_types"];
+    leaderboards?: GameConfigSnapshot["leaderboards"];
+    async_opponent_types?: GameConfigSnapshot["async_opponent_types"];
+    analytics_events?: GameConfigSnapshot["analytics_events"];
+    analytics_funnels?: GameConfigSnapshot["analytics_funnels"];
+    "rewarded_placements"?: SnapshotRewardedPlacement[];
+    version: GameConfigSnapshot["version"];
+    hash: GameConfigSnapshot["hash"];
+    item(idOrSlug: string): SnapshotItem | null;
+    currency(idOrSlug: string): SnapshotCurrency | null;
 }
-type DedicatedServerFailure = "timeout" | "aborted" | "allocation_failed" | "no_server_ready" | "start_rate_limited" | "p2p_unavailable" | "unsupported_protocol" | "credential_expired" | "credential_reused" | "join_rate_limited" | "signaling_unavailable" | "signaling_failed" | "offer_refused" | "invalid_sdp" | "media_refused" | "connection_failed" | "join_refused" | "match_ended" | "misconfigured";
-declare class DedicatedServerError extends Error {
-    readonly reason: DedicatedServerFailure;
-    readonly retryable: boolean;
-    readonly platformCode: string | undefined;
-    constructor(reason: DedicatedServerFailure, message: string, options?: {
-        cause?: unknown;
-        platformCode?: string;
-    });
+declare class GemConfigError extends Error {
+    readonly reason: "config_unreachable" | "config_too_large" | "config_malformed" | "config_timeout" | "config_channel_unknown";
+    constructor(reason: "config_unreachable" | "config_too_large" | "config_malformed" | "config_timeout" | "config_channel_unknown", message: string);
 }
-type SignalingIntent = "initial" | "ice_restart" | "full_reconnect";
-interface OfferRequest {
-    readonly matchId: string;
-    readonly sdp: string;
-    readonly intent: SignalingIntent;
+interface PreviewSources {
+    boost(): readonly PreviewBoost[];
+    holdings(needsInventory: boolean): Promise<PreviewHoldings>;
+    offers(): Promise<readonly ArcadeOffer[]>;
 }
-interface SignalingAnswer {
-    readonly sdp: string;
+interface GameConfigOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    readonly timeoutMs?: number;
 }
-interface SignalingChannel {
-    exchange(request: OfferRequest, signal?: AbortSignal): Promise<SignalingAnswer>;
-    close(): void;
+interface DropRateEntry$1 {
+    readonly entryId: string;
+    readonly weight: number;
+    readonly dropRate: number;
+    readonly rarityTier?: string;
 }
-type SdpType$1 = "offer" | "answer" | "pranswer" | "rollback";
-interface SessionDescriptionLike$1 {
-    readonly type: SdpType$1;
-    readonly sdp?: string;
+interface DropRates {
+    readonly lootTableId: string;
+    readonly name: string;
+    readonly rollCount: number;
+    readonly allowDuplicateRolls: boolean;
+    readonly totalWeight: number;
+    readonly entries: readonly DropRateEntry$1[];
 }
-interface DataChannelInitLike$1 {
-    readonly ordered?: boolean;
-    readonly maxRetransmits?: number;
+declare class GameConfigApi {
+    private readonly api;
+    private readonly channel;
+    private readonly options;
+    private loaded;
+    private inFlight;
+    private generation;
+    private readonly dropRatesByConfig;
+    constructor(api: GameApi$1, channel: () => string, options?: GameConfigOptions);
+    load(): Promise<GameConfig | null>;
+    refresh(): void;
+    bindPreview(sources: PreviewSources): void;
+    private previewSources;
+    preview(target: PreviewTarget): Promise<ConfigPreview>;
+    dropRates(lootTableId: string, signal?: AbortSignal): Promise<DropRates>;
+    private fetchConfig;
 }
-interface EventTargetLike$1 {
-    addEventListener(type: string, listener: (event: unknown) => void): void;
-    removeEventListener(type: string, listener: (event: unknown) => void): void;
+declare const MAX_PERIODS_BACK = 400;
+type ChallengeWindow = "daily" | "weekly" | "monthly" | "cron" | (string & {});
+interface Challenge {
+    readonly id: string;
+    readonly slug?: string;
+    readonly window: ChallengeWindow;
+    readonly periodStartAt: number;
+    readonly periodEndsAt: number;
+    readonly periodLocalDate?: string;
+    readonly boundary: string;
+    readonly resetTime: string;
+    readonly seed: string;
+    readonly data?: string;
+    readonly dataHash?: string;
 }
-interface DataChannelLike$1 extends EventTargetLike$1 {
-    readonly readyState: string;
-    send(data: string | Uint8Array): void;
-    close(): void;
+interface ListChallengesOptions {
+    readonly periodsBack?: number;
+    readonly signal?: AbortSignal;
+}
+declare class ChallengesApi {
+    #private;
+    constructor(api: GameApi$1);
+    list(options?: ListChallengesOptions): Promise<Challenge[]>;
 }
-interface PeerConnectionLike$1 extends EventTargetLike$1 {
-    readonly localDescription: SessionDescriptionLike$1 | null;
-    readonly iceGatheringState: string;
-    createDataChannel(label: string, init?: DataChannelInitLike$1): DataChannelLike$1;
-    createOffer(): Promise<SessionDescriptionLike$1>;
-    setLocalDescription(description: SessionDescriptionLike$1): Promise<void>;
-    setRemoteDescription(description: SessionDescriptionLike$1): Promise<void>;
-    close(): void;
+interface LeaderboardPeriod {
+    readonly id: string;
+    readonly localDate?: string;
+    readonly startAt?: number;
+    readonly endsAt?: number;
+    readonly opensAt: number;
+    readonly closesAt: number;
+    readonly final: boolean;
 }
-interface JoinWelcome {
-    readonly playerId?: string;
-    readonly matchId?: string;
-    readonly heartbeatIntervalMs?: number;
+interface LeaderboardEntry extends RankedRow, PlayerIdentity {
+    readonly rank: number;
+    readonly occurredAt: number;
+    readonly entityId?: string;
+    readonly entityType?: EntityType$1;
+    readonly stats?: Readonly<Record<string, number>>;
+    readonly properties?: Readonly<Record<string, unknown>>;
+    readonly isViewer?: boolean;
 }
-interface JoinExchange {
-    readonly welcome: JoinWelcome;
-    detach(): void;
+interface Leaderboard {
+    readonly leaderboardType: string;
+    readonly runType: string;
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly entries: readonly LeaderboardEntry[];
+    readonly generatedAt: number;
+    readonly updateFrequencySeconds?: number;
+    readonly period?: LeaderboardPeriod;
 }
-interface PresentCredentialOptions {
-    readonly channel: DataChannelLike$1;
-    readonly credential: string;
-    readonly credentialExpiresAt: number;
-    readonly clock: Clock;
-    readonly ceilingMs?: number;
-    readonly wire?: number;
-    readonly heartbeat?: boolean;
-    readonly onMessage?: (data: unknown) => void;
-    readonly signal?: AbortSignal;
+interface RankedRow {
+    readonly rank: number;
+    readonly occurredAt: number;
+    readonly stats?: Readonly<Record<string, number>>;
+    readonly properties?: Readonly<Record<string, unknown>>;
 }
-declare function presentJoinCredential(options: PresentCredentialOptions): Promise<JoinExchange>;
-type TransportKind = "webtransport" | "webrtc" | "websocket";
-declare const UNRELIABLE_CHANNEL_LABEL = "gem-uu";
-interface SendOptions$1 {
-    readonly reliable?: boolean;
-    readonly ordered?: boolean;
+interface EntityLeaderboardEntry extends RankedRow {
+    readonly rank: number;
+    readonly stats?: Readonly<Record<string, number>>;
 }
-interface MessageMeta {
-    readonly reliable: boolean;
-    readonly ordered: boolean;
+interface EntityLeaderboard {
+    readonly leaderboardType: string;
+    readonly runType: string;
+    readonly entityType: EntityType$1;
+    readonly entityId: string;
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly entries: readonly EntityLeaderboardEntry[];
+    readonly personalBest: EntityLeaderboardEntry | null;
+    readonly totalRuns: number;
+    readonly totalRunsExact: boolean;
+    readonly generatedAt: number;
+    readonly period?: LeaderboardPeriod;
 }
-interface GameServerLink {
-    readonly transport: TransportKind;
-    send(data: Uint8Array | string, options?: SendOptions$1): void;
-    onMessage(handler: (data: Uint8Array | string, meta: MessageMeta) => void): void;
-    onClose(handler: (reason?: string) => void): void;
-    close(): void;
+interface PeriodOptions {
+    readonly periodsBack?: number;
+    readonly period?: string;
+    readonly playerId?: string;
 }
-interface TransportAdvert {
-    readonly v: number;
-    readonly host: string;
-    readonly port: number;
-    readonly match_id: string;
-    readonly webrtc?: boolean;
-    readonly webtransport?: {
-        readonly url: string;
-        readonly cert_sha256_b64: string;
-        readonly expires_at?: number;
-        readonly named_url?: string;
-    };
-    readonly websocket?: {
-        readonly url: string;
-        readonly tls?: boolean;
-    };
+interface EntityLeaderboardOptions extends PeriodOptions {
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
 }
-declare function readTemplateTransports(value: unknown): readonly TransportKind[] | null;
-declare function readTransportAdvert(settings: unknown, forMatch?: string): TransportAdvert | null;
-declare function webTransportAvailable(): boolean;
-type RoomArgScalar = string | number | boolean;
-type RoomArgValue$1 = RoomArgScalar | readonly RoomArgScalar[];
-type RoomArgs = Readonly<Record<string, RoomArgValue$1>>;
-type RoomArgType$1 = "string" | "int" | "float" | "bool" | (string & {});
-interface RoomArgEntry {
-    readonly name: string;
-    readonly type: RoomArgType$1;
-    readonly list: boolean;
-    readonly required: boolean;
-    readonly mutable: boolean;
-    readonly fixed?: RoomArgValue$1;
-    readonly default?: RoomArgValue$1;
-    readonly description?: string;
-    readonly allowed?: readonly RoomArgScalar[];
-    readonly min?: number;
-    readonly max?: number;
-    readonly minItems?: number;
-    readonly maxItems?: number;
-    readonly maxLength?: number;
+interface GetLeaderboardOptions extends PeriodOptions {
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly signal?: AbortSignal;
 }
-type RoomStatus = "open" | "in_game" | "closed" | (string & {});
-type PlayWithOutcome = "joined" | "unavailable";
-type MatchConnectionState = "disconnected" | "connecting" | "connected" | "suspended";
-type MatchSessionPhase = "none" | "starting" | "ready" | "connected" | "suspended" | "ended" | (string & {});
-interface MatchSession {
-    readonly phase: MatchSessionPhase;
-    readonly matchId?: string;
-    readonly reason?: string;
-    readonly roomReopened?: boolean;
+declare class LeaderboardsApi {
+    #private;
+    constructor(api: GameApi$1);
+    get(leaderboardType: string, options?: GetLeaderboardOptions): Promise<Leaderboard>;
+    friends(leaderboardType: string, options?: GetLeaderboardOptions): Promise<Leaderboard>;
+    mine(leaderboardType: string, options?: EntityLeaderboardOptions): Promise<EntityLeaderboard>;
+    character(leaderboardType: string, characterId: string, options?: EntityLeaderboardOptions): Promise<EntityLeaderboard>;
 }
-interface MatchEnded {
-    readonly matchId: string;
-    readonly reason: string;
-    readonly roomReopened: boolean;
+interface ShowcaseValue {
+    readonly playerId: string;
+    readonly key: string;
+    readonly value: unknown;
+    readonly updatedAt: number;
 }
-interface MatchSuspended {
-    readonly matchId: string;
-    readonly cause: string;
+interface ShowcaseFriendEntry extends PlayerIdentity {
+    readonly playerId: string;
+    readonly value: unknown;
+    readonly isViewer: boolean;
+    readonly updatedAt: number;
 }
-interface MatchReconnecting {
-    readonly matchId: string;
-    readonly attempt: number;
-    readonly attempts: number;
-    readonly remainingMs: number;
+interface ShowcaseFriends {
+    readonly key: string;
+    readonly entries: readonly ShowcaseFriendEntry[];
+    readonly generatedAt: number;
 }
-interface MatchReconnected {
-    readonly matchId: string;
-    readonly attempt: number;
+interface ShowcaseCallOptions {
+    readonly signal?: AbortSignal;
 }
-interface AutoReconnectOptions {
-    readonly budgetMs?: number;
-    readonly attempts?: number;
-    readonly maxDelayMs?: number;
+declare class ShowcaseApi {
+    private readonly api;
+    private readonly selfPlayerId;
+    constructor(api: GameApi$1, selfPlayerId: () => Promise<string>);
+    friends(key: string, options?: ShowcaseCallOptions): Promise<ShowcaseFriends>;
+    of(playerId: string, key: string, options?: ShowcaseCallOptions): Promise<ShowcaseValue | null>;
+    set(key: string, value: unknown, options?: ShowcaseCallOptions): Promise<ShowcaseValue>;
+    clear(key: string, options?: ShowcaseCallOptions): Promise<void>;
 }
-interface RoomMember extends PlayerIdentity {
+interface Friend extends PlayerIdentity {
     readonly playerId: string;
-    readonly isReady: boolean;
-    readonly role: string;
-    readonly joinedAt: number;
-    readonly groupId?: string;
-    readonly platform?: string;
 }
-interface Room {
-    readonly id: string;
-    readonly gameId: string;
-    readonly name: string;
-    readonly status: RoomStatus;
-    readonly hostPlayerId: string;
-    readonly maxPlayers: number;
-    readonly memberCount: number;
-    readonly members: readonly RoomMember[];
-    readonly isPublic: boolean;
-    readonly joinCode?: string;
-    readonly settings?: unknown;
-    readonly roomArgs?: RoomArgs;
-    readonly roomArgsTemplate?: readonly RoomArgEntry[];
-    readonly gameChannel: string;
-    readonly region?: string;
-    readonly clusterTargetId?: string;
-    readonly selfHosted: boolean;
-    readonly matchId?: string;
-    readonly version: number;
-    readonly templateId?: string;
-    readonly templateSlug?: string;
-    readonly roomType: string;
-    readonly transports?: readonly TransportKind[];
-    readonly createdAt: number;
-    readonly updatedAt: number;
-    readonly startedAt?: number;
+interface FriendsPage {
+    readonly friends: readonly Friend[];
+    readonly nextCursor?: string;
 }
-interface MatchAutoStartFailed {
-    readonly roomId: string;
-    readonly code: string;
-    readonly handled: boolean;
+interface ListFriendsOptions {
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
 }
-interface RoomSummary {
+interface FriendChallenge {
     readonly id: string;
-    readonly gameId: string;
-    readonly name: string;
-    readonly status: RoomStatus;
-    readonly hostPlayerId: string;
-    readonly maxPlayers: number;
-    readonly memberCount: number;
-    readonly isPublic: boolean;
-    readonly gameChannel: string;
-    readonly roomType: string;
+    readonly from: Friend;
+    readonly template: string;
+    readonly params: Readonly<Record<string, string | number>>;
     readonly createdAt: number;
+    readonly openedAt?: number;
+    readonly answeredAt?: number;
 }
-interface RoomPage {
-    readonly rooms: readonly RoomSummary[];
+interface FriendChallengesPage {
+    readonly challenges: readonly FriendChallenge[];
     readonly nextCursor?: string;
 }
-interface RoomOperationError {
-    readonly operation: string;
-    readonly code: number;
-    readonly reason: string;
-    readonly message: string;
-    readonly retryable: boolean;
-}
-interface QueueForMatchOptions {
-    readonly templateSlugs: readonly string[];
-    readonly partyId?: string;
+interface ListFriendChallengesOptions {
+    readonly limit?: number;
+    readonly cursor?: string;
     readonly signal?: AbortSignal;
 }
-type MatchTicketStatus = "queued" | "matched" | "expired" | "cancelled" | "failed" | "lost" | "unavailable";
-type MatchTicketOutcome = {
-    readonly status: "matched";
-    readonly room: Room;
-} | {
-    readonly status: "expired";
-    readonly reason: string;
-} | {
-    readonly status: "cancelled";
-    readonly reason: string;
-} | {
-    readonly status: "failed";
-    readonly reason: string;
-} | {
-    readonly status: "lost";
-} | {
-    readonly status: "unavailable";
-};
-interface MatchTicket {
-    readonly id: string;
-    readonly status: MatchTicketStatus;
-    readonly partySize: number;
-    readonly queuedAt: number;
-    readonly expiresAt: number;
-    readonly outcome: Promise<MatchTicketOutcome>;
-    cancel(): Promise<MatchTicketOutcome>;
+interface FriendChallengeRequest {
+    readonly playerId: string;
+    readonly template: string;
+    readonly params?: Readonly<Record<string, string | number>>;
 }
-interface CreateRoomOptions {
-    readonly name: string;
-    readonly maxPlayers?: number;
-    readonly isPublic?: boolean;
-    readonly settings?: unknown;
-    readonly region?: string;
-    readonly templateId?: string;
-    readonly templateSlug?: string;
-    readonly partyId?: string;
-    readonly roomArgs?: RoomArgs;
-    readonly signal?: AbortSignal;
+type FriendChallengeOutcomeKind = "accepted" | "cancelled" | "refused" | "unavailable";
+interface FriendChallengeOutcome {
+    readonly outcome: FriendChallengeOutcomeKind;
 }
-interface JoinRoomOptions {
-    readonly partyId?: string;
-    readonly signal?: AbortSignal;
+type FriendChallengeErrorCode = "unknown_template" | "template_not_on_channel" | "param_invalid" | "param_undeclared" | "recipient_invalid" | (string & {});
+declare class FriendChallengeError extends GemApiError {
+    readonly code?: FriendChallengeErrorCode;
+    readonly param?: string;
+    readonly channel?: string;
+    readonly configVersion?: number;
+    constructor(source: GemApiError, extra?: {
+        readonly param?: string;
+        readonly channel?: string;
+        readonly configVersion?: number;
+    });
 }
-interface QuickJoinOptions extends JoinRoomOptions {
-    readonly templateSlug?: string;
-    readonly templateSlugs?: readonly string[];
-    readonly templateId?: string;
-    readonly region?: string;
-    readonly name?: string;
+interface PlayInviteRequest {
+    readonly params?: Readonly<Record<string, string>>;
 }
-interface ListRoomsOptions {
-    readonly status?: "open" | "in_game";
-    readonly templateSlug?: string;
-    readonly limit?: number;
-    readonly cursor?: string;
+interface FriendsApiDependencies {
+    readonly challenge?: (request: FriendChallengeRequest) => Promise<FriendChallengeOutcome>;
+    readonly inviteToPlay?: (request?: PlayInviteRequest) => Promise<boolean>;
+    readonly setInviteParams?: (params: Readonly<Record<string, string>> | null) => boolean;
+    readonly launchedChallengeId?: string;
+}
+declare class FriendsApi {
+    #private;
+    constructor(api: GameApi$1, dependencies?: FriendsApiDependencies);
+    list(options?: ListFriendsOptions): Promise<FriendsPage>;
+    challenge(request: FriendChallengeRequest): Promise<FriendChallengeOutcome>;
+    inviteToPlay(request?: PlayInviteRequest): Promise<boolean>;
+    setInviteParams(params: Readonly<Record<string, string>> | null): boolean;
+    inbox(options?: ListFriendChallengesOptions): Promise<FriendChallengesPage>;
+    launchedChallenge(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<FriendChallenge | null>;
+    markAnswered(id: string): Promise<void>;
+}
+type PlatformCurrencyAccess = "read" | "spend";
+interface PlatformCurrency {
+    readonly slug: string;
+    readonly currencyId: string;
+    readonly balance: number;
+    readonly access: PlatformCurrencyAccess;
+}
+interface PlatformCurrencyReadOptions {
     readonly signal?: AbortSignal;
 }
-interface UpdateRoomOptions {
-    readonly name?: string;
-    readonly maxPlayers?: number;
-    readonly isPublic?: boolean;
-    readonly settings?: unknown;
-    readonly roomArgs?: RoomArgs;
+declare class PlatformCurrenciesApi {
+    #private;
+    constructor(api: GameApi$1);
+    get(options?: PlatformCurrencyReadOptions): Promise<readonly PlatformCurrency[]>;
+}
+type EarnAllowancePeriod = "day" | "window";
+interface EarnAllowance {
+    readonly currencySlug: string;
+    readonly currencyId: string;
+    readonly limit: number;
+    readonly earned: number;
+    readonly remaining: number;
+    readonly period: EarnAllowancePeriod;
+    readonly periodDays: number;
+    readonly resetsAt?: number;
+}
+interface EarnAllowanceReadOptions {
     readonly signal?: AbortSignal;
 }
-type PartyTicketStatus = "queued" | "matched" | "expired" | "cancelled" | "failed" | "lost";
-type PartyTicketOutcome = {
-    readonly status: "matched";
-} | {
-    readonly status: "expired";
-    readonly reason: string;
-} | {
-    readonly status: "cancelled";
-    readonly reason: string;
-} | {
-    readonly status: "failed";
-    readonly reason: string;
-} | {
-    readonly status: "lost";
-};
-interface PartyTicket {
-    readonly id: string;
-    readonly status: PartyTicketStatus;
-    readonly partySize: number;
-    readonly queuedAt: number;
-    readonly expiresAt: number;
-    readonly outcome: Promise<PartyTicketOutcome>;
+interface EarnAllowanceSignal {
+    on(listener: () => void): () => void;
+    emit(): void;
 }
-interface RelayedTicketEvent {
-    readonly event: "queued" | "matched" | "expired" | "cancelled" | "failed";
-    readonly ticketId: string;
-    readonly partySize?: number;
-    readonly queuedAt?: number;
-    readonly expiresAt?: number;
-    readonly reason?: string;
-    readonly roomId?: string;
+type EarnAllowanceEvent = "changed";
+declare class PlatformEarnAllowanceApi {
+    #private;
+    constructor(api: GameApi$1, signal?: EarnAllowanceSignal, log?: ((line: string) => void) | null);
+    get(options?: EarnAllowanceReadOptions): Promise<readonly EarnAllowance[]>;
+    on(event: EarnAllowanceEvent, listener: () => void): () => void;
 }
-interface RoomEventMap {
-    created: [
-        Room
-    ];
-    joined: [
-        Room
-    ];
-    left: [
-    ];
-    closed: [
-    ];
-    updated: [
-        Room
-    ];
-    seated: [
-        Room
-    ];
-    partyQueued: [
-        PartyTicket
-    ];
-    listed: [
-        RoomPage
-    ];
-    mineListed: [
-        readonly RoomSummary[]
-    ];
-    memberJoined: [
-        string
-    ];
-    memberLeft: [
-        string
-    ];
-    kicked: [
-    ];
-    readyChanged: [
-        string,
-        boolean
-    ];
-    hostChanged: [
-        string
-    ];
-    matchStartWaiting: [
-        StartMatchWaiting
-    ];
-    matchAutoStartFailed: [
-        MatchAutoStartFailed
-    ];
-    matchAllocationStarted: [
-        string
-    ];
-    matchReady: [
-        ReadyMatch
-    ];
-    matchFailed: [
-        string,
-        string
-    ];
-    matchEnded: [
-        MatchEnded
-    ];
-    matchSuspended: [
-        MatchSuspended
-    ];
-    matchReconnecting: [
-        MatchReconnecting
-    ];
-    matchReconnected: [
-        MatchReconnected
-    ];
-    versionUpdateAvailable: [
-        ClientPlatform$1 | undefined
-    ];
-    error: [
-        RoomOperationError
-    ];
+declare class PlatformApi {
+    readonly currencies: PlatformCurrenciesApi;
+    readonly earnAllowance: PlatformEarnAllowanceApi;
+    constructor(api: GameApi$1, earnAllowanceSignal?: EarnAllowanceSignal, log?: ((line: string) => void) | null);
 }
-type RoomEventName = keyof RoomEventMap;
-interface MatchEndHint {
-    readonly matchId?: string;
-    readonly reason?: string;
+interface ProfileShowcaseEntry$1 {
+    readonly key: string;
+    readonly visibility: string;
+    readonly value: unknown;
+    readonly updatedAt: number;
 }
-interface RelayedRoomEvent {
-    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
-    readonly roomId: string;
-    readonly matchId?: string;
-    readonly version?: number;
-    readonly reason?: string;
-    readonly platform?: ClientPlatform$1;
+interface PlayerProfile extends PlayerIdentity {
+    readonly playerId: string;
+    readonly showcase: readonly ProfileShowcaseEntry$1[];
+    readonly generatedAt: number;
 }
-interface StartMatchOptions {
-    readonly clusterTargetId?: ClusterTargetLike;
-    readonly retry?: StartMatchRetryOptions;
+interface ProfileCallOptions {
     readonly signal?: AbortSignal;
 }
-interface AwaitMatchOptions {
-    readonly timeoutMs?: number;
-    readonly pollIntervalMs?: number;
+declare class ProfilesApi {
+    #private;
+    constructor(api: GameApi$1);
+    of(playerId: string, options?: ProfileCallOptions): Promise<PlayerProfile | null>;
+}
+interface FunctionInvokeOptions {
     readonly signal?: AbortSignal;
+    readonly cueId?: string;
 }
-interface StartedMatch {
-    readonly matchId: string;
-    readonly status: string;
+interface FunctionResult {
+    readonly bytes: Uint8Array;
+    readonly invocationId?: string;
+    text(): string;
+    json<T = unknown>(): T;
 }
-interface RoomManager {
-    create(options: CreateRoomOptions): Promise<Room>;
-    join(roomId: string, options?: JoinRoomOptions): Promise<Room>;
-    joinByCode(code: string, options?: JoinRoomOptions): Promise<Room>;
-    quickJoin(options: QuickJoinOptions): Promise<Room>;
-    queueForMatch(options: QueueForMatchOptions): Promise<MatchTicket>;
-    list(options?: ListRoomsOptions): Promise<RoomPage>;
-    myRooms(signal?: AbortSignal): Promise<readonly RoomSummary[]>;
-    leave(options?: {
-        asGroup?: boolean;
-        signal?: AbortSignal;
-        keepalive?: boolean;
-    }): Promise<void>;
-    leaveAll(signal?: AbortSignal): Promise<readonly string[]>;
-    close(signal?: AbortSignal): Promise<void>;
-    refresh(signal?: AbortSignal): Promise<Room | null>;
-    setReady(isReady: boolean, signal?: AbortSignal): Promise<Room>;
-    kick(playerId: string, signal?: AbortSignal): Promise<Room>;
-    transferHost(playerId: string, signal?: AbortSignal): Promise<Room>;
-    update(options: UpdateRoomOptions): Promise<Room>;
-    startMatch(options?: StartMatchOptions): Promise<StartedMatch>;
-    awaitMatch(options?: AwaitMatchOptions): Promise<ReadyMatch>;
-    pollMatchStatus(options?: AwaitMatchOptions): Promise<ReadyMatch>;
-    notifyMatchConnected(matchId: string): void;
-    notifyMatchDisconnected(cause?: string): Promise<void>;
-    reconnectToMatch(options?: AwaitMatchOptions): Promise<ReadyMatch>;
-    notifyLeavingMatch(options?: {
-        keepalive?: boolean;
-    }): Promise<void>;
-    readonly gameId: string | null;
-    readonly currentRoom: Room | null;
-    readonly currentTicket: MatchTicket | null;
-    readonly partyTicket: PartyTicket | null;
-    readonly currentMatch: ReadyMatch | null;
-    readonly matchConnectionState: MatchConnectionState;
-    readonly matchSession: MatchSession;
-    readonly isInRoom: boolean;
-    readonly isHost: boolean;
-    readonly members: readonly Room["members"][number][];
-    readonly playWith: PlayWithOutcome | null;
-    on<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): () => void;
-    off<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): void;
-    once<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): () => void;
-    handleRoomEvent(event: RelayedRoomEvent): void;
-    handleSeated(roomId: string): void;
-    handleAutoStartFailed(roomId: string, code: string): void;
-    handleTicketEvent(event: RelayedTicketEvent): void;
-    reconcileSeats(): Promise<void>;
-    reconcile(hint?: MatchEndHint): Promise<void>;
-    startPolling(intervalMs?: number): void;
-    stopPolling(): void;
-    settled(): Promise<void>;
-    dispose(): void;
+type FunctionFailure = "trap" | "memory_exceeded" | "cpu_budget_exceeded" | "host_call_limit" | "output_too_large" | "argument_too_large";
+declare class GemFunctionError extends GemApiError {
+    readonly invocationId?: string;
+    readonly functionMessage?: string;
+    readonly failure?: FunctionFailure | (string & {});
+    constructor(source: GemApiError, extra: {
+        readonly invocationId?: string;
+        readonly functionMessage?: string;
+        readonly failure?: string;
+    });
+    get retryable(): boolean;
 }
-declare const PROTOCOL: "gem-web-bridge";
-type GemErrorCode = "version_mismatch" | "handshake_timeout" | "handshake_duplicate" | "invalid_message" | "rate_limited" | "token_unavailable" | "unsupported" | "unsupported_capability" | "internal";
-interface GemToken {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.token";
-    readonly token: string;
-    readonly requestId?: string;
-    readonly generation: number;
-    readonly apiBaseUrl?: string;
-    readonly playerId: string;
-    readonly gameId: string;
-    readonly channel: "dev" | "test" | "release";
-    readonly gameVersion?: string;
-    readonly expiresAt: number;
-    readonly chainEndsAt: number;
-    readonly allowDevTools?: boolean;
+declare class FunctionsApi {
+    #private;
+    constructor(invoke: (body: Uint8Array, options?: {
+        signal?: AbortSignal;
+        cue_id?: string;
+    }) => Promise<BytesResponse>);
+    invoke(input: unknown, options?: FunctionInvokeOptions): Promise<FunctionResult>;
 }
-interface GemTokenDenied {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.token.denied";
-    readonly requestId: string;
-    readonly retryable: boolean;
-    readonly retryAfterMs?: number;
-    readonly reason: "chain_exhausted" | "unavailable";
-    readonly correlationId: string;
+type SessionEndReason = "grant_expiring" | "session_ended" | "navigating" | "kill_switch" | "pagehide";
+type MatchTransport = "dedicated" | "p2p";
+type PlatformEventName = "gem_session_start" | "gem_session_end" | "gem_pause" | "gem_resume" | "gem_boot_ready" | "gem_match_started" | "gem_match_ended" | "gem_auth_lost" | "gem_graphics_context_lost";
+declare const PLATFORM_EVENTS: readonly PlatformEventName[];
+type AnalyticsValue = string | number;
+interface AnalyticsRejection$1 {
+    readonly index: number;
+    readonly code: string;
 }
-interface GemPause {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.pause";
-    readonly paused: boolean;
+interface AnalyticsFlushResult {
+    readonly accepted: number;
+    readonly rejected: readonly AnalyticsRejection$1[];
+    readonly dropped: number;
+    readonly duplicate: boolean;
 }
-interface GemPrefs$1 {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.prefs";
-    readonly reducedMotion: boolean;
-    readonly muted: boolean;
-    readonly showFrameStats?: boolean;
-    readonly music?: boolean;
-    readonly sounds?: boolean;
-    readonly locale: string;
-    readonly recommended?: {
-        volume: number;
-        batterySaver: boolean;
-        keyboardLayout: "wasd" | "arrows";
-        gamepadConfirm: "south" | "east";
-        vibration: boolean;
-        lookSensitivity?: number;
-        gamepadLookSensitivity?: number;
-        invertLookY?: boolean;
-        touchMovement?: string;
-        graphicsQuality?: string;
-        graphicsQualityAuto?: boolean;
-        colorHelp?: boolean;
-        textScale?: number;
-    };
+interface AnalyticsFlushOptions {
+    readonly keepalive?: boolean;
+    readonly signal?: AbortSignal;
 }
-interface GemCohorts$1 {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.cohorts";
-    readonly cohorts: {
-        experimentId: string;
-        variantKey: string;
-    }[];
+interface AnalyticsOptions {
+    readonly enabled?: boolean;
+    readonly flushIntervalMs?: number;
+    readonly maxQueue?: number;
 }
-interface GemInventoryChanged {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.inventoryChanged";
+interface AnalyticsApiOptions {
+    readonly environment?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
+    readonly client: () => GemClient;
+    readonly clock: Clock;
+    readonly gameId: () => string | null;
+    readonly playerId: () => string | null;
+    readonly awaitPlayerId?: () => Promise<string>;
+    readonly declarations?: () => Promise<readonly {
+        readonly id: string;
+        readonly dimensions?: Readonly<Record<string, unknown>> | null;
+    }[] | null | undefined>;
+    readonly options?: AnalyticsOptions;
+    readonly log?: ((message: string) => void) | null;
 }
-interface GemViewport$1 {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.viewport";
-    readonly insets: {
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    };
-    readonly reserved?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        control?: {
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-        };
-    }[];
+declare class AnalyticsApi {
+    #private;
+    constructor(options: AnalyticsApiOptions);
+    track(name: string, props?: Readonly<Record<string, AnalyticsValue>>): void;
+    setContext(props: Readonly<Record<string, AnalyticsValue>>): void;
+    experiment(key: string, count: number): Promise<number>;
+    experiment<T extends string>(key: string, options: readonly T[]): Promise<T>;
+    get environment(): Readonly<Record<string, string>>;
+    flush(options?: AnalyticsFlushOptions): Promise<AnalyticsFlushResult>;
+    trackPlatform(name: PlatformEventName, props?: Readonly<Record<string, AnalyticsValue>>): void;
+    hold(): void;
+    release(): void;
+    get held(): boolean;
+    startSession(): void;
+    endSession(reason: SessionEndReason): void;
+    setPaused(paused: boolean): void;
+    setHidden(hidden: boolean): void;
+    dispose(): void;
+    get pending(): number;
 }
-interface GemDeviceSettings {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.deviceSettings";
-    readonly settings?: unknown;
+interface BootMark {
+    readonly name: string;
+    readonly at: number;
 }
-interface GemWillTerminate {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.willTerminate";
-    readonly reason: "grant_expiring" | "session_ended" | "navigating" | "kill_switch";
-    readonly graceMs: number;
+interface BootTimeline {
+    mark(name: string, at?: number): boolean;
+    timeline(): string;
+    readonly marks: readonly BootMark[];
 }
-interface GemRoomEvent {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.roomEvent";
-    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
-    readonly roomId: string;
-    readonly matchId?: string;
-    readonly version?: number;
-    readonly reason?: string;
-    readonly platform?: "universal" | "mobile";
+interface BootTimelineOptions {
+    readonly now?: () => number;
 }
-interface GemSocketState {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.socketState";
-    readonly connected: boolean;
-    readonly reason?: "connecting" | "dropped" | "watchdog" | "terminal";
+declare function markOnResolve<T>(boot: BootTimeline, name: string, work: Promise<T>, log?: ((message: string) => void) | null): Promise<T>;
+declare function reportOnResolve(boot: BootTimeline, log?: ((message: string) => void) | null): <T>(work: Promise<T>) => Promise<T>;
+declare function createBootTimeline(options?: BootTimelineOptions): BootTimeline;
+type GemGraphicsRoute = "webgpu" | "webgl";
+interface GemPreferredRoute {
+    readonly route: GemGraphicsRoute;
+    readonly listed: boolean;
 }
-interface GemSeatedEvent {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.seatedEvent";
-    readonly roomId: string;
+interface GemGraphicsRouteEntry {
+    readonly gpu: string;
+    readonly route?: string;
+    readonly host?: string;
 }
-interface GemAutoStartFailedEvent {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.autoStartFailedEvent";
-    readonly roomId: string;
-    readonly code: string;
+interface PreferredRouteOptions {
+    readonly timeoutMs?: number;
 }
-interface GemTicketEvent {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.ticketEvent";
-    readonly event: "queued" | "matched" | "expired" | "cancelled" | "failed";
-    readonly ticketId: string;
-    readonly partySize?: number;
-    readonly queuedAt?: number;
-    readonly expiresAt?: number;
-    readonly reason?: string;
-    readonly roomId?: string;
+interface GraphicsApi {
+    preferredRoute(options?: PreferredRouteOptions): Promise<GemPreferredRoute>;
 }
-interface GemSignalEvent {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.signalEvent";
-    readonly event: "hello" | "offer" | "answer" | "ice" | "peerJoined" | "peerLeft" | "migration" | "matchEnded" | "error";
-    readonly matchId: string;
-    readonly data: unknown;
+type DevToolsOpener = "game" | "platform";
+interface GemDevTools {
+    open(): Promise<boolean>;
+    close(): void;
+    readonly isOpen: boolean;
 }
-interface GemRelayDraining {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.relayDraining";
-    readonly matchId: string;
-    readonly clusterTargetId: string;
-    readonly relayIps: string[];
-    readonly drainingSince: string;
-    readonly deadline: string;
+type ClusterTargetLike = string | null | undefined;
+declare const CLIENT_PLATFORMS: readonly [
+    "universal",
+    "mobile",
+    "web"
+];
+type ClientPlatform$1 = (typeof CLIENT_PLATFORMS)[number];
+interface ClientVersion {
+    readonly platform?: ClientPlatform$1;
+    readonly gameVersion: string;
+    readonly engineVersion?: string;
 }
-interface GemDedicatedEvent {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.dedicatedEvent";
-    readonly event: "answer" | "error" | "matchEnded";
+interface ReadyMatch {
+    readonly status: "ready";
     readonly matchId: string;
-    readonly sdp?: string;
-    readonly sessionId?: string;
-    readonly code?: string;
-    readonly message?: string;
-    readonly reason?: string;
+    readonly protocol: string;
+    readonly joinCredential?: string;
+    readonly credentialExpiresAt?: number;
+    readonly host?: string;
+    readonly port?: number;
 }
-interface GemPartyResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.partyResult";
-    readonly requestId: string;
-    readonly partyId?: string;
+interface StartMatchWaiting {
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly budgetMs: number;
+    readonly nextAttemptInMs: number;
+    readonly status: number;
+    readonly message: string;
 }
-interface GemClusterTarget {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.clusterTarget";
-    readonly clusterTargetId: string;
-    readonly clusterTargetIds?: string[];
+interface StartMatchRetryOptions {
+    readonly budgetMs?: number;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly onWaiting?: (waiting: StartMatchWaiting) => void;
 }
-interface GemGraphicsRoutes {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.graphicsRoutes";
-    readonly entries: {
-        gpu: string;
-        route?: string;
-        host?: string;
-    }[];
+interface ClusterTarget {
+    readonly id: string;
+    readonly pressure: string;
 }
-interface GemScreenshotDenied {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.screenshot.denied";
-    readonly reason: "not_wired" | "no_source" | "unsupported" | "unreadable" | "tainted" | "too_large" | "busy" | "declined" | "failed";
+type DedicatedServerFailure = "timeout" | "aborted" | "allocation_failed" | "no_server_ready" | "start_rate_limited" | "p2p_unavailable" | "unsupported_protocol" | "credential_expired" | "credential_reused" | "join_rate_limited" | "signaling_unavailable" | "signaling_failed" | "offer_refused" | "invalid_sdp" | "media_refused" | "connection_failed" | "join_refused" | "match_ended" | "misconfigured";
+declare class DedicatedServerError extends Error {
+    readonly reason: DedicatedServerFailure;
     readonly retryable: boolean;
+    readonly platformCode: string | undefined;
+    constructor(reason: DedicatedServerFailure, message: string, options?: {
+        cause?: unknown;
+        platformCode?: string;
+    });
 }
-interface GemDedicatedOffer {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.dedicatedOffer";
+type SignalingIntent = "initial" | "ice_restart" | "full_reconnect";
+interface OfferRequest {
     readonly matchId: string;
     readonly sdp: string;
-    readonly intent: "initial" | "ice_restart" | "full_reconnect";
+    readonly intent: SignalingIntent;
 }
-interface GemLocalServer {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.localServer";
-    readonly requestId: string;
-    readonly serverId?: string;
+interface SignalingAnswer {
+    readonly sdp: string;
 }
-interface GemLocalServerDenied {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.localServer.denied";
-    readonly requestId: string;
-    readonly retryable: boolean;
-    readonly reason: "refused" | "unavailable";
+interface SignalingChannel {
+    exchange(request: OfferRequest, signal?: AbortSignal): Promise<SignalingAnswer>;
+    close(): void;
 }
-interface GemMenuSelect {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.menuSelect";
-    readonly entry: "settings" | "item";
-    readonly id?: string;
+type SdpType$1 = "offer" | "answer" | "pranswer" | "rollback";
+interface SessionDescriptionLike$1 {
+    readonly type: SdpType$1;
+    readonly sdp?: string;
 }
-interface GemSettingsDeclare {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.settingsDeclare";
-    readonly settings: {
-        id: string;
-        label: string;
-        kind: "toggle" | "slider" | "choice";
-        value: boolean | number | string;
-        quick?: boolean;
-        icon?: string;
-        min?: number;
-        max?: number;
-        step?: number;
-        options?: {
-            id: string;
-            label: string;
-        }[];
-    }[];
+interface DataChannelInitLike$1 {
+    readonly ordered?: boolean;
+    readonly maxRetransmits?: number;
+}
+interface EventTargetLike$1 {
+    addEventListener(type: string, listener: (event: unknown) => void): void;
+    removeEventListener(type: string, listener: (event: unknown) => void): void;
+}
+interface DataChannelLike$1 extends EventTargetLike$1 {
+    readonly readyState: string;
+    send(data: string | Uint8Array): void;
+    close(): void;
+}
+interface PeerConnectionLike$1 extends EventTargetLike$1 {
+    readonly localDescription: SessionDescriptionLike$1 | null;
+    readonly iceGatheringState: string;
+    createDataChannel(label: string, init?: DataChannelInitLike$1): DataChannelLike$1;
+    createOffer(): Promise<SessionDescriptionLike$1>;
+    setLocalDescription(description: SessionDescriptionLike$1): Promise<void>;
+    setRemoteDescription(description: SessionDescriptionLike$1): Promise<void>;
+    close(): void;
+}
+interface JoinWelcome {
+    readonly playerId?: string;
+    readonly matchId?: string;
+    readonly heartbeatIntervalMs?: number;
+}
+interface JoinExchange {
+    readonly welcome: JoinWelcome;
+    detach(): void;
+}
+interface PresentCredentialOptions {
+    readonly channel: DataChannelLike$1;
+    readonly credential: string;
+    readonly credentialExpiresAt: number;
+    readonly clock: Clock;
+    readonly ceilingMs?: number;
+    readonly wire?: number;
+    readonly heartbeat?: boolean;
+    readonly onMessage?: (data: unknown) => void;
+    readonly signal?: AbortSignal;
+}
+declare function presentJoinCredential(options: PresentCredentialOptions): Promise<JoinExchange>;
+type TransportKind = "webtransport" | "webrtc" | "websocket";
+declare const UNRELIABLE_CHANNEL_LABEL = "gem-uu";
+interface SendOptions$1 {
+    readonly reliable?: boolean;
+    readonly ordered?: boolean;
+}
+interface MessageMeta {
+    readonly reliable: boolean;
+    readonly ordered: boolean;
+}
+interface GameServerLink {
+    readonly transport: TransportKind;
+    send(data: Uint8Array | string, options?: SendOptions$1): void;
+    onMessage(handler: (data: Uint8Array | string, meta: MessageMeta) => void): void;
+    onClose(handler: (reason?: string) => void): void;
+    close(): void;
 }
-interface GemSettingChange {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.settingChange";
-    readonly id: string;
-    readonly value: boolean | number | string;
+interface TransportAdvert {
+    readonly v: number;
+    readonly host: string;
+    readonly port: number;
+    readonly match_id: string;
+    readonly webrtc?: boolean;
+    readonly webtransport?: {
+        readonly url: string;
+        readonly cert_sha256_b64: string;
+        readonly expires_at?: number;
+        readonly named_url?: string;
+    };
+    readonly websocket?: {
+        readonly url: string;
+        readonly tls?: boolean;
+    };
 }
-interface GemShareResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.shareResult";
-    readonly requestId: string;
-    readonly outcome: "accepted" | "refused";
-    readonly reason?: string;
-    readonly key?: string;
+declare function readTemplateTransports(value: unknown): readonly TransportKind[] | null;
+declare function readTransportAdvert(settings: unknown, forMatch?: string): TransportAdvert | null;
+declare function webTransportAvailable(): boolean;
+type RoomArgScalar = string | number | boolean;
+type RoomArgValue$1 = RoomArgScalar | readonly RoomArgScalar[];
+type RoomArgs = Readonly<Record<string, RoomArgValue$1>>;
+type RoomArgType$1 = "string" | "int" | "float" | "bool" | (string & {});
+interface RoomArgEntry {
+    readonly name: string;
+    readonly type: RoomArgType$1;
+    readonly list: boolean;
+    readonly required: boolean;
+    readonly mutable: boolean;
+    readonly fixed?: RoomArgValue$1;
+    readonly default?: RoomArgValue$1;
+    readonly description?: string;
+    readonly allowed?: readonly RoomArgScalar[];
+    readonly min?: number;
+    readonly max?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly maxLength?: number;
 }
-interface GemPurchaseResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.purchaseResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
+type RoomStatus = "open" | "in_game" | "closed" | (string & {});
+type PlayWithOutcome = "joined" | "unavailable";
+type MatchConnectionState = "disconnected" | "connecting" | "connected" | "suspended";
+type MatchSessionPhase = "none" | "starting" | "ready" | "connected" | "suspended" | "ended" | (string & {});
+interface MatchSession {
+    readonly phase: MatchSessionPhase;
+    readonly matchId?: string;
     readonly reason?: string;
-    readonly purchaseId?: string;
+    readonly roomReopened?: boolean;
 }
-interface GemPurchaseSettled {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.purchaseSettled";
-    readonly purchaseKind: "item" | "recipe";
-    readonly targetId: string;
-    readonly catalogId?: string;
-    readonly quantity: number;
-    readonly purchaseId?: string;
+interface MatchEnded {
+    readonly matchId: string;
+    readonly reason: string;
+    readonly roomReopened: boolean;
 }
-interface GemDeviceSettingsResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.deviceSettings.result";
-    readonly requestId: string;
-    readonly outcome: "stored" | "too_large" | "unavailable";
+interface MatchSuspended {
+    readonly matchId: string;
+    readonly cause: string;
 }
-interface GemAdResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.adResult";
-    readonly requestId: string;
-    readonly outcome: "shown" | "no_ad" | "unavailable";
+interface MatchReconnecting {
+    readonly matchId: string;
+    readonly attempt: number;
+    readonly attempts: number;
+    readonly remainingMs: number;
 }
-interface GemMomentResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.momentResult";
-    readonly requestId: string;
-    readonly shown: boolean;
+interface MatchReconnected {
+    readonly matchId: string;
+    readonly attempt: number;
 }
-interface GemSignInResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.signInResult";
-    readonly requestId: string;
-    readonly outcome: "signed_in" | "declined" | "unavailable";
+interface AutoReconnectOptions {
+    readonly budgetMs?: number;
+    readonly attempts?: number;
+    readonly maxDelayMs?: number;
 }
-interface GemFriendChallengeResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.friendChallengeResult";
-    readonly requestId: string;
-    readonly outcome: "accepted" | "cancelled" | "refused" | "unavailable" | "rate_limited" | "invalid";
-    readonly code?: string;
-    readonly param?: string;
-    readonly channel?: string;
-    readonly configVersion?: number;
-    readonly retryAfterMs?: number;
-    readonly detail?: string;
+interface RoomMember extends PlayerIdentity {
+    readonly playerId: string;
+    readonly isReady: boolean;
+    readonly role: string;
+    readonly joinedAt: number;
+    readonly groupId?: string;
+    readonly platform?: string;
 }
-interface GemRequestPlayInvite {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestPlayInvite";
-    readonly requestId: string;
-    readonly params?: {
-        key: string;
-        value: string;
-    }[];
+interface Room {
+    readonly id: string;
+    readonly gameId: string;
+    readonly name: string;
+    readonly status: RoomStatus;
+    readonly hostPlayerId: string;
+    readonly maxPlayers: number;
+    readonly memberCount: number;
+    readonly members: readonly RoomMember[];
+    readonly isPublic: boolean;
+    readonly joinCode?: string;
+    readonly settings?: unknown;
+    readonly roomArgs?: RoomArgs;
+    readonly roomArgsTemplate?: readonly RoomArgEntry[];
+    readonly gameChannel: string;
+    readonly region?: string;
+    readonly clusterTargetId?: string;
+    readonly selfHosted: boolean;
+    readonly matchId?: string;
+    readonly version: number;
+    readonly templateId?: string;
+    readonly templateSlug?: string;
+    readonly roomType: string;
+    readonly transports?: readonly TransportKind[];
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly startedAt?: number;
 }
-interface GemPlayInviteResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.playInviteResult";
-    readonly requestId: string;
-    readonly shown: boolean;
+interface MatchAutoStartFailed {
+    readonly roomId: string;
+    readonly code: string;
+    readonly handled: boolean;
 }
-interface GemInviteParams {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.inviteParams";
-    readonly params?: {
-        key: string;
-        value: string;
-    }[];
+interface RoomSummary {
+    readonly id: string;
+    readonly gameId: string;
+    readonly name: string;
+    readonly status: RoomStatus;
+    readonly hostPlayerId: string;
+    readonly maxPlayers: number;
+    readonly memberCount: number;
+    readonly isPublic: boolean;
+    readonly gameChannel: string;
+    readonly roomType: string;
+    readonly createdAt: number;
 }
-interface GemRequestAppLinks {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestAppLinks";
-    readonly requestId: string;
+interface RoomPage {
+    readonly rooms: readonly RoomSummary[];
+    readonly nextCursor?: string;
 }
-interface GemAppLinksResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.appLinksResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
-    readonly reason?: string;
-    readonly arcade?: {
-        store: "app_store" | "google_play";
-    };
-    readonly game?: {
-        store: "app_store" | "google_play";
-    };
+interface RoomOperationError {
+    readonly operation: string;
+    readonly code: number;
+    readonly reason: string;
+    readonly message: string;
+    readonly retryable: boolean;
 }
-interface GemRequestOpenApp {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestOpenApp";
-    readonly requestId: string;
-    readonly target: "arcade" | "game";
+interface QueueForMatchOptions {
+    readonly templateSlugs: readonly string[];
+    readonly partyId?: string;
+    readonly signal?: AbortSignal;
+}
+type MatchTicketStatus = "queued" | "matched" | "expired" | "cancelled" | "failed" | "lost" | "unavailable";
+type MatchTicketOutcome = {
+    readonly status: "matched";
+    readonly room: Room;
+} | {
+    readonly status: "expired";
+    readonly reason: string;
+} | {
+    readonly status: "cancelled";
+    readonly reason: string;
+} | {
+    readonly status: "failed";
+    readonly reason: string;
+} | {
+    readonly status: "lost";
+} | {
+    readonly status: "unavailable";
+};
+interface MatchTicket {
+    readonly id: string;
+    readonly status: MatchTicketStatus;
+    readonly partySize: number;
+    readonly queuedAt: number;
+    readonly expiresAt: number;
+    readonly outcome: Promise<MatchTicketOutcome>;
+    cancel(): Promise<MatchTicketOutcome>;
 }
-interface GemOpenAppResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.openAppResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
-    readonly reason?: string;
+interface CreateRoomOptions {
+    readonly name: string;
+    readonly maxPlayers?: number;
+    readonly isPublic?: boolean;
+    readonly settings?: unknown;
+    readonly region?: string;
+    readonly templateId?: string;
+    readonly templateSlug?: string;
+    readonly partyId?: string;
+    readonly roomArgs?: RoomArgs;
+    readonly signal?: AbortSignal;
 }
-interface GemRequestOpenGame {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestOpenGame";
-    readonly requestId: string;
-    readonly ref: string;
+interface JoinRoomOptions {
+    readonly partyId?: string;
+    readonly signal?: AbortSignal;
 }
-interface GemOpenGameResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.openGameResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
-    readonly reason?: string;
+interface QuickJoinOptions extends JoinRoomOptions {
+    readonly templateSlug?: string;
+    readonly templateSlugs?: readonly string[];
+    readonly templateId?: string;
+    readonly region?: string;
+    readonly name?: string;
 }
-interface GemRequestSimilarGames {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestSimilarGames";
-    readonly requestId: string;
+interface ListRoomsOptions {
+    readonly status?: "open" | "in_game";
+    readonly templateSlug?: string;
     readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
 }
-interface GemSimilarGamesResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.similarGamesResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
-    readonly reason?: string;
-    readonly games: {
-        gameId: string;
-        slug?: string;
-        iconUrl: string;
-        capsuleLandscapeUrl: string;
-        capsulePortraitUrl: string;
-        previewVideoUrl?: string;
-        previewPosterUrl?: string;
-        untrusted: {
-            name: string;
-            tagline: string;
-            shortDescription: string;
-            tags: string[];
-        };
-    }[];
+interface UpdateRoomOptions {
+    readonly name?: string;
+    readonly maxPlayers?: number;
+    readonly isPublic?: boolean;
+    readonly settings?: unknown;
+    readonly roomArgs?: RoomArgs;
+    readonly signal?: AbortSignal;
 }
-interface GemRequestStoreOffers {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestStoreOffers";
-    readonly requestId: string;
+type PartyTicketStatus = "queued" | "matched" | "expired" | "cancelled" | "failed" | "lost";
+type PartyTicketOutcome = {
+    readonly status: "matched";
+} | {
+    readonly status: "expired";
+    readonly reason: string;
+} | {
+    readonly status: "cancelled";
+    readonly reason: string;
+} | {
+    readonly status: "failed";
+    readonly reason: string;
+} | {
+    readonly status: "lost";
+};
+interface PartyTicket {
+    readonly id: string;
+    readonly status: PartyTicketStatus;
+    readonly partySize: number;
+    readonly queuedAt: number;
+    readonly expiresAt: number;
+    readonly outcome: Promise<PartyTicketOutcome>;
 }
-interface GemStoreOffersResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.storeOffersResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
+interface RelayedTicketEvent {
+    readonly event: "queued" | "matched" | "expired" | "cancelled" | "failed";
+    readonly ticketId: string;
+    readonly partySize?: number;
+    readonly queuedAt?: number;
+    readonly expiresAt?: number;
     readonly reason?: string;
-    readonly offers: {
-        skuId: string;
-        kind: "gem_pack" | "boost" | "pass" | "bundle";
-        name: string;
-        description: string;
-        imageUrl?: string;
-        priceDisplay: string;
-        grant?: {
-            currency: string;
-            amount: number;
-        };
-    }[];
+    readonly roomId?: string;
 }
-interface GemRequestStorePurchase {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestStorePurchase";
-    readonly requestId: string;
-    readonly skuId: string;
+interface RoomEventMap {
+    created: [
+        Room
+    ];
+    joined: [
+        Room
+    ];
+    left: [
+    ];
+    closed: [
+    ];
+    updated: [
+        Room
+    ];
+    seated: [
+        Room
+    ];
+    partyQueued: [
+        PartyTicket
+    ];
+    listed: [
+        RoomPage
+    ];
+    mineListed: [
+        readonly RoomSummary[]
+    ];
+    memberJoined: [
+        string
+    ];
+    memberLeft: [
+        string
+    ];
+    kicked: [
+    ];
+    readyChanged: [
+        string,
+        boolean
+    ];
+    hostChanged: [
+        string
+    ];
+    matchStartWaiting: [
+        StartMatchWaiting
+    ];
+    matchAutoStartFailed: [
+        MatchAutoStartFailed
+    ];
+    matchAllocationStarted: [
+        string
+    ];
+    matchReady: [
+        ReadyMatch
+    ];
+    matchFailed: [
+        string,
+        string
+    ];
+    matchEnded: [
+        MatchEnded
+    ];
+    matchSuspended: [
+        MatchSuspended
+    ];
+    matchReconnecting: [
+        MatchReconnecting
+    ];
+    matchReconnected: [
+        MatchReconnected
+    ];
+    versionUpdateAvailable: [
+        ClientPlatform$1 | undefined
+    ];
+    error: [
+        RoomOperationError
+    ];
 }
-interface GemStorePurchaseResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.storePurchaseResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
+type RoomEventName = keyof RoomEventMap;
+interface MatchEndHint {
+    readonly matchId?: string;
     readonly reason?: string;
 }
-interface GemStorePurchaseSettled {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.storePurchaseSettled";
-    readonly skuId: string;
+interface RelayedRoomEvent {
+    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
+    readonly roomId: string;
+    readonly matchId?: string;
+    readonly version?: number;
+    readonly reason?: string;
+    readonly platform?: ClientPlatform$1;
 }
-interface GemRequestStoreOfferSheet {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.requestStoreOfferSheet";
-    readonly requestId: string;
-    readonly skuId: string;
+interface StartMatchOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly retry?: StartMatchRetryOptions;
+    readonly signal?: AbortSignal;
 }
-interface GemStoreOfferSheetResult {
-    readonly gem: typeof PROTOCOL;
-    readonly type: "gem.storeOfferSheetResult";
-    readonly requestId: string;
-    readonly outcome: "ok" | "declined" | "unavailable";
-    readonly reason?: string;
+interface AwaitMatchOptions {
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+}
+interface StartedMatch {
+    readonly matchId: string;
+    readonly status: string;
+}
+interface RoomManager {
+    create(options: CreateRoomOptions): Promise<Room>;
+    join(roomId: string, options?: JoinRoomOptions): Promise<Room>;
+    joinByCode(code: string, options?: JoinRoomOptions): Promise<Room>;
+    quickJoin(options: QuickJoinOptions): Promise<Room>;
+    queueForMatch(options: QueueForMatchOptions): Promise<MatchTicket>;
+    list(options?: ListRoomsOptions): Promise<RoomPage>;
+    myRooms(signal?: AbortSignal): Promise<readonly RoomSummary[]>;
+    leave(options?: {
+        asGroup?: boolean;
+        signal?: AbortSignal;
+        keepalive?: boolean;
+    }): Promise<void>;
+    leaveAll(signal?: AbortSignal): Promise<readonly string[]>;
+    close(signal?: AbortSignal): Promise<void>;
+    refresh(signal?: AbortSignal): Promise<Room | null>;
+    setReady(isReady: boolean, signal?: AbortSignal): Promise<Room>;
+    kick(playerId: string, signal?: AbortSignal): Promise<Room>;
+    transferHost(playerId: string, signal?: AbortSignal): Promise<Room>;
+    update(options: UpdateRoomOptions): Promise<Room>;
+    startMatch(options?: StartMatchOptions): Promise<StartedMatch>;
+    awaitMatch(options?: AwaitMatchOptions): Promise<ReadyMatch>;
+    pollMatchStatus(options?: AwaitMatchOptions): Promise<ReadyMatch>;
+    notifyMatchConnected(matchId: string): void;
+    notifyMatchDisconnected(cause?: string): Promise<void>;
+    reconnectToMatch(options?: AwaitMatchOptions): Promise<ReadyMatch>;
+    notifyLeavingMatch(options?: {
+        keepalive?: boolean;
+    }): Promise<void>;
+    readonly gameId: string | null;
+    readonly currentRoom: Room | null;
+    readonly currentTicket: MatchTicket | null;
+    readonly partyTicket: PartyTicket | null;
+    readonly currentMatch: ReadyMatch | null;
+    readonly matchConnectionState: MatchConnectionState;
+    readonly matchSession: MatchSession;
+    readonly isInRoom: boolean;
+    readonly isHost: boolean;
+    readonly members: readonly Room["members"][number][];
+    readonly playWith: PlayWithOutcome | null;
+    on<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): () => void;
+    off<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): void;
+    once<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): () => void;
+    handleRoomEvent(event: RelayedRoomEvent): void;
+    handleSeated(roomId: string): void;
+    handleAutoStartFailed(roomId: string, code: string): void;
+    handleTicketEvent(event: RelayedTicketEvent): void;
+    reconcileSeats(): Promise<void>;
+    reconcile(hint?: MatchEndHint): Promise<void>;
+    startPolling(intervalMs?: number): void;
+    stopPolling(): void;
+    settled(): Promise<void>;
+    dispose(): void;
 }
 interface ConnectOptions {
     readonly clusterTargetId?: ClusterTargetLike;
@@ -3027,9 +3343,15 @@ interface GemServerHost extends ServerBundleHost {
     broadcast(data: string | Uint8Array, options?: BroadcastOptions): void;
     kick(playerId: string, reason?: string): void;
     endMatch?(): Promise<"ok" | "already_ended" | "refused" | "failed" | (string & {})>;
+    passes?(playerId: string): Promise<GemServerHostRead>;
+    boost?(playerId: string): Promise<GemServerHostRead>;
     log(message: string): void;
     warn(message: string): void;
 }
+interface GemServerHostRead {
+    readonly status: number;
+    readonly body: unknown;
+}
 interface HostTokenSourceOptions {
     readonly clock: Clock;
     readonly timeoutMs?: number;
@@ -4608,6 +4930,15 @@ interface ServerListChallengesOptions {
 interface ServerChallenges {
     list(options: ServerListChallengesOptions): Promise<Challenge[]>;
 }
+interface MatchBoostMultiplier {
+    readonly currencySlug: string;
+    readonly multiplier: number;
+}
+interface MatchPlayerBoost {
+    readonly active: boolean;
+    readonly multipliers: readonly MatchBoostMultiplier[];
+    readonly expiresInDays?: number;
+}
 interface GemServerOptions {
     readonly baseUrl?: string;
     readonly clock?: Clock;
@@ -4646,7 +4977,10 @@ interface GemServer {
             readonly seats?: number;
         }, signal?: AbortSignal): Promise<MatchBackfillState>;
         reportPlayers(reports: readonly MatchPlayerReport[], signal?: AbortSignal): Promise<MatchPlayerReportResult[]>;
+        playerPasses(playerId: string, signal?: AbortSignal): Promise<readonly GamePass[]>;
+        playerBoost(playerId: string, signal?: AbortSignal): Promise<MatchPlayerBoost>;
     };
+    readonly earnings: EarningsApi;
     readonly analytics: ServerAnalytics;
     readonly functions: FunctionsApi;
     readonly challenges: ServerChallenges;
@@ -4816,177 +5150,6 @@ interface AccountApi {
     onSignInAvailableChange(listener: (available: boolean) => void): () => void;
     requestSignIn(): Promise<SignInOutcome>;
 }
-interface PlayerBoostMultiplier {
-    readonly currencyId: string;
-    readonly currencySlug: string;
-    readonly multiplier: number;
-}
-interface PlayerBoost {
-    readonly active: boolean;
-    readonly multipliers: readonly PlayerBoostMultiplier[];
-    readonly expiresInDays?: number;
-}
-interface RewardCue {
-    currencySlug: string;
-    cueId?: string;
-    expected?: number;
-    origin?: {
-        x: number;
-        y: number;
-    };
-}
-type GemCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
-type RewardPresentation = "arcade" | "game";
-interface MenuStyle {
-    readonly ground: string;
-    readonly accent: string;
-}
-type FrameState = "waiting" | "connected" | "refused" | "closed";
-interface FramePlayer extends PlayerIdentity {
-    readonly displayName: PlayerText;
-    readonly displayHandle: PlayerText;
-    readonly avatarUrl?: string;
-    readonly boost: PlayerBoost;
-}
-type GemArcadeAsk = Omit<GemRequestAppLinks, "gem"> | Omit<GemRequestOpenApp, "gem"> | Omit<GemRequestOpenGame, "gem"> | Omit<GemRequestSimilarGames, "gem"> | Omit<GemRequestStoreOffers, "gem"> | Omit<GemRequestStorePurchase, "gem"> | Omit<GemRequestStoreOfferSheet, "gem">;
-type GemFriendsWindowAsk = Omit<GemRequestPlayInvite, "gem"> | Omit<GemInviteParams, "gem">;
-type GemArcadeAnswer = GemAppLinksResult | GemOpenAppResult | GemOpenGameResult | GemSimilarGamesResult | GemStoreOffersResult | GemStorePurchaseResult | GemStorePurchaseSettled | GemStoreOfferSheetResult;
-interface FrameCallbacks {
-    onToken?(msg: GemToken): void;
-    onPause?(msg: GemPause): void;
-    onMenuSelect?(msg: GemMenuSelect): void;
-    onSettingChange?(msg: GemSettingChange): void;
-    onPrefs?(msg: GemPrefs$1): void;
-    onCohorts?(msg: GemCohorts$1): void;
-    onEarnAllowanceChanged?(): void;
-    onInventoryChanged?(msg: GemInventoryChanged): void;
-    onViewport?(msg: GemViewport$1): void;
-    onWillTerminate?(msg: GemWillTerminate): void;
-    onDevtools?(action: "open" | "close" | "toggle"): void;
-    onScreenshot?(request: {
-        maxWidth: number;
-        maxHeight: number;
-    }, port: MessagePort, deny: (reason: GemScreenshotDenied["reason"], retryable: boolean) => void): void;
-    onRequestContext?(): void;
-    onTokenDenied?(msg: GemTokenDenied): void;
-    onLocalServer?(msg: GemLocalServer): void;
-    onLocalServerDenied?(msg: GemLocalServerDenied): void;
-    onPlayer?(player: FramePlayer, signInAvailable?: boolean): void;
-    onRoomEvent?(msg: GemRoomEvent): void;
-    onSeatedEvent?(msg: GemSeatedEvent): void;
-    onAutoStartFailedEvent?(msg: GemAutoStartFailedEvent): void;
-    onTicketEvent?(msg: GemTicketEvent): void;
-    onSocketState?(msg: GemSocketState): void;
-    onSignalEvent?(msg: GemSignalEvent): void;
-    onRelayDraining?(msg: GemRelayDraining): void;
-    onDedicatedEvent?(msg: GemDedicatedEvent): void;
-    onClusterTarget?(msg: GemClusterTarget): void;
-    onGraphicsRoutes?(msg: GemGraphicsRoutes): void;
-    onPartyResult?(msg: GemPartyResult): void;
-    onPurchaseResult?(msg: GemPurchaseResult): void;
-    onPurchaseSettled?(msg: GemPurchaseSettled): void;
-    onShareResult?(msg: GemShareResult): void;
-    onDeviceSettings?(msg: GemDeviceSettings): void;
-    onDeviceSettingsResult?(msg: GemDeviceSettingsResult): void;
-    onAdResult?(msg: GemAdResult): void;
-    onMomentResult?(msg: GemMomentResult): void;
-    onSignInResult?(msg: GemSignInResult): void;
-    onFriendChallengeResult?(msg: GemFriendChallengeResult): void;
-    onArcadeAnswer?(msg: GemArcadeAnswer): void;
-    onPlayInviteResult?(msg: GemPlayInviteResult): void;
-    onError?(code: GemErrorCode, message?: string): void;
-    onDropped?(code: GemErrorCode, message?: string): void;
-    onStateChange?(state: FrameState): void;
-    onRefused?(reason: string): void;
-}
-interface FrameOptions extends FrameCallbacks {
-    allowedEmbedders: readonly string[];
-    selfOrigin?: string;
-    expectedSource: unknown;
-    capabilities?: readonly string[];
-    clock?: Clock;
-}
-declare class GemFrame {
-    private readonly options;
-    private state;
-    private port;
-    private version;
-    private peerCapabilities;
-    private unbidden;
-    private engagedSent;
-    private readyPending;
-    private readySent;
-    private settleWaiters;
-    private readonly clock;
-    private readonly inbound;
-    private readonly outbound;
-    private readonly expectedSource;
-    constructor(options: FrameOptions);
-    get currentState(): FrameState;
-    get parentCapabilities(): readonly string[];
-    parentSupports(capability: string): boolean;
-    get protocolVersion(): number | null;
-    get unbiddenLaunch(): boolean;
-    handleWindowMessage(event: HandshakeEvent): boolean;
-    ready(): void;
-    settled(timeoutMs?: number): Promise<FrameState>;
-    progress(loaded: number, total: number): void;
-    requestToken(requestId: string, reason: "initial" | "expiring" | "rejected"): void;
-    requestLocalServer(requestId: string, gameRoomId: string): boolean;
-    exit(reason?: string): void;
-    openExternal(url: string): void;
-    requestFullscreen(enabled: boolean): void;
-    reportMuted(muted: boolean): boolean;
-    reportEngaged(): boolean;
-    cueReward(cue: RewardCue): boolean;
-    showPortraitBorders(name: string | null): boolean;
-    setWalletVisible(visible: boolean, options?: {
-        only?: readonly string[];
-    }): boolean;
-    setMenu(items?: ReadonlyArray<{
-        readonly id: string;
-        readonly label: string;
-    }>): boolean;
-    declareSettings(settings: GemSettingsDeclare["settings"]): boolean;
-    setGemCorner(corner: GemCorner): boolean;
-    setRewardPresentation(mode: RewardPresentation): boolean;
-    setMenuStyle(style: MenuStyle | null): boolean;
-    requestShare(params: ReadonlyArray<{
-        readonly key: string;
-        readonly value: string;
-    }>, requestId?: string): boolean;
-    requestAvatarPicker(tab?: "2d" | "3d"): boolean;
-    requestVibrate(pattern: readonly number[]): boolean;
-    reportFrameStats(stats: {
-        fps: number;
-        frameTimeP95Ms: number;
-        counts?: "pageFrames" | "gameDraws";
-    }): boolean;
-    sendGameContext(context: Record<string, unknown>): boolean;
-    signal(signal: string, matchId: string, data: Record<string, unknown>): void;
-    dedicatedOffer(matchId: string, sdp: string, intent: GemDedicatedOffer["intent"]): void;
-    requestParty(requestId: string): boolean;
-    requestPurchase(requestId: string, purchaseKind: "item" | "recipe", targetId: string, currencySlug: string, quantity?: number, catalogId?: string, origin?: "sheet" | "direct_refused"): boolean;
-    requestAvatar3dPurchase(requestId: string, itemId: string, currencySlug: string): boolean;
-    putDeviceSettings(requestId: string, settings: Readonly<Record<string, unknown>>): boolean;
-    requestAd(requestId: string, placement: string, format: "interstitial" | "rewarded"): boolean;
-    signalMoment(requestId: string, kind: string, placement?: string, wall?: boolean): boolean;
-    readyCalled(): boolean;
-    requestSignIn(requestId: string): boolean;
-    requestFriendChallenge(requestId: string, playerId: string, template: string, params?: Readonly<Record<string, string | number>>): boolean;
-    requestArcade(msg: GemArcadeAsk | GemFriendsWindowAsk): boolean;
-    close(): void;
-    private transition;
-    private refuseMalformed;
-    private dropUnknownType;
-    private refuse;
-    private fail;
-    private gated;
-    private send;
-    private receive;
-    private dispatchInbound;
-    private screenshotDenied;
-}
 interface ShareRequest {
     readonly params?: Readonly<Record<string, string>>;
 }
@@ -4999,11 +5162,6 @@ interface ShareApi {
     readonly available: boolean;
     request(request?: ShareRequest): Promise<void>;
 }
-type ArcadeOutcomeKind = "ok" | "declined" | "unavailable";
-interface ArcadeOutcome {
-    readonly outcome: ArcadeOutcomeKind;
-    readonly reason?: string;
-}
 type AppStore = "app_store" | "google_play";
 interface AppListing {
     readonly store: AppStore;
@@ -5041,32 +5199,6 @@ interface ArcadeApi {
         readonly limit?: number;
     }): Promise<SimilarGamesOutcome>;
 }
-interface ArcadeOffer {
-    readonly skuId: string;
-    readonly kind: "gem_pack" | "boost" | "pass" | "bundle";
-    readonly name: string;
-    readonly description: string;
-    readonly imageUrl?: string;
-    readonly priceDisplay: string;
-    readonly grant?: {
-        readonly currency: string;
-        readonly amount: number;
-    };
-}
-interface StoreOffersOutcome extends ArcadeOutcome {
-    readonly offers: readonly ArcadeOffer[];
-}
-interface StoreSettlement {
-    readonly skuId: string;
-}
-interface StoreApi {
-    readonly available: boolean;
-    readonly showOfferAvailable: boolean;
-    offers(): Promise<StoreOffersOutcome>;
-    purchase(skuId: string): Promise<ArcadeOutcome>;
-    showOffer(skuId: string): Promise<ArcadeOutcome>;
-    onSettled(listener: (settlement: StoreSettlement) => void): () => void;
-}
 type BrandingTheme = "light" | "dark";
 interface BrandingVariant {
     readonly url: string;
@@ -5291,6 +5423,7 @@ interface GemPlayer extends PlayerIdentity {
     readonly displayHandle: PlayerText;
     readonly avatarUrl?: string;
     readonly boost: PlayerBoost;
+    readonly isGuest: boolean;
 }
 interface GemPrefs {
     readonly reducedMotion: boolean;
@@ -5378,6 +5511,7 @@ interface Gem {
     readonly characters: CharactersApi;
     readonly transfers: TransfersApi;
     readonly gameConfig: GameConfigApi;
+    readonly earnings: EarningsApi;
     readonly purchases: PurchaseApi;
     readonly deviceSettings: DeviceSettingsApi;
     readonly graphics: GraphicsApi;
@@ -5445,4 +5579,4 @@ interface ExitAnalytics {
 }
 declare function leaveAndExit(rooms: ExitRooms, bridge: ExitBridge | null, reason?: string, analytics?: ExitAnalytics): Promise<void>;
 declare function createGem(options?: GemOptions): Gem;
-export { ARCADE_EMBEDDERS, AVATAR_RIGS, type AccountApi, type AdFormat, type AdOutcome, type AdOutcomeKind, type AdRequest, type AdsApi, AnalyticsApi, type AnalyticsFlushOptions, type AnalyticsFlushResult, type AnalyticsOptions, type AnalyticsRejection$1 as AnalyticsRejection, type AnalyticsValue, type AppLinksOutcome, type AppListing, type AppStore, type ArcadeApi, type ArcadeAvailability, type ArcadeOffer, type ArcadeOutcome, type ArcadeOutcomeKind, AuthError, type AuthFailure, type AuthState, type Avatar3dFamily, type Avatar3dOffer, type Avatar3dPrice, type Avatar3dPurchaseRequest, type AvatarRigNode, type AvatarRigs, type Avatars3dApi, type Base64String, type BootMark, type BootTimeline, type BrandingApi, type BrandingAsset, type BrandingAssetOptions, type BrandingCurrency, type BrandingImageOptions, type BrandingList, type BrandingLookup, type BrandingTheme, type BrandingVariant, type BroadcastOptions, type BytesResponse, CONDITIONAL_HEADERS, type Challenge, type ChallengeWindow, ChallengesApi, type ClientOptions, type Clock, type ConditionalRequestHeaders, type ConfiguredPurchasePayment, type ConfiguredPurchaseRequest, type ConfiguredPurchaseResult, type ControlsApi, DEVICE_SETTINGS_MAX_BYTES, DedicatedServerError, type DedicatedServerFailure, type DedicatedServerSession, type DevToolsOpener, type DeviceSettings, type DeviceSettingsApi, type DeviceSettingsPutOutcome, type DirectPurchaseRequest, type DirectPurchaseResult, type EarnAllowance, type EarnAllowanceEvent, type EarnAllowancePeriod, type EarnAllowanceReadOptions, type EntityLeaderboard, type EntityLeaderboardEntry, type EntityLeaderboardOptions, type EntityType$1 as EntityType, type ExitAnalytics, type ExitBridge, type ExitRooms, type FrameState, type Friend, type FriendChallenge, FriendChallengeError, type FriendChallengeErrorCode, type FriendChallengeOutcome, type FriendChallengeOutcomeKind, type FriendChallengeRequest, type FriendChallengesPage, FriendsApi, type FriendsPage, type FunctionFailure, type FunctionInvokeOptions, type FunctionResult, FunctionsApi, type GameApi, type GameCard, type GameConfig, type GameMenu, type GameMenuItem, type GamePass, type GameServerLink, type GameSettingsApi, type Gem, GemApiError, type GemAudioChannels, GemClient, type GemCohort, type GemCohorts, GemConfigError, type GemControlBox, type GemCorner, type GemDevTools, type GemErrorReason, GemFrame, GemFunctionError, type GemGameChoiceSetting, type GemGameSetting, type GemGameSettingBase, type GemGameSettingChange, type GemGameSettingIcon, type GemGameSettingOption, type GemGameSettingValue, type GemGameSliderSetting, type GemGameToggleSetting, type GemGraphicsQuality, type GemGraphicsRoute, type GemGraphicsRouteEntry, type GemIdentity, type GemInsets, type GemLook, type GemLookBase, type GemLookDelta, type GemLookOptions, type GemLookSpeed, type GemMatchApi, type GemMatchServer, type GemMatchServerModule, type GemOptions, type GemPlayer, type GemPreferredRoute, type GemPrefs, type GemRecommendedSettings, type GemReservedArea, GemSaveError, type GemServer, type GemServerBundle, type GemServerFactory, type GemServerHost, type GemServerHostProfile, type GemServerIdentity, type GemServerLifecycle, type GemServerOptions, type GemServerProfile, type GemTerminationNotice, GemUnframedError, type GemViewport, type GetLeaderboardOptions, type GraphicsApi, type HostTokenSource, type HostTokenSourceOptions, type JoinWelcome, type Leaderboard, type LeaderboardEntry, type LeaderboardPeriod, LeaderboardsApi, type ListChallengesOptions, type ListFriendChallengesOptions, type ListFriendsOptions, MAX_PERIODS_BACK, type MatchBackfillState, type MatchConnectOptions, type MatchConnection, type MatchHosting, type MatchHostingMode, type MatchPlayerReport, type MatchPlayerReportResult, type MatchServeOptions, type MatchTransport, type MenuStyle, type MessageMeta, type MomentKind, type MomentResult, type MomentSignal, type MomentsApi, type MultiTransportSession, PLATFORM_EVENTS, type PassesApi, type PassesEvent, type PeriodOptions, PlatformApi, PlatformCurrenciesApi, type PlatformCurrency, type PlatformCurrencyAccess, type PlatformCurrencyPurchasePayment, type PlatformCurrencyPurchaseRequest, type PlatformCurrencyPurchaseResult, type PlatformCurrencyReadOptions, PlatformEarnAllowanceApi, type PlatformEventName, type PlayInviteRequest, type PlayerBadge$1 as PlayerBadge, type PlayerBoost, type PlayerBoostMultiplier, type PlayerIdentity, type PlayerProfile, type PlayerScope, PlayerText, type PreferredRouteOptions, type ProfileCallOptions, type ProfileShowcaseEntry$1 as ProfileShowcaseEntry, ProfilesApi, type PurchaseApi, type PurchaseOptions, type PurchaseOutcome, PurchaseRefusal, type PurchaseRefusalCode, type PurchaseRequest, type PurchaseSettlement, type PutBytesOptions, type PutSaveOptions, type RankedRow, type RecipeAvailability, type RecipeLock, type RequestOptions, type RewardCue, type RewardPresentation, type RewardedOption, type RewardedStatus, type RoomArgValue, type SavePage, type SaveRecord, type SendOptions$1 as SendOptions, type ServerApi, type ServerBundleHost, type ServerTokenGrant, type SessionEndReason, type ShareApi, ShareRefusal, type ShareRequest, ShowcaseApi, type ShowcaseCallOptions, type ShowcaseFriendEntry, type ShowcaseFriends, type ShowcaseValue, type SignInOutcome, type SignInOutcomeKind, type SimilarGamesOutcome, type SnapshotCurrency, type SnapshotItem, type StoreApi, type StoreOffersOutcome, type StoreSettlement, type TokenGrant, type Transport, type TransportAdvert, type TransportKind, TransportRefusal, type TransportRequest, type TransportResponse, UNRELIABLE_CHANNEL_LABEL, type VersionedGetOptions, type VersionedResponse, type VibrationApi, type WalletVisibleOptions, type WornAvatar3d$1 as WornAvatar3d, asPlayerText, createBootTimeline, createGem, createGemServer, createHostTokenSource, createMatchServer, defineServer, experimentSelection, leaveAndExit, mapIdentity, markOnResolve, platformIconUrl, presentJoinCredential, readTemplateTransports, readTransportAdvert, reportOnResolve, systemClock, text, toBase64, webTransportAvailable };
+export { ARCADE_EMBEDDERS, AVATAR_RIGS, type AccountApi, type AdFormat, type AdOutcome, type AdOutcomeKind, type AdRequest, type AdsApi, AnalyticsApi, type AnalyticsFlushOptions, type AnalyticsFlushResult, type AnalyticsOptions, type AnalyticsRejection$1 as AnalyticsRejection, type AnalyticsValue, type AppLinksOutcome, type AppListing, type AppStore, type ArcadeApi, type ArcadeAvailability, type ArcadeOffer, type ArcadeOfferEarnMultiplier, type ArcadeOfferKind, type ArcadeOutcome, type ArcadeOutcomeKind, AuthError, type AuthFailure, type AuthState, type Avatar3dFamily, type Avatar3dOffer, type Avatar3dPrice, type Avatar3dPurchaseRequest, type AvatarRigNode, type AvatarRigs, type Avatars3dApi, type Base64String, type BonusPreview, type BootMark, type BootTimeline, type BrandingApi, type BrandingAsset, type BrandingAssetOptions, type BrandingCurrency, type BrandingImageOptions, type BrandingList, type BrandingLookup, type BrandingTheme, type BrandingVariant, type BroadcastOptions, type BytesResponse, CONDITIONAL_HEADERS, type Challenge, type ChallengeWindow, ChallengesApi, type ClientOptions, type Clock, type ConditionalRequestHeaders, type ConfigPreview, type ConfiguredPurchasePayment, type ConfiguredPurchaseRequest, type ConfiguredPurchaseResult, type ControlsApi, DEVICE_SETTINGS_MAX_BYTES, DedicatedServerError, type DedicatedServerFailure, type DedicatedServerSession, type DevToolsOpener, type DeviceSettings, type DeviceSettingsApi, type DeviceSettingsPutOutcome, type DirectPurchaseRequest, type DirectPurchaseResult, type EarnAllowance, type EarnAllowanceEvent, type EarnAllowancePeriod, type EarnAllowanceReadOptions, type EarningsApi, type EntityLeaderboard, type EntityLeaderboardEntry, type EntityLeaderboardOptions, type EntityType$1 as EntityType, type ExitAnalytics, type ExitBridge, type ExitRooms, type FrameState, type Friend, type FriendChallenge, FriendChallengeError, type FriendChallengeErrorCode, type FriendChallengeOutcome, type FriendChallengeOutcomeKind, type FriendChallengeRequest, type FriendChallengesPage, FriendsApi, type FriendsPage, type FunctionFailure, type FunctionInvokeOptions, type FunctionResult, FunctionsApi, type GameApi, type GameCard, type GameConfig, type GameMenu, type GameMenuItem, type GamePass, type GameServerLink, type GameSettingsApi, type Gem, GemApiError, type GemAudioChannels, GemClient, type GemCohort, type GemCohorts, GemConfigError, type GemControlBox, type GemCorner, type GemDevTools, type GemErrorReason, GemFrame, GemFunctionError, type GemGameChoiceSetting, type GemGameSetting, type GemGameSettingBase, type GemGameSettingChange, type GemGameSettingIcon, type GemGameSettingOption, type GemGameSettingValue, type GemGameSliderSetting, type GemGameToggleSetting, type GemGraphicsQuality, type GemGraphicsRoute, type GemGraphicsRouteEntry, type GemIdentity, type GemInsets, type GemLook, type GemLookBase, type GemLookDelta, type GemLookOptions, type GemLookSpeed, type GemMatchApi, type GemMatchServer, type GemMatchServerModule, type GemOptions, type GemPlayer, type GemPreferredRoute, type GemPrefs, type GemRecommendedSettings, type GemReservedArea, GemSaveError, type GemServer, type GemServerBundle, type GemServerFactory, type GemServerHost, type GemServerHostProfile, type GemServerHostRead, type GemServerIdentity, type GemServerLifecycle, type GemServerOptions, type GemServerProfile, type GemTerminationNotice, GemUnframedError, type GemViewport, type GetLeaderboardOptions, type GraphicsApi, type HostTokenSource, type HostTokenSourceOptions, type JoinWelcome, type Leaderboard, type LeaderboardEntry, type LeaderboardPeriod, LeaderboardsApi, type ListChallengesOptions, type ListFriendChallengesOptions, type ListFriendsOptions, MAX_PERIODS_BACK, type MatchBackfillState, type MatchBoostMultiplier, type MatchConnectOptions, type MatchConnection, type MatchHosting, type MatchHostingMode, type MatchPlayerBoost, type MatchPlayerReport, type MatchPlayerReportResult, type MatchServeOptions, type MatchTransport, type MenuStyle, type MessageMeta, type MomentKind, type MomentResult, type MomentSignal, type MomentsApi, type MultiTransportSession, PLATFORM_EVENTS, type PassUpsell, type PassesApi, type PassesEvent, type PeriodOptions, PlatformApi, PlatformCurrenciesApi, type PlatformCurrency, type PlatformCurrencyAccess, type PlatformCurrencyPurchasePayment, type PlatformCurrencyPurchaseRequest, type PlatformCurrencyPurchaseResult, type PlatformCurrencyReadOptions, PlatformEarnAllowanceApi, type PlatformEventName, type PlatformGrantPreview, type PlatformGrantSource, type PlayInviteRequest, type PlayerBadge$1 as PlayerBadge, type PlayerBoost, type PlayerBoostMultiplier, type PlayerIdentity, type PlayerProfile, type PlayerScope, PlayerText, type PreferredRouteOptions, PreviewError, type PreviewGrant, type PreviewTarget, type ProfileCallOptions, type ProfileShowcaseEntry$1 as ProfileShowcaseEntry, ProfilesApi, type PurchaseApi, type PurchaseOptions, type PurchaseOutcome, PurchaseRefusal, type PurchaseRefusalCode, type PurchaseRequest, type PurchaseSettlement, type PutBytesOptions, type PutSaveOptions, type RankedRow, type RecipeAvailability, type RecipeLock, type RequestOptions, type RewardCue, type RewardPresentation, type RewardedOption, type RewardedStatus, type RoomArgValue, type SavePage, type SaveRecord, type SendOptions$1 as SendOptions, type ServerApi, type ServerBundleHost, type ServerTokenGrant, type SessionEndReason, type ShareApi, ShareRefusal, type ShareRequest, type ShowPassOutcome, ShowcaseApi, type ShowcaseCallOptions, type ShowcaseFriendEntry, type ShowcaseFriends, type ShowcaseValue, type SignInOutcome, type SignInOutcomeKind, type SimilarGamesOutcome, type SnapshotCurrency, type SnapshotItem, type StoreApi, type StoreOffersOutcome, type StoreSettlement, type TokenGrant, type Transport, type TransportAdvert, type TransportKind, TransportRefusal, type TransportRequest, type TransportResponse, UNRELIABLE_CHANNEL_LABEL, type UnmetRequirement, type VersionedGetOptions, type VersionedResponse, type VibrationApi, type WalletVisibleOptions, type WornAvatar3d$1 as WornAvatar3d, asPlayerText, createBootTimeline, createGem, createGemServer, createHostTokenSource, createMatchServer, defineServer, experimentSelection, leaveAndExit, mapIdentity, markOnResolve, platformIconUrl, presentJoinCredential, readTemplateTransports, readTransportAdvert, reportOnResolve, systemClock, text, toBase64, webTransportAvailable };