@indiegems/gem-web-sdk 5.9.0

package/dist/game.d.ts

@@ -0,0 +1,2601 @@
+type PortMessageHandler = {
+    handle(event: {
+        data: unknown;
+        ports?: ReadonlyArray<MessagePort>;
+    }): void;
+}["handle"];
+interface PortLike {
+    postMessage(data: unknown, transfer?: unknown[]): void;
+    close(): void;
+    onmessage: PortMessageHandler | null;
+    start?(): void;
+}
+interface HandshakeEvent {
+    readonly data: unknown;
+    readonly origin: string;
+    readonly source?: unknown;
+    readonly ports?: readonly PortLike[];
+}
+interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+type AuthFailure = "chain_exhausted" | "unavailable" | "timeout" | "internal";
+type AuthState = "ready" | "pending" | "degraded" | "lost";
+declare class AuthError extends Error {
+    readonly reason: AuthFailure;
+    constructor(reason: AuthFailure, message: string);
+    static isAuthError(error: unknown): error is AuthError;
+}
+declare class TransportRefusal extends Error {
+    readonly retryable: false;
+    constructor(message: string);
+    static isRefusal(error: unknown): error is TransportRefusal;
+}
+declare const CONDITIONAL_HEADERS: readonly [
+    "if-match",
+    "if-none-match"
+];
+type ConditionalRequestHeaders = Partial<Record<(typeof CONDITIONAL_HEADERS)[number], string>>;
+interface TransportRequest {
+    readonly method: "GET" | "PUT" | "POST" | "PATCH" | "DELETE";
+    readonly path: string;
+    readonly body?: unknown;
+    readonly headers?: ConditionalRequestHeaders;
+    readonly signal?: AbortSignal;
+    readonly keepalive?: boolean;
+}
+interface TransportResponse {
+    readonly status: number;
+    readonly body: unknown;
+    readonly etag?: string;
+    readonly retryAfterSeconds?: number;
+}
+interface Transport {
+    request(request: TransportRequest): Promise<TransportResponse>;
+}
+type GemErrorReason = "invalid" | "forbidden" | "not_found" | "conflict" | "precondition_failed" | "not_modified" | "insufficient_funds" | "too_large" | "rate_limited" | "unavailable";
+declare class GemApiError extends Error {
+    readonly reason: GemErrorReason;
+    readonly status: number;
+    readonly detail: string;
+    readonly retryAfterSeconds?: number | undefined;
+    readonly code?: string | undefined;
+    constructor(reason: GemErrorReason, status: number, detail: string, retryAfterSeconds?: number | undefined, code?: string | undefined);
+    get retryable(): boolean;
+}
+interface ClientOptions {
+    readonly transport: Transport;
+    readonly clock: Clock;
+    readonly maxRetries?: number;
+}
+interface RequestOptions {
+    readonly keepalive?: boolean;
+    readonly ifMatch?: string;
+    readonly replaySafe?: boolean;
+}
+interface VersionedGetOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+type VersionedResponse<T> = {
+    readonly modified: true;
+    readonly body: T;
+    readonly etag?: string;
+} | {
+    readonly modified: false;
+    readonly etag?: string;
+};
+declare class GemClient {
+    private readonly options;
+    constructor(options: ClientOptions);
+    get<T>(path: string, signal?: AbortSignal): Promise<T>;
+    getWithEtag<T>(path: string, options?: VersionedGetOptions): Promise<VersionedResponse<T>>;
+    put<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    delete<T>(path: string, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    private send;
+    private sendRaw;
+    private backoff;
+}
+interface GameApi {
+    readonly client: GemClient;
+    gameId(): string;
+}
+type Affix = {
+    "group"?: string | null;
+    "is_active"?: boolean;
+    "properties": Record<string, unknown>;
+    "slug": string;
+    "tier"?: string | null;
+    "weight": number;
+};
+type AffixPoolRef = {
+    "by_id": string;
+} | {
+    "inline": Affix[];
+};
+type AffixSelection = {
+    "allow_duplicates"?: boolean;
+    "count": CountSpec;
+    "pity"?: null | PityRule;
+    "pool": AffixPoolRef;
+    "respect_groups"?: boolean;
+};
+type BucketColumn = "bucket_1" | "bucket_2";
+type BucketConfig = {
+    "grant_sources"?: OrderSource[];
+    "name": string;
+    "priority": number;
+    "reset_amount"?: number | null;
+    "reset_cap"?: number | null;
+    "reset_interval": BucketResetInterval;
+};
+type BucketResetInterval = "never" | "daily" | "weekly" | "monthly";
+type CountSpec = {
+    "exact": number;
+} | {
+    "range": {
+        "max": number;
+        "min": number;
+    };
+};
+type EntityType = "player" | "character";
+type EntriesPerEntity = "all" | "best";
+type EventSource = "client" | "server";
+type ExclusionCondition = {
+    "item_definition_id": string;
+    "min_quantity"?: number;
+    "type": "owns_item";
+} | {
+    "progression_definition_id": string;
+    "type": "progression_complete";
+} | {
+    "currency_id": string;
+    "min_amount": number;
+    "type": "has_currency";
+} | {
+    "min_level": number;
+    "progression_definition_id": string;
+    "type": "progression_level";
+};
+type GameConfigSnapshot = {
+    "affix_pools"?: SnapshotAffixPool[];
+    "analytics_events"?: SnapshotAnalyticsEvent[];
+    "analytics_funnels"?: SnapshotAnalyticsFunnel[];
+    "async_opponent_types"?: SnapshotAsyncOpponentType[];
+    "catalogs": SnapshotCatalog[];
+    "currencies": SnapshotCurrency[];
+    "game_room_templates": SnapshotGameRoomTemplate[];
+    "hash": string;
+    "items": SnapshotItem[];
+    "kv": Record<string, unknown>;
+    "leaderboards"?: SnapshotLeaderboard[];
+    "loot_tables": SnapshotLootTable[];
+    "progressions": SnapshotProgression[];
+    "run_types"?: SnapshotRunType[];
+    "version": number;
+};
+type ItemGeneration = {
+    "affix_selections"?: AffixSelection[];
+    "property_rolls"?: Record<string, unknown>;
+};
+type LevelDefinition = {
+    "auto_claim"?: boolean;
+    "level": number;
+    "rewards"?: RecipeOperation[];
+    "threshold": number;
+};
+type OrderBySpec = {
+    "column": RunValueColumn;
+    "direction": SortDirection;
+};
+type OrderSource = "real_money_purchase" | "real_money_refund" | "full_game_purchase" | "full_game_refund" | "platform_purchase" | "reward" | "admin" | "system" | "promo" | "game_consume" | "play" | "recipe" | "transfer" | "platform_funded_game_inventory_purchase";
+type OverflowBehavior = "fail" | "clamp" | "allow";
+type PityEffect = "guarantee_tier" | {
+    "weight_boost": {
+        "per_miss_bps": number;
+    };
+};
+type PityRule = {
+    "counter_id": string;
+    "effect": PityEffect;
+    "reset_on_hit"?: boolean;
+    "target_tier": string;
+    "threshold": number;
+};
+type PlatformDisplay = "none" | "challenge";
+type PlatformGrantMapping = {
+    "amount"?: number | null;
+    "max_per_window"?: number | null;
+    "mode": PlatformGrantMode;
+    "target": PlatformGrantTarget;
+};
+type PlatformGrantMode = "on_add" | "on_complete";
+type PlatformGrantTarget = {
+    "platform_currency_id"?: string | null;
+    "platform_currency_slug"?: string | null;
+};
+type PlatformPrice = {
+    "platform_currency_id": string;
+    "price": number;
+};
+type PrerequisiteType = "owns_item" | "progression_complete" | "min_progression_value" | "progression_level";
+type ProgressionConfig = {
+    "client_writable"?: boolean;
+    "completion_threshold"?: number | null;
+    "label"?: string | null;
+    "max_completions"?: number | null;
+    "platform_display"?: PlatformDisplay;
+    "platform_grants"?: PlatformGrantMapping[];
+    "reset_schedule"?: null | ResetSchedule;
+    "rewards_on_complete"?: RecipeOperation[];
+    "tracks"?: TrackDefinition[];
+};
+type RecipeOperation = {
+    "amount": number;
+    "currency_id": string;
+    "overflow"?: OverflowBehavior;
+    "reason"?: string | null;
+    "type": "currency_grant";
+} | {
+    "amount": number;
+    "currency_id": string;
+    "overflow"?: OverflowBehavior;
+    "reason"?: string | null;
+    "type": "currency_consume";
+} | {
+    "custom_data"?: Record<string, unknown> | null;
+    "generation"?: ItemGeneration;
+    "instance_id"?: string | null;
+    "item_definition_id": string;
+    "overflow"?: OverflowBehavior;
+    "properties"?: Record<string, unknown> | null;
+    "quantity"?: number;
+    "reason"?: string | null;
+    "type": "item_grant";
+} | {
+    "instance_id"?: string | null;
+    "item_definition_id": string;
+    "overflow"?: OverflowBehavior;
+    "quantity"?: number;
+    "reason"?: string | null;
+    "type": "item_remove";
+} | {
+    "amount": number;
+    "progression_definition_id": string;
+    "reason"?: string | null;
+    "type": "progression_add";
+} | {
+    "progression_definition_id": string;
+    "reason"?: string | null;
+    "type": "progression_set";
+    "value": number;
+} | {
+    "progression_definition_id": string;
+    "reason"?: string | null;
+    "type": "progression_reset";
+};
+type RecipePrerequisite = {
+    "prerequisite_type": PrerequisiteType;
+    "reference_id": string;
+    "reference_value": number;
+};
+type ResetSchedule = {
+    "expr": string;
+    "type": "cron";
+} | {
+    "event_id": string;
+    "type": "event_window";
+} | {
+    "type": "daily";
+} | {
+    "type": "weekly";
+} | {
+    "type": "monthly";
+};
+type RoomArgType$1 = "string" | "int" | "float" | "bool";
+type RoomArgsTemplate = {
+    "name": string;
+} & {
+    "allowed"?: Record<string, unknown>[] | null;
+    "default"?: Record<string, unknown> | null;
+    "description"?: string | null;
+    "fixed"?: Record<string, unknown> | null;
+    "list"?: boolean;
+    "max"?: number | null;
+    "max_items"?: number | null;
+    "max_length"?: number | null;
+    "min"?: number | null;
+    "min_items"?: number | null;
+    "mutable"?: boolean | null;
+    "required"?: boolean;
+    "type": RoomArgType$1;
+}[];
+type RunValueColumn = "int_value_1" | "int_value_2" | "float_value_1" | "float_value_2";
+type SnapshotAffix = {
+    "group"?: string | null;
+    "id": string;
+    "properties"?: Record<string, unknown> | null;
+    "slug": string;
+    "sort_order": number;
+    "tier"?: string | null;
+    "weight": number;
+};
+type SnapshotAffixPool = {
+    "affixes": SnapshotAffix[];
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "id": string;
+    "slug"?: string | null;
+};
+type SnapshotAnalyticsEvent = {
+    "description"?: string | null;
+    "dimensions"?: Record<string, unknown>;
+    "id": string;
+    "measures"?: Record<string, unknown>;
+    "sources": EventSource[];
+};
+type SnapshotAnalyticsFunnel = {
+    "id": string;
+    "steps": string[];
+};
+type SnapshotAsyncOpponentType = {
+    "display_name"?: string | null;
+    "id": string;
+    "max_payload_bytes"?: number | null;
+    "max_slots_per_entity": number;
+    "player_writable": boolean;
+    "slug"?: string | null;
+    "ttl_seconds": number;
+    "versions": SnapshotAsyncOpponentTypeVersion[];
+};
+type SnapshotAsyncOpponentTypeVersion = {
+    "is_active": boolean;
+    "properties": Record<string, unknown>;
+    "searchable": string[];
+    "version": number;
+};
+type SnapshotCatalog = {
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "id": string;
+    "recipes": SnapshotRecipe[];
+    "slug"?: string | null;
+};
+type SnapshotCurrency = {
+    "bucket_config"?: BucketConfig[] | null;
+    "display_name"?: string | null;
+    "history_tracking": boolean;
+    "id": string;
+    "max_balance": number;
+    "min_balance": number;
+    "slug"?: string | null;
+};
+type SnapshotGameRoomTemplate = {
+    "allow_host_transfer": boolean;
+    "allow_join_in_progress"?: boolean;
+    "allow_kick": boolean;
+    "allow_party_join": boolean;
+    "allow_ready_check": boolean;
+    "auto_close_when_empty": boolean;
+    "auto_leave_on_client_shutdown"?: boolean;
+    "auto_start_host"?: boolean;
+    "default_visibility": string;
+    "game_room_ttl_seconds": number;
+    "game_room_type": string;
+    "id": string;
+    "idle_timeout_seconds"?: number | null;
+    "match_type": string;
+    "max_match_duration_seconds"?: number | null;
+    "max_players": number;
+    "min_players": number;
+    "name": string;
+    "notify_on_host_transfer": string;
+    "notify_on_join": string;
+    "notify_on_kick": string;
+    "notify_on_leave": string;
+    "notify_on_ready": string;
+    "offline_member_timeout_seconds"?: number | null;
+    "room_args_template"?: null | RoomArgsTemplate;
+    "show_in_browser": boolean;
+    "slug"?: string | null;
+    "transports"?: string[];
+};
+type SnapshotItem = {
+    "consumable": boolean;
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "fungible": boolean;
+    "icon_url"?: string | null;
+    "id": string;
+    "item_type": string;
+    "metadata"?: unknown;
+    "platform_prices"?: PlatformPrice[];
+    "properties"?: Record<string, unknown> | null;
+    "slug"?: string | null;
+    "stack_size"?: number | null;
+    "transfer_mode": string;
+    "transfer_policy": string;
+};
+type SnapshotLeaderboard = {
+    "bucket_by": BucketColumn[];
+    "entries_per_entity": EntriesPerEntity;
+    "expose_player": boolean;
+    "expose_properties"?: boolean;
+    "expose_stats": boolean;
+    "id": string;
+    "max_size": number;
+    "order_by": OrderBySpec[];
+    "run_type": string;
+    "update_frequency_seconds": number;
+};
+type SnapshotLootTable = {
+    "allow_duplicate_rolls": boolean;
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "entries": SnapshotLootTableEntry[];
+    "event_id"?: string | null;
+    "id": string;
+    "pity"?: null | PityRule;
+    "roll_count": number;
+    "slug"?: string | null;
+};
+type SnapshotLootTableEntry = {
+    "exclusion_conditions"?: ExclusionCondition[] | null;
+    "grants"?: RecipeOperation[] | null;
+    "id": string;
+    "rarity_tier"?: string | null;
+    "replacement_entry_id"?: string | null;
+    "sort_order": number;
+    "weight": number;
+};
+type SnapshotProgression = {
+    "config": ProgressionConfig;
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "icon_url"?: string | null;
+    "id": string;
+    "progression_type": string;
+    "slug"?: string | null;
+    "sort_order": number;
+};
+type SnapshotRecipe = {
+    "availability_end"?: string | null;
+    "availability_start"?: string | null;
+    "cooldown_seconds"?: number | null;
+    "costs"?: RecipeOperation[] | null;
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "event_id"?: string | null;
+    "grants"?: RecipeOperation[] | null;
+    "id": string;
+    "loot_table_id"?: string | null;
+    "max_uses"?: number | null;
+    "platform_prices"?: PlatformPrice[];
+    "prerequisites"?: RecipePrerequisite[] | null;
+    "recipe_type": string;
+    "slug"?: string | null;
+    "sort_order": number;
+};
+type SnapshotRunType = {
+    "bucket_1_allowed_values"?: string[] | null;
+    "bucket_1_name"?: string | null;
+    "bucket_2_allowed_values"?: string[] | null;
+    "bucket_2_name"?: string | null;
+    "float_value_1_name"?: string | null;
+    "float_value_2_name"?: string | null;
+    "id": string;
+    "int_value_1_name"?: string | null;
+    "int_value_2_name"?: string | null;
+    "properties_schema"?: Record<string, unknown>;
+};
+type SortDirection = "asc" | "desc";
+type TrackDefinition = {
+    "levels": LevelDefinition[];
+    "requires_item_id"?: string | null;
+    "track_id": string;
+};
+type CacheParam = string | number | boolean | undefined;
+declare class EntityReadCache {
+    private readonly clock;
+    private readonly identity?;
+    private generation;
+    private readonly slots;
+    private readonly listeners;
+    private boundTo;
+    constructor(clock: Clock, identity?: (() => string | null) | undefined);
+    read<T>(route: string, params: readonly CacheParam[], fetch: () => Promise<T>, maxAgeMs?: number): Promise<T>;
+    invalidate(): void;
+    onInvalidate(listener: () => void): () => void;
+    private rebind;
+}
+interface Page<T> {
+    readonly data: readonly T[];
+    readonly nextCursor?: string;
+}
+interface InventoryItem {
+    readonly itemDefinitionId: string;
+    readonly instanceId: string;
+    readonly quantity: number;
+    readonly acquiredAt: number;
+    readonly properties?: unknown;
+    readonly customData?: unknown;
+}
+interface Progression {
+    readonly progressionDefinitionId: string;
+    readonly currentValue: number;
+    readonly completionCount: number;
+    readonly isCompleted: boolean;
+}
+interface CurrencyBucket {
+    readonly bucket: string;
+    readonly balance: number;
+}
+interface CurrencyRow {
+    readonly currencyId: string;
+    readonly total: number;
+    readonly buckets?: readonly CurrencyBucket[];
+}
+interface InventorySnapshot {
+    readonly currencies: Page<CurrencyRow>;
+    readonly items: Page<InventoryItem>;
+    readonly progressions: Page<Progression>;
+    readonly etag?: string;
+}
+interface SnapshotPageOptions {
+    readonly currencyCursor?: string;
+    readonly itemCursor?: string;
+    readonly progressionCursor?: string;
+    readonly currencyLimit?: number;
+    readonly itemLimit?: number;
+    readonly progressionLimit?: number;
+    readonly includeBuckets?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface SnapshotOptions {
+    readonly buckets?: boolean;
+}
+declare class InventoryApi {
+    private readonly api;
+    private readonly entity;
+    private readonly cache;
+    constructor(api: GameApi, entity: EntityRef, cache: EntityReadCache);
+    snapshot(options?: SnapshotOptions): Promise<InventorySnapshot>;
+    instances(itemDefinitionId: string, signal?: AbortSignal): Promise<readonly InventoryItem[]>;
+    page(options: SnapshotPageOptions): Promise<InventorySnapshot>;
+    refresh(): void;
+    onChanged(listener: () => void): () => void;
+    invalidate(): void;
+    private fetch;
+}
+interface CurrencyBalance {
+    readonly currencyId: string;
+    readonly total: number | null;
+    readonly buckets?: readonly CurrencyBucket[];
+}
+interface CurrencyReadOptions {
+    readonly buckets?: boolean;
+}
+declare class CurrenciesApi {
+    private readonly inventory;
+    private readonly resolveCurrencyId?;
+    constructor(inventory: InventoryApi, resolveCurrencyId?: ((slugOrId: string) => Promise<string | undefined>) | undefined);
+    list(options?: CurrencyReadOptions): Promise<readonly CurrencyBalance[]>;
+    get(currencyId: string, options?: CurrencyReadOptions): Promise<CurrencyBalance>;
+}
+type GameOrderSource = "play" | "game_consume";
+interface RecipeAvailability {
+    readonly canExecute: boolean;
+    readonly reasons: readonly string[];
+    readonly usesRemaining?: number;
+    readonly cooldownExpiresAt?: string;
+}
+interface RecipeUsage {
+    readonly recipeId: string;
+    readonly useCount: number;
+    readonly isOnCooldown: boolean;
+    readonly lastUsedAt?: string;
+    readonly cooldownExpiresAt?: string;
+}
+interface RecipeUsageList {
+    readonly usages: readonly RecipeUsage[];
+    readonly truncated: boolean;
+}
+type RecipeChange = {
+    readonly kind: "currency";
+    readonly currencyId: string;
+    readonly bucket: string;
+    readonly delta: number;
+    readonly balanceAfter: number;
+} | {
+    readonly kind: "item";
+    readonly itemDefinitionId: string;
+    readonly instanceId: string;
+    readonly delta: number;
+    readonly quantityAfter: number;
+} | {
+    readonly kind: "progression";
+    readonly progressionDefinitionId: string;
+    readonly delta: number;
+    readonly valueAfter: number;
+    readonly completed: boolean;
+} | {
+    readonly kind: "other";
+    readonly type: string;
+};
+interface LootRoll {
+    readonly entryId: string;
+    readonly rarityTier?: string;
+    readonly rollNumber: number;
+    readonly wasReplacement: boolean;
+    readonly grants: readonly RecipeChange[];
+}
+interface RecipeResult {
+    readonly orderId: string;
+    readonly status: string;
+    readonly etag?: string;
+    readonly granted: readonly RecipeChange[];
+    readonly consumed: readonly RecipeChange[];
+    readonly autoClaimedRewards: readonly RecipeChange[];
+    readonly lootResults?: readonly LootRoll[];
+}
+interface ConfiguredPurchasePayment {
+    readonly kind: "configured";
+}
+interface PlatformCurrencyPurchasePayment {
+    readonly kind: "platform_currency";
+    readonly currencySlug: string;
+}
+interface ConfiguredPurchaseRequest {
+    readonly kind: "recipe";
+    readonly catalogId: string;
+    readonly targetId: string;
+    readonly quantity?: 1;
+    readonly payment: ConfiguredPurchasePayment;
+}
+type PlatformCurrencyPurchaseRequest = {
+    readonly kind: "recipe";
+    readonly catalogId: string;
+    readonly targetId: string;
+    readonly quantity?: 1;
+    readonly payment: PlatformCurrencyPurchasePayment;
+} | {
+    readonly kind: "item";
+    readonly targetId: string;
+    readonly quantity?: number;
+    readonly payment: PlatformCurrencyPurchasePayment;
+};
+type DirectPurchaseRequest = ConfiguredPurchaseRequest | PlatformCurrencyPurchaseRequest;
+interface PurchaseOptions {
+    readonly ifMatch?: string;
+    readonly signal?: AbortSignal;
+}
+interface ConfiguredPurchaseResult extends RecipeResult {
+    readonly payment: "configured";
+}
+interface PlatformCurrencyPurchaseResult {
+    readonly payment: "platform_currency";
+    readonly orderId: string;
+    readonly status: string;
+    readonly purchaseId: string;
+    readonly sourceOrderId: string;
+    readonly price: {
+        readonly currencyId: string;
+        readonly amount: number;
+    };
+}
+type DirectPurchaseResult = ConfiguredPurchaseResult | PlatformCurrencyPurchaseResult;
+type InventoryOperation = {
+    readonly type: "currency_grant";
+    readonly currencyId: string;
+    readonly amount: number;
+} | {
+    readonly type: "currency_consume";
+    readonly currencyId: string;
+    readonly amount: number;
+} | {
+    readonly type: "item_grant";
+    readonly itemDefinitionId: string;
+    readonly quantity: number;
+} | {
+    readonly type: "item_remove";
+    readonly itemDefinitionId: string;
+    readonly quantity: number;
+};
+interface OrderOptions {
+    readonly source?: GameOrderSource;
+    readonly ifMatch?: string;
+    readonly signal?: AbortSignal;
+}
+interface OrderResult {
+    readonly orderId: string;
+    readonly status: string;
+    readonly etag?: string;
+}
+declare class MutationsApi {
+    private readonly api;
+    private readonly entity;
+    private readonly cache;
+    constructor(api: GameApi, entity: EntityRef, cache: EntityReadCache);
+    create(operations: readonly InventoryOperation[], options?: OrderOptions): Promise<OrderResult>;
+    createMany(orders: ReadonlyArray<readonly InventoryOperation[]>, options?: OrderOptions): Promise<unknown>;
+    recipeAvailability(catalogId: string, recipeId: string, signal?: AbortSignal): Promise<RecipeAvailability>;
+    recipeUsageAll(): Promise<RecipeUsageList>;
+    recipeUsage(recipeId: string): Promise<RecipeUsage | null>;
+    purchase(request: ConfiguredPurchaseRequest, options?: PurchaseOptions): Promise<ConfiguredPurchaseResult>;
+    purchase(request: PlatformCurrencyPurchaseRequest, options?: PurchaseOptions): Promise<PlatformCurrencyPurchaseResult>;
+    executeRecipe(catalogId: string, recipeId: string, options?: OrderOptions): Promise<RecipeResult>;
+    addProgression(progressionId: string, amount: number, signal?: AbortSignal): Promise<OrderResult>;
+    maxProgression(progressionId: string, value: number, signal?: AbortSignal): Promise<OrderResult>;
+    claimProgression(progressionId: string, signal?: AbortSignal): Promise<OrderResult>;
+    resetProgression(progressionId: string, signal?: AbortSignal): Promise<OrderResult>;
+    private write;
+}
+interface Order {
+    readonly orderId: string;
+    readonly status: string;
+    readonly source: string;
+    readonly createdAt: number;
+}
+interface OrderPageOptions {
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+declare class OrdersApi {
+    private readonly api;
+    private readonly entity;
+    constructor(api: GameApi, entity: EntityRef);
+    list(options?: OrderPageOptions): Promise<Page<Order>>;
+    get(orderId: string, signal?: AbortSignal): Promise<Order>;
+}
+declare class ProgressionsApi {
+    private readonly api;
+    private readonly entity;
+    private readonly inventory;
+    constructor(api: GameApi, entity: EntityRef, inventory: InventoryApi);
+    list(): Promise<readonly Progression[]>;
+    get(progressionDefinitionId: string, signal?: AbortSignal): Promise<Progression | null>;
+}
+interface SaveRecord {
+    readonly key: string;
+    readonly sizeBytes: number;
+    readonly etag: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+interface SavePage {
+    readonly saves: readonly SaveRecord[];
+    readonly nextCursor?: string;
+}
+declare class GemSaveError extends Error {
+    readonly reason: "upload_failed" | "download_failed" | "save_timeout" | "save_malformed";
+    constructor(reason: "upload_failed" | "download_failed" | "save_timeout" | "save_malformed", message: string);
+}
+interface SavesOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    readonly timeoutMs?: number;
+}
+interface PutSaveOptions {
+    readonly metadata?: Record<string, unknown>;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+interface PutBytesOptions extends PutSaveOptions {
+    readonly contentType?: string;
+}
+interface GetSaveOptions {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+interface DescribeSaveOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+interface ListSavesOptions {
+    readonly signal?: AbortSignal;
+    readonly limit?: number;
+    readonly cursor?: string;
+}
+declare class SavesApi {
+    private readonly api;
+    private readonly entity;
+    private readonly options;
+    constructor(api: GameApi, entity: EntityRef, options?: SavesOptions);
+    put(key: string, value: unknown, options?: PutSaveOptions): Promise<SaveRecord>;
+    putBytes(key: string, bytes: Uint8Array, options?: PutBytesOptions): Promise<SaveRecord>;
+    get<T = unknown>(key: string, options?: GetSaveOptions): Promise<T | null>;
+    getBytes(key: string, options?: GetSaveOptions): Promise<Uint8Array | null>;
+    describe(key: string, options?: DescribeSaveOptions): Promise<SaveRecord | null>;
+    list(options?: ListSavesOptions): Promise<SavePage>;
+    delete(key: string, signal?: AbortSignal): Promise<void>;
+    private budget;
+    private timeout;
+    private rethrow;
+}
+interface Setting {
+    readonly key: string;
+    readonly value: string;
+    readonly etag?: string;
+    readonly updatedAt: number;
+}
+interface GetSettingOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+interface PutSettingOptions {
+    readonly signal?: AbortSignal;
+    readonly ifMatch?: string;
+}
+declare class SettingsApi {
+    private readonly api;
+    private readonly entity;
+    constructor(api: GameApi, entity: EntityRef);
+    list(signal?: AbortSignal): Promise<readonly Setting[]>;
+    get(key: string, options?: GetSettingOptions): Promise<Setting | null>;
+    put(key: string, value: string, options?: PutSettingOptions): Promise<Setting>;
+    delete(key: string, signal?: AbortSignal): Promise<void>;
+}
+interface EntityRef {
+    readonly type: "players" | "characters";
+    readonly id: string;
+}
+interface EntityScope {
+    readonly settings: SettingsApi;
+    readonly inventory: InventoryApi;
+    readonly currencies: CurrenciesApi;
+    readonly mutations: MutationsApi;
+    readonly saves: SavesApi;
+    readonly orders: OrdersApi;
+    readonly progressions: ProgressionsApi;
+}
+interface Character extends EntityScope {
+    readonly id: string;
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: string;
+    readonly name: string;
+    readonly slotIndex: number;
+    readonly isActive: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface SlotInfo {
+    readonly totalSlots: number;
+    readonly availableSlots: number;
+    readonly activeCharacterCount: number;
+    readonly defaultMaxSlots: number;
+    readonly purchasedExtraSlots: number;
+    readonly canPurchaseMore: boolean;
+}
+interface CreateCharacterOptions {
+    readonly name: string;
+    readonly signal?: AbortSignal;
+}
+declare class CharactersApi {
+    private readonly api;
+    private readonly saves?;
+    private readonly identity?;
+    private readonly resolveCurrencyId?;
+    private readonly scopes;
+    constructor(api: GameApi, saves?: SavesOptions | undefined, identity?: (() => string | null) | undefined, resolveCurrencyId?: ((slugOrId: string) => Promise<string | undefined>) | undefined);
+    private readonly scope;
+    list(signal?: AbortSignal): Promise<readonly Character[]>;
+    get(id: string, signal?: AbortSignal): Promise<Character>;
+    create(options: CreateCharacterOptions): Promise<Character>;
+    update(id: string, name: string, signal?: AbortSignal): Promise<Character>;
+    delete(id: string, signal?: AbortSignal): Promise<void>;
+    slots(signal?: AbortSignal): Promise<SlotInfo>;
+}
+declare class PlayerText {
+    #private;
+    constructor(value: string);
+    toString(): string;
+    toJSON(): string;
+    get [Symbol.toStringTag](): string;
+    static unwrap(t: PlayerText): string;
+}
+declare function asPlayerText(value: string): PlayerText;
+declare const text: {
+    toPlain(t: PlayerText): string;
+    compare(a: PlayerText | string, b: PlayerText | string, locale?: string): number;
+    equals(a: PlayerText | string, b: PlayerText | string): boolean;
+};
+type TransferDirection = "incoming" | "outgoing";
+interface Transfer {
+    readonly id: string;
+    readonly status: string;
+    readonly sourceEntityId: string;
+    readonly targetEntityId: string;
+    readonly message?: PlayerText;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly resolvedAt?: string;
+}
+interface InitiateTransferOptions {
+    readonly to: EntityRef;
+    readonly items?: ReadonlyArray<{
+        itemDefinitionId: string;
+        quantity: number;
+    }>;
+    readonly currencies?: ReadonlyArray<{
+        currencyId: string;
+        amount: number;
+    }>;
+    readonly message?: string;
+    readonly signal?: AbortSignal;
+}
+interface ListTransfersOptions {
+    readonly direction?: TransferDirection;
+    readonly status?: string;
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+}
+declare class TransfersApi {
+    private readonly api;
+    private readonly self;
+    private readonly inventory;
+    constructor(api: GameApi, self: EntityRef, inventory: InventoryApi);
+    initiate(options: InitiateTransferOptions): Promise<Transfer>;
+    list(options?: ListTransfersOptions): Promise<{
+        readonly transfers: readonly Transfer[];
+        readonly nextCursor?: string;
+    }>;
+    get(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    accept(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    reject(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    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"];
+    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);
+}
+interface GameConfigOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    readonly timeoutMs?: number;
+}
+interface DropRateEntry {
+    readonly entryId: string;
+    readonly weight: number;
+    readonly dropRate: number;
+    readonly rarityTier?: string;
+}
+interface DropRates {
+    readonly lootTableId: string;
+    readonly name: string;
+    readonly rollCount: number;
+    readonly allowDuplicateRolls: boolean;
+    readonly totalWeight: number;
+    readonly entries: readonly DropRateEntry[];
+}
+declare class GameConfigApi {
+    private readonly api;
+    private readonly channel;
+    private readonly options;
+    private loaded;
+    private inFlight;
+    private generation;
+    private readonly dropRatesByConfig;
+    constructor(api: GameApi, channel: () => string, options?: GameConfigOptions);
+    load(): Promise<GameConfig | null>;
+    refresh(): void;
+    dropRates(lootTableId: string, signal?: AbortSignal): Promise<DropRates>;
+    private fetchConfig;
+}
+declare const MAX_PERIODS_BACK = 400;
+type ChallengeWindow = "daily" | "weekly" | "monthly" | (string & {});
+interface Challenge {
+    readonly id: string;
+    readonly slug?: string;
+    readonly window: ChallengeWindow;
+    readonly periodStartAt: number;
+    readonly periodEndsAt: number;
+    readonly seed: string;
+}
+interface ListChallengesOptions {
+    readonly periodsBack?: number;
+    readonly signal?: AbortSignal;
+}
+declare class ChallengesApi {
+    #private;
+    constructor(api: GameApi);
+    list(options?: ListChallengesOptions): Promise<Challenge[]>;
+}
+interface LeaderboardEntry extends RankedRow {
+    readonly rank: number;
+    readonly occurredAt: number;
+    readonly entityId?: string;
+    readonly entityType?: EntityType;
+    readonly displayName?: string;
+    readonly discriminator?: string;
+    readonly displayTag?: string;
+    readonly stats?: Readonly<Record<string, number>>;
+    readonly properties?: Readonly<Record<string, unknown>>;
+    readonly isViewer?: boolean;
+}
+interface Leaderboard {
+    readonly leaderboardType: string;
+    readonly runType: string;
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly entries: readonly LeaderboardEntry[];
+    readonly generatedAt: number;
+    readonly updateFrequencySeconds?: number;
+}
+interface RankedRow {
+    readonly rank: number;
+    readonly occurredAt: number;
+    readonly stats?: Readonly<Record<string, number>>;
+    readonly properties?: Readonly<Record<string, unknown>>;
+}
+interface EntityLeaderboardEntry extends RankedRow {
+    readonly rank: number;
+    readonly stats?: Readonly<Record<string, number>>;
+}
+interface EntityLeaderboard {
+    readonly leaderboardType: string;
+    readonly runType: string;
+    readonly entityType: EntityType;
+    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;
+}
+interface EntityLeaderboardOptions {
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+}
+interface GetLeaderboardOptions {
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly signal?: AbortSignal;
+}
+declare class LeaderboardsApi {
+    #private;
+    constructor(api: GameApi);
+    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 ShowcaseValue {
+    readonly playerId: string;
+    readonly key: string;
+    readonly value: unknown;
+    readonly updatedAt: number;
+}
+interface ShowcaseFriendEntry {
+    readonly playerId: string;
+    readonly displayName?: string;
+    readonly discriminator?: string;
+    readonly displayTag?: string;
+    readonly value: unknown;
+    readonly isViewer: boolean;
+    readonly updatedAt: number;
+}
+interface ShowcaseFriends {
+    readonly key: string;
+    readonly entries: readonly ShowcaseFriendEntry[];
+    readonly generatedAt: number;
+}
+interface ShowcaseCallOptions {
+    readonly signal?: AbortSignal;
+}
+declare class ShowcaseApi {
+    private readonly api;
+    private readonly selfPlayerId;
+    constructor(api: GameApi, 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 Friend {
+    readonly playerId: string;
+    readonly displayName?: string;
+    readonly discriminator?: string;
+    readonly displayTag?: string;
+    readonly avatarIconId?: string;
+    readonly avatarIconUrl?: string;
+}
+interface FriendsPage {
+    readonly friends: readonly Friend[];
+    readonly nextCursor?: string;
+}
+interface ListFriendsOptions {
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+declare class FriendsApi {
+    #private;
+    constructor(api: GameApi);
+    list(options?: ListFriendsOptions): Promise<FriendsPage>;
+}
+type PlatformCurrencyAccess = "read" | "spend";
+interface PlatformCurrency {
+    readonly slug: string;
+    readonly currencyId: string;
+    readonly balance: number;
+    readonly access: PlatformCurrencyAccess;
+}
+interface PlatformCurrencyReadOptions {
+    readonly signal?: AbortSignal;
+}
+declare class PlatformCurrenciesApi {
+    #private;
+    constructor(api: GameApi);
+    get(options?: PlatformCurrencyReadOptions): Promise<readonly PlatformCurrency[]>;
+}
+declare class PlatformApi {
+    readonly currencies: PlatformCurrenciesApi;
+    constructor(api: GameApi);
+}
+interface ProfileShowcaseEntry {
+    readonly key: string;
+    readonly visibility: string;
+    readonly value: unknown;
+    readonly updatedAt: number;
+}
+interface PlayerProfile {
+    readonly playerId: string;
+    readonly displayName?: string;
+    readonly discriminator?: string;
+    readonly displayTag?: string;
+    readonly avatarIconId?: string;
+    readonly avatarIconUrl?: string;
+    readonly showcase: readonly ProfileShowcaseEntry[];
+    readonly generatedAt: number;
+}
+interface ProfileCallOptions {
+    readonly signal?: AbortSignal;
+}
+declare class ProfilesApi {
+    #private;
+    constructor(api: GameApi);
+    of(playerId: string, options?: ProfileCallOptions): Promise<PlayerProfile | null>;
+}
+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";
+declare const PLATFORM_EVENTS: readonly PlatformEventName[];
+type AnalyticsValue = string | number;
+interface AnalyticsRejection {
+    readonly index: number;
+    readonly code: string;
+}
+interface AnalyticsFlushResult {
+    readonly accepted: number;
+    readonly rejected: readonly AnalyticsRejection[];
+    readonly dropped: number;
+    readonly duplicate: boolean;
+}
+interface AnalyticsFlushOptions {
+    readonly keepalive?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface AnalyticsOptions {
+    readonly enabled?: boolean;
+    readonly flushIntervalMs?: number;
+    readonly maxQueue?: number;
+}
+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 options?: AnalyticsOptions;
+    readonly log?: ((message: string) => void) | null;
+}
+declare class AnalyticsApi {
+    #private;
+    constructor(options: AnalyticsApiOptions);
+    track(name: string, props?: Readonly<Record<string, AnalyticsValue>>): void;
+    setContext(props: Readonly<Record<string, AnalyticsValue>>): void;
+    get environment(): Readonly<Record<string, string>>;
+    flush(options?: AnalyticsFlushOptions): Promise<AnalyticsFlushResult>;
+    trackPlatform(name: PlatformEventName, props?: Readonly<Record<string, AnalyticsValue>>): void;
+    startSession(): void;
+    endSession(reason: SessionEndReason): void;
+    setPaused(paused: boolean): void;
+    setHidden(hidden: boolean): void;
+    dispose(): void;
+    get pending(): number;
+}
+interface BootMark {
+    readonly name: string;
+    readonly at: number;
+}
+interface BootTimeline {
+    mark(name: string, at?: number): boolean;
+    timeline(): string;
+    readonly marks: readonly BootMark[];
+}
+interface BootTimelineOptions {
+    readonly now?: () => number;
+}
+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 DevToolsOpener = "game" | "platform";
+interface GemDevTools {
+    open(): Promise<boolean>;
+    close(): void;
+    readonly isOpen: boolean;
+}
+type ClusterTargetLike = string | null | undefined;
+declare const CLIENT_PLATFORMS: readonly [
+    "universal",
+    "mobile",
+    "web"
+];
+type ClientPlatform = (typeof CLIENT_PLATFORMS)[number];
+interface ClientVersion {
+    readonly platform?: ClientPlatform;
+    readonly gameVersion: string;
+    readonly engineVersion?: 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 StartMatchWaiting {
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly budgetMs: number;
+    readonly nextAttemptInMs: number;
+    readonly status: number;
+    readonly message: string;
+}
+interface StartMatchRetryOptions {
+    readonly budgetMs?: number;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly onWaiting?: (waiting: StartMatchWaiting) => void;
+}
+interface ClusterTarget {
+    readonly id: string;
+    readonly pressure: string;
+}
+type RoomArgScalar = string | number | boolean;
+type RoomArgValue$1 = RoomArgScalar | readonly RoomArgScalar[];
+type RoomArgs = Readonly<Record<string, RoomArgValue$1>>;
+type RoomArgType = "string" | "int" | "float" | "bool" | (string & {});
+interface RoomArgEntry {
+    readonly name: string;
+    readonly type: RoomArgType;
+    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;
+}
+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;
+    });
+}
+type SignalingIntent = "initial" | "ice_restart" | "full_reconnect";
+interface OfferRequest {
+    readonly matchId: string;
+    readonly sdp: string;
+    readonly intent: SignalingIntent;
+}
+interface SignalingAnswer {
+    readonly sdp: string;
+}
+interface SignalingChannel {
+    exchange(request: OfferRequest, signal?: AbortSignal): Promise<SignalingAnswer>;
+    close(): void;
+}
+type SdpType$1 = "offer" | "answer" | "pranswer" | "rollback";
+interface SessionDescriptionLike$1 {
+    readonly type: SdpType$1;
+    readonly sdp?: 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 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;
+    };
+}
+declare function readTemplateTransports(value: unknown): readonly TransportKind[] | null;
+declare function readTransportAdvert(settings: unknown, forMatch?: string): TransportAdvert | null;
+declare function webTransportAvailable(): boolean;
+type RoomStatus = "open" | "in_game" | "closed" | (string & {});
+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;
+}
+interface MatchEnded {
+    readonly matchId: string;
+    readonly reason: string;
+    readonly roomReopened: boolean;
+}
+interface MatchSuspended {
+    readonly matchId: string;
+    readonly cause: string;
+}
+interface MatchReconnecting {
+    readonly matchId: string;
+    readonly attempt: number;
+    readonly attempts: number;
+    readonly remainingMs: number;
+}
+interface MatchReconnected {
+    readonly matchId: string;
+    readonly attempt: number;
+}
+interface AutoReconnectOptions {
+    readonly budgetMs?: number;
+    readonly attempts?: number;
+    readonly maxDelayMs?: number;
+}
+interface RoomMember {
+    readonly playerId: string;
+    readonly isReady: boolean;
+    readonly role: string;
+    readonly joinedAt: number;
+    readonly groupId?: string;
+    readonly platform?: string;
+    readonly displayName?: PlayerText;
+    readonly displayTag?: PlayerText;
+    readonly discriminator?: 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 matchId?: string;
+    readonly version: number;
+    readonly templateId?: string;
+    readonly roomType: string;
+    readonly transports?: readonly TransportKind[];
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly startedAt?: number;
+}
+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 RoomPage {
+    readonly rooms: readonly RoomSummary[];
+    readonly nextCursor?: string;
+}
+interface RoomOperationError {
+    readonly operation: string;
+    readonly code: number;
+    readonly reason: string;
+    readonly message: string;
+    readonly retryable: boolean;
+}
+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 JoinRoomOptions {
+    readonly partyId?: string;
+    readonly signal?: AbortSignal;
+}
+interface QuickJoinOptions extends JoinRoomOptions {
+    readonly templateSlug?: string;
+    readonly templateId?: string;
+    readonly region?: string;
+    readonly name?: string;
+}
+interface ListRoomsOptions {
+    readonly status?: "open" | "in_game";
+    readonly templateSlug?: string;
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+interface UpdateRoomOptions {
+    readonly name?: string;
+    readonly maxPlayers?: number;
+    readonly isPublic?: boolean;
+    readonly settings?: unknown;
+    readonly roomArgs?: RoomArgs;
+    readonly signal?: AbortSignal;
+}
+interface RoomEventMap {
+    created: [
+        Room
+    ];
+    joined: [
+        Room
+    ];
+    left: [
+    ];
+    closed: [
+    ];
+    updated: [
+        Room
+    ];
+    seated: [
+        Room
+    ];
+    listed: [
+        RoomPage
+    ];
+    mineListed: [
+        readonly RoomSummary[]
+    ];
+    memberJoined: [
+        string
+    ];
+    memberLeft: [
+        string
+    ];
+    kicked: [
+    ];
+    readyChanged: [
+        string,
+        boolean
+    ];
+    hostChanged: [
+        string
+    ];
+    matchStartWaiting: [
+        StartMatchWaiting
+    ];
+    matchAllocationStarted: [
+        string
+    ];
+    matchReady: [
+        ReadyMatch
+    ];
+    matchFailed: [
+        string,
+        string
+    ];
+    matchEnded: [
+        MatchEnded
+    ];
+    matchSuspended: [
+        MatchSuspended
+    ];
+    matchReconnecting: [
+        MatchReconnecting
+    ];
+    matchReconnected: [
+        MatchReconnected
+    ];
+    versionUpdateAvailable: [
+        ClientPlatform | undefined
+    ];
+    error: [
+        RoomOperationError
+    ];
+}
+type RoomEventName = keyof RoomEventMap;
+interface MatchEndHint {
+    readonly matchId?: string;
+    readonly reason?: 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;
+}
+interface StartMatchOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly retry?: StartMatchRetryOptions;
+    readonly signal?: AbortSignal;
+}
+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>;
+    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 currentMatch: ReadyMatch | null;
+    readonly matchConnectionState: MatchConnectionState;
+    readonly matchSession: MatchSession;
+    readonly isInRoom: boolean;
+    readonly isHost: boolean;
+    readonly members: readonly Room["members"][number][];
+    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;
+    reconcileSeats(): Promise<void>;
+    reconcile(hint?: MatchEndHint): Promise<void>;
+    startPolling(intervalMs?: number): void;
+    stopPolling(): void;
+    settled(): Promise<void>;
+    dispose(): void;
+}
+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 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 GemPause {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.pause";
+    readonly paused: boolean;
+}
+interface GemPrefs$1 {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.prefs";
+    readonly reducedMotion: boolean;
+    readonly muted: boolean;
+    readonly showFrameStats?: boolean;
+    readonly locale: string;
+}
+interface GemCohorts$1 {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.cohorts";
+    readonly cohorts: {
+        experimentId: string;
+        variantKey: string;
+    }[];
+}
+interface GemViewport$1 {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.viewport";
+    readonly insets: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+interface GemDeviceSettings {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings";
+    readonly settings?: unknown;
+}
+interface GemWillTerminate {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.willTerminate";
+    readonly reason: "grant_expiring" | "session_ended" | "navigating" | "kill_switch";
+    readonly graceMs: number;
+}
+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 GemSocketState {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.socketState";
+    readonly connected: boolean;
+    readonly reason?: "connecting" | "dropped" | "watchdog" | "terminal";
+}
+interface GemSeatedEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.seatedEvent";
+    readonly roomId: string;
+}
+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 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 GemPartyResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.partyResult";
+    readonly requestId: string;
+    readonly partyId?: string;
+}
+interface GemClusterTarget {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.clusterTarget";
+    readonly clusterTargetId: 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";
+    readonly retryable: boolean;
+}
+interface GemDedicatedOffer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.dedicatedOffer";
+    readonly matchId: string;
+    readonly sdp: string;
+    readonly intent: "initial" | "ice_restart" | "full_reconnect";
+}
+interface GemLocalServer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.localServer";
+    readonly requestId: string;
+    readonly serverId?: string;
+}
+interface GemLocalServerDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.localServer.denied";
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly reason: "refused" | "unavailable";
+}
+interface GemPurchaseResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.purchaseResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly purchaseId?: string;
+}
+interface GemDeviceSettingsResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings.result";
+    readonly requestId: string;
+    readonly outcome: "stored" | "too_large" | "unavailable";
+}
+interface GemAdResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.adResult";
+    readonly requestId: string;
+    readonly outcome: "shown" | "no_ad" | "unavailable";
+}
+interface GemSignInResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.signInResult";
+    readonly requestId: string;
+    readonly outcome: "signed_in" | "declined" | "unavailable";
+}
+interface ConnectOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly retry?: StartMatchRetryOptions;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+    readonly signaling?: SignalingChannel;
+    readonly peerConnection?: PeerConnectionLike$1;
+    readonly intent?: SignalingIntent;
+    readonly channelLabel?: string;
+    readonly gatherTimeoutMs?: number;
+    readonly exchangeTimeoutMs?: number;
+    readonly openTimeoutMs?: number;
+    readonly reportDisconnect?: boolean;
+    readonly reportConnected?: boolean;
+    readonly presentCredential?: boolean;
+    readonly onMessage?: (data: unknown) => void;
+    readonly onMatchEnded?: (reason?: string) => void;
+    readonly welcomeTimeoutMs?: number;
+    readonly transports?: readonly TransportKind[];
+    readonly transportAttemptTimeoutMs?: number;
+    readonly redial?: boolean;
+    readonly deadlineAt?: number;
+}
+interface DedicatedServerSession {
+    readonly matchId: string;
+    readonly channel: RTCDataChannel;
+    readonly peerConnection: PeerConnectionLike$1;
+    readonly joinCredential: string;
+    readonly credentialExpiresAt: number;
+    readonly welcome: JoinWelcome | null;
+    close(): void;
+}
+interface MultiTransportSession {
+    readonly matchId: string;
+    readonly transport: TransportKind;
+    readonly link: GameServerLink;
+    readonly joinCredential: string;
+    readonly credentialExpiresAt: number;
+    readonly welcome: JoinWelcome | null;
+    readonly channel?: RTCDataChannel;
+    readonly peerConnection?: PeerConnectionLike$1;
+    close(): void;
+}
+interface DedicatedServerConnect {
+    (options?: ConnectOptions & {
+        transports?: undefined;
+    }): Promise<DedicatedServerSession>;
+    (options: ConnectOptions & {
+        transports: readonly TransportKind[];
+    }): Promise<MultiTransportSession>;
+    (options?: ConnectOptions): Promise<DedicatedServerSession | MultiTransportSession>;
+}
+interface DedicatedServerApi {
+    readonly connect: DedicatedServerConnect;
+    listClusterTargets(options?: {
+        signal?: AbortSignal;
+    }): Promise<readonly ClusterTarget[]>;
+    handleMatchEnded(matchId: string, reason?: string): void;
+}
+type TransportLabel = "p2p" | "dedicated" | "unknown";
+interface TelemetrySample {
+    readonly type: string;
+    readonly value?: number;
+    readonly transport?: TransportLabel;
+}
+interface P2pApiOptions {
+    readonly client: GemClient;
+    readonly gameId: () => string;
+}
+interface JoinCredential {
+    readonly credential: string;
+    readonly hostFingerprint: string;
+    readonly hostEpoch: number;
+    readonly expiresAt: number;
+}
+interface IceServer {
+    readonly urls: readonly string[];
+    readonly username: string;
+    readonly credential: string;
+}
+interface TurnLease {
+    readonly iceServers: readonly IceServer[];
+    readonly expiresAt: number;
+}
+type P2pTelemetryEvent = TelemetrySample;
+declare class P2pApi {
+    private readonly options;
+    private readonly reporter;
+    constructor(options: P2pApiOptions);
+    joinCredential(matchId: string, fingerprint: string, signal?: AbortSignal): Promise<JoinCredential>;
+    turnLease(matchId: string, clusterTargetId: string, signal?: AbortSignal): Promise<TurnLease>;
+    kick(matchId: string, playerId: string, signal?: AbortSignal): Promise<void>;
+    leave(matchId: string, keepalive?: boolean): Promise<void>;
+    telemetry(events: readonly P2pTelemetryEvent[], signal?: AbortSignal): Promise<void>;
+    private match;
+}
+type P2pFailure = "timeout" | "aborted" | "unsupported_protocol" | "signaling_unavailable" | "signaling_failed" | "invalid_sdp" | "media_refused" | "peer_unauthenticated" | "not_expected_player" | "keys_unavailable" | "migration_failed" | "kicked" | "match_ended" | "connection_failed" | "misconfigured";
+declare class P2pError extends Error {
+    readonly reason: P2pFailure;
+    readonly retryable: boolean;
+    constructor(reason: P2pFailure, message: string, options?: {
+        cause?: unknown;
+    });
+}
+interface P2pEventMap {
+    peerJoined: [
+        P2pPeer
+    ];
+    peerLeft: [
+        string,
+        string
+    ];
+    migrating: [
+        string,
+        number
+    ];
+    hostChanged: [
+        string,
+        number
+    ];
+    matchEnded: [
+        string
+    ];
+    candidatesDropped: [
+        number
+    ];
+    error: [
+        P2pError
+    ];
+}
+type P2pEventName = keyof P2pEventMap;
+interface KeySource {
+    key(kid: string): Promise<CryptoKey | null>;
+}
+interface SignalTransport {
+    signal(signal: string, matchId: string, data: Record<string, unknown>): void;
+    parentSupports(capability: string): boolean;
+}
+interface SignalingOptions {
+    readonly bridge: SignalTransport;
+    readonly matchId: string;
+    readonly clock: {
+        now(): number;
+        setTimeout(fn: () => void, ms: number): unknown;
+        clearTimeout(handle: unknown): void;
+    };
+    readonly maxQueuedCandidates?: number;
+    readonly candidateIntervalMs?: number;
+    readonly onCandidatesDropped?: (dropped: number) => void;
+}
+declare class SignalingClient {
+    private readonly options;
+    private readonly queue;
+    private drainHandle;
+    private dropped;
+    private closed;
+    private dropListener;
+    constructor(options: SignalingOptions);
+    onDropped(listener: (dropped: number) => void): void;
+    join(): void;
+    offer(sdp: string, intent: "initial" | "ice_restart" | "full_reconnect"): void;
+    answer(peerId: string, sdp: string, assignedPeerId: number): void;
+    candidate(peerId: string, candidate: string, sdpMid?: string, sdpMLineIndex?: number): void;
+    migrationAck(hostEpoch: number): void;
+    reportHostUnreachable(hostEpoch: number, iceState: "disconnected" | "failed" | "closed"): void;
+    discardQueued(): void;
+    close(): void;
+    private assertUsable;
+    private schedule;
+}
+type SdpType = "offer" | "answer" | "pranswer" | "rollback";
+interface SessionDescriptionLike {
+    readonly type: SdpType;
+    readonly sdp?: string;
+}
+interface IceCandidateLike {
+    readonly candidate: string;
+    readonly sdpMid?: string | null;
+    readonly sdpMLineIndex?: number | null;
+}
+interface EventTargetLike {
+    addEventListener(type: string, listener: (event: never) => void): void;
+    removeEventListener(type: string, listener: (event: never) => void): void;
+}
+interface DataChannelLike extends EventTargetLike {
+    readonly readyState: string;
+    readonly label: string;
+    binaryType: string;
+    send(data: string | ArrayBuffer): void;
+    close(): void;
+}
+interface DataChannelInitLike {
+    readonly ordered?: boolean;
+    readonly maxRetransmits?: number;
+    readonly negotiated?: boolean;
+    readonly id?: number;
+}
+interface PeerConnectionLike extends EventTargetLike {
+    readonly localDescription: SessionDescriptionLike | null;
+    readonly remoteDescription: SessionDescriptionLike | null;
+    readonly iceConnectionState: string;
+    readonly connectionState: string;
+    createDataChannel(label: string, init?: DataChannelInitLike): DataChannelLike;
+    createOffer(): Promise<SessionDescriptionLike>;
+    createAnswer(): Promise<SessionDescriptionLike>;
+    setLocalDescription(description?: SessionDescriptionLike): Promise<void>;
+    setRemoteDescription(description: SessionDescriptionLike): Promise<void>;
+    addIceCandidate(candidate: IceCandidateLike): Promise<void>;
+    close(): void;
+}
+interface PeerConnectionConfig {
+    readonly iceServers: readonly {
+        urls: readonly string[];
+        username?: string;
+        credential?: string;
+    }[];
+    readonly certificates?: readonly unknown[];
+}
+type PeerConnectionFactory = (config: PeerConnectionConfig) => PeerConnectionLike;
+type ChannelKind = "reliable" | "ordered" | "unreliable";
+declare class CredentialPacing {
+    private readonly perMinute;
+    private readonly sent;
+    constructor(perMinute?: number);
+    delayUntilAllowed(now: number): number;
+    record(now: number): void;
+    private prune;
+}
+interface P2pPeer {
+    readonly playerId: string;
+    readonly assignedPeerId: number;
+    readonly connection: PeerConnectionLike;
+    readonly channels: Readonly<Record<ChannelKind, DataChannelLike>>;
+    send(data: string | ArrayBuffer, kind?: ChannelKind): void;
+}
+interface P2pSessionOptions {
+    readonly api: P2pApi;
+    readonly clock: Clock;
+    readonly matchId: string;
+    readonly gameId: string;
+    readonly baseUrl: string;
+    readonly signaling: SignalingClient;
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly peerConnectionFactory?: PeerConnectionFactory;
+    readonly certificate?: unknown;
+    readonly connectTimeoutMs?: number;
+    readonly keys?: KeySource;
+    readonly boot?: BootTimeline;
+    readonly log?: ((message: string) => void) | null;
+    readonly credentialPacing?: CredentialPacing;
+}
+declare class P2pSession {
+    private readonly options;
+    private readonly emitter;
+    private readonly links;
+    private readonly replays;
+    private readonly keys;
+    private localPlayerId;
+    private migration;
+    private iceServers;
+    private credential;
+    private nextPeerId;
+    private ended;
+    private closed;
+    private ready;
+    private helloSeen;
+    private reportedUnreachableEpoch;
+    private reportedStallEpoch;
+    private counted;
+    private readonly pendingOffers;
+    private readonly answeredSessions;
+    private credentialGeneration;
+    private credentialDeadline;
+    constructor(options: P2pSessionOptions);
+    get matchId(): string;
+    get playerId(): string;
+    get isHost(): boolean;
+    get hostPlayerId(): string;
+    get hostEpoch(): number;
+    get peers(): readonly P2pPeer[];
+    peer(playerId: string): P2pPeer | null;
+    on<K extends P2pEventName>(event: K, listener: (...args: P2pEventMap[K]) => void): () => void;
+    off<K extends P2pEventName>(event: K, listener: (...args: P2pEventMap[K]) => void): void;
+    once<K extends P2pEventName>(event: K, listener: (...args: P2pEventMap[K]) => void): () => void;
+    start(signal?: AbortSignal): Promise<void>;
+    kick(playerId: string): Promise<void>;
+    leave(): Promise<void>;
+    close(): void;
+    report(events: readonly TelemetrySample[]): void;
+    notifyCandidatesDropped(dropped: number): void;
+    handleSignal(event: string, data: Record<string, unknown>): void;
+    private route;
+    private onHello;
+    private drainPendingOffers;
+    private offerToHost;
+    private fetchCredential;
+    private waitForCredential;
+    private onOffer;
+    private onAnswer;
+    private hostVerified;
+    private maybeAuthenticate;
+    private applyAnswer;
+    private onIce;
+    private onPeerLeft;
+    private onMigration;
+    private watchMigration;
+    private onMatchEnded;
+    private onSignalingError;
+    private openLink;
+    private flushCandidates;
+    private onReliableOpen;
+    private onHandshakeMessage;
+    private admit;
+    private refuseLink;
+    private finishAdmission;
+    private onIceState;
+    private onConnectionState;
+    private expose;
+    private dropLink;
+    private settle;
+    private fail;
+    private report_;
+    private count;
+    private refuseMedia;
+    private mark;
+    private sleep;
+    private warn;
+    get endedReason(): string | null;
+}
+interface P2pConnectOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+    readonly peerConnectionFactory?: PeerConnectionFactory;
+    readonly certificate?: unknown;
+}
+interface P2pMatchApi {
+    connect(options?: P2pConnectOptions): Promise<P2pSession>;
+    handleSignalEvent(matchId: string, event: string, data: Record<string, unknown>): void;
+    session(matchId: string): P2pSession | null;
+}
+type RoomArgValue = string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+interface ServerTokenGrant {
+    readonly token: string;
+    readonly expiresAt: number;
+}
+interface ServerBundleHost {
+    readonly matchId: string;
+    readonly gameId: string;
+    readonly channel: string;
+    readonly gameRoomId?: string;
+    readonly apiBaseUrl?: string;
+    serverToken?(): ServerTokenGrant | undefined;
+    onServerToken?(listener: (grant: ServerTokenGrant) => void): () => void;
+}
+interface SendOptions {
+    readonly reliable?: boolean;
+    readonly ordered?: boolean;
+}
+interface BroadcastOptions extends SendOptions {
+    readonly except?: string;
+}
+interface GemServerHostProfile {
+    readonly displayName?: string;
+    readonly displayTag?: string;
+    readonly discriminator?: string;
+}
+interface GemServerHost extends ServerBundleHost {
+    readonly sizeClass: string;
+    readonly roomArgs?: Readonly<Record<string, RoomArgValue>>;
+    readonly roster: readonly string[];
+    players(): string[];
+    profile?(playerId: string): GemServerHostProfile | undefined;
+    playerNumber?(playerId: string): number | undefined;
+    send(playerId: string, data: string | Uint8Array, options?: SendOptions): void;
+    broadcast(data: string | Uint8Array, options?: BroadcastOptions): void;
+    kick(playerId: string, reason?: string): void;
+    endMatch?(): Promise<"ok" | "already_ended" | "refused" | "failed" | (string & {})>;
+    log(message: string): void;
+    warn(message: string): void;
+}
+interface GemServerBundle {
+    init?(): void | Promise<void>;
+    join?(playerId: string, meta?: {
+        playerNumber?: number;
+        transport?: string;
+        rejoin?: boolean;
+        superseded?: boolean;
+    }): void | Promise<void>;
+    leave?(playerId: string, meta?: {
+        cause?: string;
+    }): void | Promise<void>;
+    message?(playerId: string, data: string | Uint8Array, isText: boolean, meta?: {
+        reliable?: boolean;
+        ordered?: boolean;
+        sessionId?: number;
+        playerNumber?: number;
+    }): void | Promise<void>;
+    shutdown?(info?: ServerShutdownInfo): void | Promise<void>;
+}
+interface ServerShutdownInfo {
+    readonly reason: "match_ended" | "idle_timeout" | "signal" | (string & {});
+    readonly endedReason?: string;
+}
+interface GemServerLifecycle {
+    init(host: GemServerHost): Promise<void>;
+    join?(playerId: string, meta?: {
+        playerNumber?: number;
+        transport?: string;
+        rejoin?: boolean;
+        superseded?: boolean;
+    }): void | Promise<void>;
+    leave?(playerId: string, meta?: {
+        cause?: string;
+    }): void | Promise<void>;
+    message?(playerId: string, data: string | Uint8Array, isText: boolean, meta?: {
+        reliable?: boolean;
+        ordered?: boolean;
+        sessionId?: number;
+        playerNumber?: number;
+    }): void | Promise<void>;
+    shutdown(info?: RuntimeShutdownPayload): Promise<void>;
+}
+interface RuntimeShutdownPayload {
+    readonly reason?: string;
+    readonly platform_reason?: string;
+    readonly endedReason?: string;
+}
+type GemServerFactory = () => GemServerLifecycle;
+type GemMatchServerModule = GemServerFactory | GemServerLifecycle;
+interface MatchServeOptions {
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+    readonly clusterTargetId?: ClusterTargetLike;
+}
+interface MatchConnectOptions extends MatchServeOptions {
+    readonly transports?: readonly TransportKind[];
+    readonly onMatchEnded?: (reason?: string) => void;
+}
+type MatchHostingMode = "listen" | "dedicated" | "peer";
+interface MatchHosting {
+    readonly mode: MatchHostingMode;
+    readonly matchId: string;
+    end(): Promise<void>;
+    leave(): Promise<void>;
+    stop(): Promise<void>;
+}
+interface MatchConnection {
+    readonly matchId: string;
+    readonly protocol: "dedicated" | "p2p" | "loopback";
+    readonly transport?: TransportKind;
+    send(data: string | Uint8Array, options?: SendOptions$1): void;
+    onMessage(handler: (data: string | Uint8Array, meta: MessageMeta) => void): void;
+    readonly state: "connected" | "suspended" | "closed";
+    onClose(handler: (reason?: string) => void): void;
+    close(): void;
+}
+interface GemMatchApi {
+    serve(server: GemMatchServerModule, options?: MatchServeOptions): Promise<MatchHosting>;
+    connect(options?: MatchConnectOptions): Promise<MatchConnection>;
+}
+interface PurchaseRequest {
+    kind: "item" | "recipe";
+    targetId: string;
+    currencySlug: string;
+    quantity?: number;
+    catalogId?: string;
+}
+type PurchaseOutcome = {
+    readonly outcome: "ok";
+    readonly purchaseId?: string;
+} | {
+    readonly outcome: "declined" | "unavailable";
+};
+interface PurchaseApi {
+    request(req: PurchaseRequest): Promise<PurchaseOutcome>;
+}
+type SignInOutcomeKind = "signed_in" | "declined" | "unavailable";
+interface SignInOutcome {
+    readonly outcome: SignInOutcomeKind;
+}
+interface AccountApi {
+    requestSignIn(): Promise<SignInOutcome>;
+}
+type AdFormat = "interstitial" | "rewarded";
+interface AdRequest {
+    placement: string;
+    format: AdFormat;
+}
+type AdOutcomeKind = "shown" | "no_ad" | "unavailable";
+interface AdOutcome {
+    readonly outcome: AdOutcomeKind;
+}
+interface AdsApi {
+    requestAd(req: AdRequest): Promise<AdOutcome>;
+}
+type DeviceSettings = Readonly<Record<string, unknown>>;
+type DeviceSettingsPutOutcome = "stored" | "too_large" | "unavailable";
+interface DeviceSettingsApi {
+    readonly current: DeviceSettings | null;
+    wait(timeoutMs?: number): Promise<DeviceSettings | null>;
+    put(settings: DeviceSettings): Promise<DeviceSettingsPutOutcome>;
+}
+interface RewardCue {
+    currencySlug: string;
+    expected?: number;
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+type FrameState = "waiting" | "connected" | "refused" | "closed";
+interface FrameCallbacks {
+    onToken?(msg: GemToken): void;
+    onPause?(msg: GemPause): void;
+    onPrefs?(msg: GemPrefs$1): void;
+    onCohorts?(msg: GemCohorts$1): 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: {
+        displayName: PlayerText;
+        displayHandle: PlayerText;
+        displayTag: string;
+        avatarUrl?: string;
+    }): void;
+    onRoomEvent?(msg: GemRoomEvent): void;
+    onSeatedEvent?(msg: GemSeatedEvent): void;
+    onSocketState?(msg: GemSocketState): void;
+    onSignalEvent?(msg: GemSignalEvent): void;
+    onDedicatedEvent?(msg: GemDedicatedEvent): void;
+    onClusterTarget?(msg: GemClusterTarget): void;
+    onPartyResult?(msg: GemPartyResult): void;
+    onPurchaseResult?(msg: GemPurchaseResult): void;
+    onDeviceSettings?(msg: GemDeviceSettings): void;
+    onDeviceSettingsResult?(msg: GemDeviceSettingsResult): void;
+    onAdResult?(msg: GemAdResult): void;
+    onSignInResult?(msg: GemSignInResult): 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 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;
+    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;
+    cueReward(cue: RewardCue): boolean;
+    reportFrameStats(stats: {
+        fps: number;
+        frameTimeP95Ms: number;
+    }): 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): boolean;
+    putDeviceSettings(requestId: string, settings: Readonly<Record<string, unknown>>): boolean;
+    requestAd(requestId: string, placement: string, format: "interstitial" | "rewarded"): boolean;
+    requestSignIn(requestId: string): boolean;
+    close(): void;
+    private transition;
+    private refuseMalformed;
+    private dropUnknownType;
+    private refuse;
+    private fail;
+    private send;
+    private receive;
+    private dispatchInbound;
+    private screenshotDenied;
+}
+declare const DEVICE_SETTINGS_MAX_BYTES = 16384;
+interface GemOptions {
+    readonly allowedEmbedders?: readonly string[];
+    readonly baseUrl?: string;
+    readonly clock?: Clock;
+    readonly onAuthStateChange?: (state: AuthState, reason?: AuthFailure) => void;
+    readonly onDevToolsPermissionChange?: (canOpen: boolean) => void;
+    readonly log?: ((message: string) => void) | null;
+    readonly clientVersion?: ClientVersion;
+    readonly pollRooms?: boolean;
+    readonly recoverStaleMembership?: boolean;
+    readonly watchSeats?: boolean;
+    readonly seatPollIntervalMs?: number;
+    readonly autoReconnect?: AutoReconnectOptions | false;
+    readonly onRefused?: (reason: string) => void;
+    readonly onError?: (code: GemErrorCode, message?: string) => void;
+    readonly onStateChange?: (state: FrameState) => void;
+    readonly onPlayer?: (player: GemPlayer) => void;
+    readonly onPrefs?: (prefs: GemPrefs) => void;
+    readonly onCohorts?: (cohorts: GemCohorts) => void;
+    readonly onDeviceSettings?: (settings: DeviceSettings | null) => void;
+    readonly onViewport?: (viewport: GemViewport) => void;
+    readonly manageAudio?: boolean;
+    readonly onPause?: (paused: boolean) => void;
+    readonly onWillTerminate?: (notice: GemTerminationNotice) => void;
+    readonly analytics?: AnalyticsOptions;
+    readonly onFeedbackContext?: () => Record<string, unknown> | null | Promise<Record<string, unknown> | null>;
+    readonly onScreenshot?: (request: {
+        readonly maxWidth: number;
+        readonly maxHeight: number;
+    }) => Promise<ImageBitmap | null>;
+    readonly handshakeWarningMs?: number | null;
+}
+interface GemPlayer {
+    readonly displayName: PlayerText;
+    readonly displayHandle: PlayerText;
+    readonly displayTag: string;
+    readonly avatarUrl?: string;
+}
+interface GemPrefs {
+    readonly reducedMotion: boolean;
+    readonly muted: boolean;
+    readonly showFrameStats: boolean;
+    readonly locale: string;
+}
+interface GemCohort {
+    readonly experimentId: string;
+    readonly variantKey: string;
+}
+type GemCohorts = readonly GemCohort[];
+interface GemInsets {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+interface GemViewport {
+    readonly insets: GemInsets;
+}
+interface GemTerminationNotice {
+    readonly reason: GemWillTerminate["reason"];
+    readonly graceMs: number;
+}
+interface GemIdentity {
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: string;
+}
+interface Gem {
+    readonly client: GemClient;
+    readonly identity: GemIdentity | null;
+    awaitIdentity(timeoutMs?: number): Promise<GemIdentity>;
+    awaitBridge(timeoutMs?: number): Promise<FrameState | null>;
+    readonly player: GemPlayer | null;
+    readonly me: EntityScope;
+    readonly characters: CharactersApi;
+    readonly transfers: TransfersApi;
+    readonly gameConfig: GameConfigApi;
+    readonly purchases: PurchaseApi;
+    readonly deviceSettings: DeviceSettingsApi;
+    readonly ads: AdsApi;
+    readonly account: AccountApi;
+    readonly analytics: AnalyticsApi;
+    readonly leaderboards: LeaderboardsApi;
+    readonly challenges: ChallengesApi;
+    readonly showcase: ShowcaseApi;
+    readonly friends: FriendsApi;
+    readonly platform: PlatformApi;
+    readonly profiles: ProfilesApi;
+    awaitPlayer(timeoutMs?: number): Promise<GemPlayer | null>;
+    readonly prefs: GemPrefs | null;
+    readonly cohorts: GemCohorts | null;
+    readonly viewport: GemViewport | null;
+    awaitCohorts(timeoutMs?: number): Promise<GemCohorts | null>;
+    reportMuted(muted: boolean): void;
+    cueReward(cue: RewardCue): boolean;
+    exit(reason?: string): Promise<void>;
+    readonly boot: BootTimeline;
+    readonly frame: GemFrame;
+    readonly devtools: GemDevTools;
+    readonly rooms: RoomManager;
+    readonly dedicatedServer: DedicatedServerApi;
+    readonly p2p: P2pMatchApi;
+    readonly match: GemMatchApi;
+}
+interface ExitBridge {
+    readonly currentState: FrameState;
+    exit(reason?: string): void;
+}
+interface ExitRooms {
+    readonly isInRoom: boolean;
+    leave(options?: {
+        asGroup?: boolean;
+        keepalive?: boolean;
+    }): Promise<void>;
+}
+interface ExitAnalytics {
+    endSession(reason: "session_ended"): void;
+}
+declare function leaveAndExit(rooms: ExitRooms, bridge: ExitBridge | null, reason?: string, analytics?: ExitAnalytics): Promise<void>;
+declare function createGem(options?: GemOptions): Gem;
+export { type AccountApi, type AdFormat, type AdOutcome, type AdOutcomeKind, type AdRequest, type AdsApi, AnalyticsApi, type AnalyticsFlushOptions, type AnalyticsFlushResult, type AnalyticsOptions, type AnalyticsRejection, type AnalyticsValue, AuthError, type AuthFailure, type AuthState, type BootMark, type BootTimeline, type Challenge, type ChallengeWindow, ChallengesApi, type ConfiguredPurchasePayment, type ConfiguredPurchaseRequest, type ConfiguredPurchaseResult, DEVICE_SETTINGS_MAX_BYTES, DedicatedServerError, type DedicatedServerFailure, type DedicatedServerSession, type DevToolsOpener, type DeviceSettings, type DeviceSettingsApi, type DeviceSettingsPutOutcome, type DirectPurchaseRequest, type DirectPurchaseResult, type EntityLeaderboard, type EntityLeaderboardEntry, type EntityLeaderboardOptions, type EntityType, type ExitAnalytics, type ExitBridge, type ExitRooms, type FrameState, type Friend, FriendsApi, type FriendsPage, type GameConfig, type GameServerLink, type Gem, GemApiError, GemClient, type GemCohort, type GemCohorts, GemConfigError, type GemDevTools, GemFrame, type GemIdentity, type GemInsets, type GemMatchApi, type GemMatchServerModule, type GemOptions, type GemPlayer, type GemPrefs, GemSaveError, type GemServerBundle, type GemServerFactory, type GemServerHost, type GemServerHostProfile, type GemServerLifecycle, type GemTerminationNotice, type GemViewport, type GetLeaderboardOptions, type JoinWelcome, type Leaderboard, type LeaderboardEntry, LeaderboardsApi, type ListChallengesOptions, type ListFriendsOptions, MAX_PERIODS_BACK, type MatchConnectOptions, type MatchConnection, type MatchHosting, type MatchHostingMode, type MatchServeOptions, type MatchTransport, type MessageMeta, type MultiTransportSession, PLATFORM_EVENTS, PlatformApi, PlatformCurrenciesApi, type PlatformCurrency, type PlatformCurrencyAccess, type PlatformCurrencyPurchasePayment, type PlatformCurrencyPurchaseRequest, type PlatformCurrencyPurchaseResult, type PlatformCurrencyReadOptions, type PlatformEventName, type PlayerProfile, PlayerText, type ProfileCallOptions, type ProfileShowcaseEntry, ProfilesApi, type PurchaseApi, type PurchaseOptions, type PurchaseOutcome, type PurchaseRequest, type PutBytesOptions, type PutSaveOptions, type RankedRow, type RewardCue, type SavePage, type SaveRecord, type SendOptions$1 as SendOptions, type ServerTokenGrant, type SessionEndReason, ShowcaseApi, type ShowcaseCallOptions, type ShowcaseFriendEntry, type ShowcaseFriends, type ShowcaseValue, type SignInOutcome, type SignInOutcomeKind, type SnapshotCurrency, type SnapshotItem, type TransportAdvert, type TransportKind, TransportRefusal, UNRELIABLE_CHANNEL_LABEL, asPlayerText, createBootTimeline, createGem, leaveAndExit, markOnResolve, presentJoinCredential, readTemplateTransports, readTransportAdvert, reportOnResolve, text, webTransportAvailable };