@series-inc/rundot-game-sdk 5.0.0

package/dist/index.d.ts

@@ -0,0 +1,1085 @@
+import { A as AnalyticsApi, s as RpcRequest, t as RpcResponse, u as RpcNotification, v as RpcClient, R as RundotGameAPI, H as Host, w as StorageApi, N as NavigationApi, Q as QuitOptions, x as NavigationStackInfo, y as PushAppOptions, z as NotificationsApi, C as ScheduleLocalNotification, D as ScheduleNotificationOptions, E as PopupsApi, F as ShowToastOptions, G as ShowInterstitialAdOptions, I as ShowRewardedAdOptions, J as ProfileApi, P as Profile, K as DeviceApi, L as DeviceInfo, M as EnvironmentApi, O as EnvironmentInfo, T as SystemApi, U as SafeArea, V as CdnApi, W as FetchFromCdnOptions, X as TimeApi, Y as ServerTimeData, Z as GetFutureTimeOptions, _ as AiApi, $ as AiChatCompletionRequest, a0 as AiChatCompletionData, a1 as HapticsApi, a2 as HapticFeedbackStyle, a3 as FeaturesApi, a4 as Experiment, a5 as LifecycleApi, a6 as SleepCallback, a7 as Subscription, a8 as AwakeCallback, a9 as PauseCallback, aa as ResumeCallback, ab as QuitCallback, ac as SimulationApi, ad as SimulationSlotValidationResult, h as SimulationSubscribeOptions, ae as SimulationBatchOperation, af as SimulationBatchOperationsResult, ag as SimulationAvailableItem, ah as SimulationPowerPreview, ai as SimulationSlotMutationResult, aj as SimulationSlotContainer, ak as SimulationAssignment, al as SimulationState, k as RundotGameSimulationConfig, am as ExecuteRecipeOptions, an as ExecuteRecipeResponse, ao as CollectRecipeResult, ap as ResetStateOptions, aq as ResetStateResult, ar as GetActiveRunsOptions, S as SimulationRunSummary, as as ExecuteScopedRecipeOptions, at as ExecuteScopedRecipeResult, au as GetAvailableRecipesOptions, av as GetAvailableRecipesResult, aw as Recipe, a as RecipeRequirementResult, ax as GetBatchRecipeRequirements, ay as TriggerRecipeChainOptions, az as RoomDataUpdate, aA as RoomMessageEvent, aB as ProposedMoveEvent, aC as RundotGameTransport, aD as RoomsApi, aE as CreateRoomOptions, r as RundotGameRoom, aF as JoinOrCreateRoomOptions, aG as JoinOrCreateResult, aH as ListRoomsOptions, aI as UpdateRoomDataOptions, aJ as RoomMessageRequest, aK as StartRoomGameOptions, aL as ProposeMoveRequest, aM as ProposeMoveResult, aN as ValidateMoveVerdict, aO as ValidateMoveResult, aP as RoomSubscriptionOptions, aQ as LoggingApi, aR as IapApi, aS as SpendCurrencyOptions, aT as LoadEmbeddedAssetsResponse, aU as SharedAssetsApi, aV as LeaderboardApi, aW as ScoreToken, aX as SubmitScoreParams, aY as SubmitScoreResult, aZ as GetPagedScoresOptions, a_ as PagedScoresResponse, a$ as PlayerRankOptions, b0 as PlayerRankResult, b1 as GetPodiumScoresOptions, b2 as PodiumScoresResponse, b3 as PreloaderApi, b4 as SocialApi, b5 as ShareMetadata, b6 as ShareLinkResult, b7 as SocialQRCodeOptions, b8 as QRCodeResult, b9 as Avatar3dApi, ba as AssetManifest, bb as Avatar3dConfig, bc as ShowEditorOptions, bd as Avatar3dEdits, be as AdsApi, bf as InitializationContext, bg as InitializationOptions } from './AdsApi-B_d_w_jB.js';
+export { bh as AiMessage, bi as Asset, bj as Category, bW as HudInsets, bE as JoinOrCreateRoomEnvelopeResponse, bs as JoinRoomMatchCriteria, bR as LeaderboardAntiCheatConfig, bT as LeaderboardConfig, bS as LeaderboardDisplaySettings, bU as LeaderboardEntry, bO as LeaderboardModeConfig, bQ as LeaderboardPeriodConfig, bP as LeaderboardPeriodType, bN as LoadEmbeddedAssetsRequest, bk as MockAvatarApi, bn as NotificationTriggerInput, bq as OnNotificationCallback, bo as OnRequestCallback, bp as OnResponseCallback, bV as PodiumScoresContext, bv as ProposedMovePayload, bw as ROOM_GAME_PHASES, bF as RecipeInfo, bC as RoomEnvelopeResponse, bx as RoomGamePhase, bt as RoomMessageEventType, bu as RoomMessagePayload, bD as RoomsEnvelopeResponse, bM as RpcSharedAssetsApi, br as RpcTransport, bA as RundotGameRoomCustomMetadata, bB as RundotGameRoomPayload, bz as RundotGameRoomRules, by as RundotGameRoomRulesGameState, bJ as SimulationBatchOperationAssign, bK as SimulationBatchOperationRemove, bL as SimulationBatchOperationResult, bG as SimulationPersonalState, bH as SimulationRoomActiveRecipe, bI as SimulationRoomState, bl as SubPath, bm as TimeIntervalTriggerInput, bX as createHost } from './AdsApi-B_d_w_jB.js';
+export { WEBVIEW_LIBRARY_SHIM_SOURCE, getWebviewLibraryShimSource } from './webview/index.js';
+
+declare class MockAnalyticsApi implements AnalyticsApi {
+    recordCustomEvent(eventName: string, payload: Record<string, any>): Promise<void>;
+    trackFunnelStep(stepNumber: number, stepName: string, funnelName?: string): Promise<void>;
+}
+
+type RpcMessage = RpcRequest | RpcResponse | RpcNotification;
+
+declare class RpcAnalyticsApi implements AnalyticsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    recordCustomEvent(eventName: string, payload: Record<string, any>): Promise<void>;
+    trackFunnelStep(stepNumber: number, stepName: string, funnelName?: string): Promise<void>;
+}
+
+declare function initializeAnalytics(rundotGameApiInstance: RundotGameAPI, host: Host): void;
+
+type StorageType = 'globalStorage' | 'deviceCache' | 'appStorage';
+declare function createMockStorageApi(storageType: StorageType, appUrl?: string): MockStorageApi;
+declare class MockStorageApi implements StorageApi {
+    private readonly prefix;
+    private readonly syncDelay;
+    private readonly orderStorageKey;
+    constructor(prefix: string, syncDelay: number);
+    clear(): Promise<void>;
+    getAllItems(): Promise<string[]>;
+    getAllData(): Promise<Record<string, string>>;
+    getItem(key: string): Promise<string | null>;
+    key(index: number): Promise<string | null>;
+    length(): Promise<number>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, item: string): Promise<void>;
+    setMultipleItems(entries: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+    removeMultipleItems(keys: string[]): Promise<void>;
+    private buildKey;
+    private extractKey;
+    private keys;
+    private simulateSyncDelay;
+    private readOrder;
+    private normalizeOrder;
+    private rebuildOrderFromStorage;
+    private upsertOrder;
+    private bulkUpsertOrder;
+    private removeFromOrder;
+    private bulkRemoveFromOrder;
+    private writeOrder;
+    private clearOrder;
+    private dedupeKeys;
+}
+
+interface MethodIds {
+    clear: string;
+    getItem: string;
+    getKey: string;
+    length: string;
+    removeItem: string;
+    setItem: string;
+    getAllItems?: string;
+    removeMultipleItems?: string;
+    setMultipleItems?: string;
+}
+declare class RpcStorageApi implements StorageApi {
+    private readonly rpcClient;
+    private readonly methodIds;
+    constructor(rpcClient: RpcClient, methodIds: MethodIds);
+    clear(): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    key(index: number): Promise<string | null>;
+    length(): Promise<number>;
+    removeItem(key: string): Promise<void>;
+    removeMultipleItems(keys: string[]): Promise<void>;
+    getAllItems(): Promise<string[]>;
+    getAllData(): Promise<Record<string, string>>;
+    setMultipleItems(items: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+}
+
+declare function initializeStorage(rundotGameApiInstance: RundotGameAPI, host: Host): void;
+
+declare class MockNavigationApi implements NavigationApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    requestPopOrQuit(options?: QuitOptions): Promise<boolean>;
+    getStackInfo(): NavigationStackInfo;
+    popApp(): Promise<void>;
+    pushApp(appId: string, options?: PushAppOptions): Promise<void>;
+    private log;
+}
+
+declare class RpcNavigationApi implements NavigationApi {
+    private readonly rundotGameApi;
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient, rundotGameApi: RundotGameAPI);
+    requestPopOrQuit(options?: QuitOptions): Promise<boolean>;
+    getStackInfo(): NavigationStackInfo;
+    popApp(): Promise<void>;
+    pushApp(appId: string, options?: PushAppOptions): Promise<void>;
+}
+
+declare function initializeStackNavigation(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class MockNotificationsApi implements NotificationsApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    cancelNotification(notificationId: string): Promise<boolean>;
+    getAllScheduledLocalNotifications(): Promise<ScheduleLocalNotification[]>;
+    isLocalNotificationsEnabled(): Promise<boolean>;
+    scheduleAsync(title: string, body: string, seconds: number, notificationId?: string, options?: ScheduleNotificationOptions): Promise<string | null>;
+    setLocalNotificationsEnabled(enabled: boolean): Promise<boolean>;
+}
+
+declare class RpcNotificationsApi implements NotificationsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    scheduleAsync(title: string, body: string, seconds: number, notificationId?: string, options?: ScheduleNotificationOptions): Promise<string | null>;
+    cancelNotification(id: string): Promise<boolean>;
+    getAllScheduledLocalNotifications(): Promise<ScheduleLocalNotification[]>;
+    isLocalNotificationsEnabled(): Promise<boolean>;
+    setLocalNotificationsEnabled(enabled: boolean): Promise<boolean>;
+}
+type NotificationContent = {
+    title: string | null;
+    subtitle: string | null;
+    body: string | null;
+    data?: Record<string, any>;
+};
+
+declare function initializeLocalNotifications(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcPopupsApi implements PopupsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    showToast(message: string, options?: ShowToastOptions): Promise<boolean>;
+}
+interface ShowToastResponse {
+    shown: boolean;
+    actionTriggered: boolean;
+}
+
+interface MockActionSheetItem {
+    id?: string;
+    label: string;
+    icon?: string;
+}
+interface MockActionSheetOptions {
+    title?: string;
+    message?: string;
+    cancelButtonText?: string;
+    disableCancel?: boolean;
+}
+interface MockOverlay {
+    container: HTMLElement;
+    elements: OverlayElements;
+    adOverlay: HTMLElement;
+    actionSheetOverlay: HTMLElement;
+    appVisibilityState: 'visible' | 'hidden';
+    showAdOverlay: (options?: ShowInterstitialAdOptions | ShowRewardedAdOptions) => Promise<boolean>;
+    showActionSheet: (items: MockActionSheetItem[], options?: MockActionSheetOptions) => Promise<string | number | null>;
+}
+interface OverlayElements {
+    menuButton: HTMLElement;
+}
+
+declare class MockPopupsApi implements PopupsApi {
+    private readonly overlay;
+    constructor(override: MockOverlay);
+    showToast(message: string, options?: ShowToastOptions): Promise<boolean>;
+}
+
+declare function initializePopups(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class HostProfileApi implements ProfileApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getCurrentProfile(): Profile;
+}
+
+declare class MockProfileApi implements ProfileApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getCurrentProfile(): Profile;
+}
+
+/**
+ * Sandbox profile API.
+ *
+ * In sandbox mode (browser + real backend), profile identity must match the backend's
+ * notion of profileId (which is effectively the Firebase Auth UID in this codebase).
+ *
+ * This implementation reads from `rundotGameApi._profileData`, which is populated by
+ * SandboxHost when Firebase auth state changes.
+ *
+ * NOTE: `ProfileApi` is synchronous, so we return a placeholder profile until the
+ * user signs in and `_profileData` is available.
+ */
+declare class SandboxProfileApi implements ProfileApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getCurrentProfile(): Profile;
+}
+
+declare function initializeProfile(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class HostDeviceApi implements DeviceApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getDevice(): DeviceInfo;
+}
+
+declare class MockDeviceApi implements DeviceApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getDevice(): DeviceInfo;
+}
+
+declare class HostEnvironmentApi implements EnvironmentApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getEnvironment(): EnvironmentInfo;
+}
+
+declare class MockEnvironmentApi implements EnvironmentApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    getEnvironment(): EnvironmentInfo;
+}
+
+/**
+ * Host implementation of SystemApi that delegates to device and environment APIs.
+ * Acts as a facade combining both system-level information sources.
+ */
+declare class HostSystemApi implements SystemApi {
+    private readonly deviceApi;
+    private readonly environmentApi;
+    private readonly rundotGameApi;
+    constructor(deviceApi: DeviceApi, environmentApi: EnvironmentApi, rundotGameApi: RundotGameAPI);
+    getDevice(): DeviceInfo;
+    getEnvironment(): EnvironmentInfo;
+    getSafeArea(): SafeArea;
+    isMobile(): boolean;
+    isWeb(): boolean;
+}
+
+/**
+ * Mock implementation of SystemApi for local development.
+ * Delegates to mock device and environment APIs.
+ */
+declare class MockSystemApi implements SystemApi {
+    private readonly deviceApi;
+    private readonly environmentApi;
+    private readonly rundotGameAPI;
+    constructor(deviceApi: DeviceApi, environmentApi: EnvironmentApi, rundotGameApi: RundotGameAPI);
+    getDevice(): DeviceInfo;
+    getEnvironment(): EnvironmentInfo;
+    getSafeArea(): SafeArea;
+    isMobile(): boolean;
+    isWeb(): boolean;
+}
+
+declare function initializeSystem(rundotGameApi: RundotGameAPI, host: Host): void;
+
+/**
+ * Base class for CDN API implementations with shared utility methods
+ */
+declare abstract class BaseCdnApi implements CdnApi {
+    private static readonly AVATAR_ASSETS_PREFIX;
+    private static readonly SHARED_LIBS_PREFIX;
+    protected abstract getCdnAssetsBaseUrl(): string;
+    protected abstract getCdnBaseUrl(): string;
+    protected abstract getSharedAssetsCdnBaseUrl(): string;
+    /**
+     * Remove leading slash from subPath
+     */
+    protected cleanSubPath(subPath: string): string;
+    /**
+     * Encode path parts - only encode the filename (last part) to preserve directory structure
+     */
+    protected encodePathParts(subPath: string): string;
+    /**
+     * Check if subPath is already a full URL
+     */
+    protected isFullUrl(subPath: string): boolean;
+    /**
+     * Normalize base URL to not end with trailing slash
+     */
+    protected normalizeBaseUrl(url: string): string;
+    /**
+     * Build full URL with encoding
+     */
+    protected buildCdnUrl(subPath: string, baseUrl: string): string;
+    /**
+     * Execute a fetch request with timeout handling
+     */
+    protected executeFetch(url: string, options?: FetchFromCdnOptions): Promise<Blob>;
+    getAssetCdnBaseUrl(): string;
+    resolveAssetUrl(subPath: string): string;
+    resolveAvatarAssetUrl(subPath: string): string;
+    resolveSharedLibUrl(subPath: string): string;
+    abstract fetchAsset(relativePath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+    abstract fetchFromCdn(subPath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+}
+
+/**
+ * CDN API implementation for production/remote environments.
+ * Automatically derives the CDN URL from the current window location.
+ */
+declare class HostCdnApi extends BaseCdnApi {
+    private static readonly CDN_FOLDER_NAME;
+    private static readonly MIN_PATH_PARTS_FOR_CDN;
+    private static readonly MANIFEST_FILE_PREFIX;
+    private static readonly SHARED_ASSETS_CDN_BASE;
+    private readonly bucketBaseUrl;
+    private readonly gameId;
+    private readonly version;
+    private manifestCache;
+    private manifestPromise;
+    constructor();
+    protected getCdnAssetsBaseUrl(): string;
+    protected getCdnBaseUrl(): string;
+    protected getSharedAssetsCdnBaseUrl(): string;
+    /**
+     * Compute CDN information from the current window location.
+     *
+     * Expected URL structure:
+     * - App: {origin}/{bucket}/{gameId}/{version}/...
+     * - Bucket root: {origin}/{bucket}/
+     *
+     * Example:
+     * - App: https://h5-apps.development.getreel.com/development/game123/v1.0.0/index.html
+     * - Bucket: https://h5-apps.development.getreel.com/development
+     * - Game ID: game123
+     * - Version: v1.0.0
+     *
+     * @throws {Error} If not in browser environment or URL structure doesn't match expected pattern
+     */
+    private computeCdnInfo;
+    private isBrowserEnvironment;
+    /**
+     * Fetch directly from CDN root (bucket root).
+     * This is the primitive fetch operation that accesses files from the bucket base URL.
+     *
+     * @param subPath - Path relative to bucket root (e.g., "othergame/bundle.stow", "game123/cdn-assets/file.png")
+     * @param options - Optional fetch options including timeout
+     * @returns Promise<Blob> - The asset data as a Blob
+     *
+     * @example
+     * // App URL: https://h5-apps.dev.com/development/game123/v1.0.0/
+     * // fetchFromCdn("othergame/asset.png")
+     * // → https://h5-apps.dev.com/development/othergame/asset.png
+     */
+    fetchFromCdn(subPath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+    /**
+     * Fetch an asset using the manifest to resolve the actual hashed filename.
+     * The manifest maps logical paths (e.g., "images/hero.png") to file hashes.
+     * The actual files are stored as {hash}.{extension} in the CDN.
+     *
+     * @param relativePath - The logical path to the asset (e.g., "/assets/sample.json" or "assets/sample.json")
+     * @param options - Optional fetch options including timeout
+     * @returns Promise<Blob> - The asset data as a Blob
+     * @throws {Error} If the asset is not found in the manifest or the fetch fails
+     */
+    fetchAsset(relativePath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+    /**
+     * Get the manifest, either from cache or by fetching it.
+     * Uses promise caching to prevent multiple simultaneous fetches.
+     */
+    private getManifest;
+    /**
+     * Fetch the manifest file from the CDN.
+     * The manifest filename is based on the version: manifest_{version}.json
+     */
+    private fetchManifest;
+}
+
+/**
+ * CDN API implementation for mock/development environments.
+ * Serves assets from the public/cdn-assets folder via Vite dev server.
+ */
+declare class MockCdnApi extends BaseCdnApi {
+    private static readonly LEGACY_CDN_PREFIX;
+    private static readonly SHARED_ASSETS_CDN_BASE;
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    protected getCdnAssetsBaseUrl(): string;
+    protected getCdnBaseUrl(): string;
+    protected getSharedAssetsCdnBaseUrl(): string;
+    resolveAssetUrl(subPath: string): string;
+    /**
+     * Fetch an asset directly from the bucket root (public folder root in mock mode).
+     * This mimics production behavior where cross-game assets are at the bucket root.
+     *
+     * @param subPath - The path relative to public folder root (e.g., "othergame/bundle.stow")
+     * @param options - Optional fetch options including timeout
+     * @returns Promise<Blob> - The asset data as a Blob
+     *
+     * @example
+     * // In mock mode with public folder structure:
+     * // fetchFromCdn("othergame/bundle.stow")
+     * // → othergame/bundle.stow (from public root, not public/cdn-assets)
+     */
+    fetchFromCdn(subPath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+    /**
+     * Fetch an asset in mock/development mode.
+     * In development, assets are served directly without manifest transformation,
+     * so this method fetches from the cdn-assets folder.
+     *
+     * @param relativePath - The path to the asset (e.g., "/some/asset.png" or "some/asset.png")
+     * @param options - Optional fetch options including timeout
+     * @returns Promise<Blob> - The asset data as a Blob
+     */
+    fetchAsset(relativePath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+}
+
+declare function initializeCdn(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class HostTimeApi implements TimeApi {
+    private readonly rpcClient;
+    private readonly rundotGameApi;
+    constructor(rpcClient: RpcClient, rundotGameApi: RundotGameAPI);
+    requestTimeAsync(): Promise<ServerTimeData>;
+    formatTime(timestamp: number, options?: any): string;
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    getFutureTimeAsync(options?: GetFutureTimeOptions): Promise<number>;
+}
+
+declare function isPacificDaylightTime(date: Date): boolean;
+
+declare class MockTimeApi implements TimeApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    formatTime(timestamp: number, options?: any): string;
+    getFutureTimeAsync(options?: GetFutureTimeOptions): Promise<number>;
+    requestTimeAsync(): Promise<ServerTimeData>;
+}
+
+declare function initializeTime(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcAiApi implements AiApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    requestChatCompletionAsync(request: AiChatCompletionRequest): Promise<AiChatCompletionData>;
+    getAvailableCompletionModels(): Promise<Array<string>>;
+}
+
+declare class MockAiApi implements AiApi {
+    requestChatCompletionAsync(request: AiChatCompletionRequest): Promise<AiChatCompletionData>;
+    getAvailableCompletionModels(): Promise<Array<string>>;
+}
+
+declare function initializeAi(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcHapticsApi implements HapticsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    triggerHapticAsync(style: HapticFeedbackStyle): Promise<void>;
+}
+
+declare class MockHapticsApi implements HapticsApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    triggerHapticAsync(style: HapticFeedbackStyle): Promise<void>;
+}
+
+declare function initializeHaptics(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcFeaturesApi implements FeaturesApi {
+    private readonly rpcClient;
+    constructor(rcpClient: RpcClient);
+    getExperiment(experimentName: string): Promise<Experiment | null>;
+    getFeatureFlag(flagName: string): Promise<boolean>;
+    getFeatureGate(gateName: string): Promise<boolean>;
+}
+
+declare class MockFeaturesApi implements FeaturesApi {
+    getExperiment(experimentName: string): Promise<Experiment | null>;
+    getFeatureFlag(flagName: string): Promise<boolean>;
+    getFeatureGate(gateName: string): Promise<boolean>;
+}
+
+declare function initializeFeaturesApi(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class MockLifecycleApi implements LifecycleApi {
+    private pauseCallbacks;
+    private resumeCallbacks;
+    private awakeCallbacks;
+    private sleepCallbacks;
+    private quitCallbacks;
+    onSleep(callback: SleepCallback): Subscription;
+    onAwake(callback: AwakeCallback): Subscription;
+    onPause(callback: PauseCallback): Subscription;
+    onResume(callback: ResumeCallback): Subscription;
+    onQuit(callback: QuitCallback): Subscription;
+    triggerPauseCallbacks(): void;
+    triggerResumeCallbacks(): void;
+    triggerAwakeCallbacks(): void;
+    triggerSleepCallbacks(): void;
+    triggerQuitCallbacks(): void;
+}
+
+declare class RpcLifecycleApi implements LifecycleApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    onQuit(callback: QuitCallback): Subscription;
+    onSleep(callback: SleepCallback): Subscription;
+    onAwake(callback: AwakeCallback): Subscription;
+    onResume(callback: ResumeCallback): Subscription;
+    onPause(callback: PauseCallback): Subscription;
+}
+
+declare function initializeLifecycleApi(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcSimulationApi implements SimulationApi {
+    private readonly rpcClient;
+    private _simulationConfig;
+    private readonly subscriptionCallbacks;
+    constructor(rpcClient: RpcClient);
+    isEnabled(): boolean;
+    validateSlotAssignmentAsync(containerId: string, slotId: string, itemId: string): Promise<SimulationSlotValidationResult>;
+    subscribeAsync(options: SimulationSubscribeOptions): Promise<() => void>;
+    executeBatchOperationsAsync(operations: Array<SimulationBatchOperation>, validateOnly?: boolean): Promise<SimulationBatchOperationsResult>;
+    getAvailableItemsAsync(containerId: string, slotId: string): Promise<SimulationAvailableItem[]>;
+    calculatePowerPreviewAsync(containerId: string, slotId: string, candidateItemId: string): Promise<SimulationPowerPreview>;
+    assignItemToSlotAsync(containerId: string, slotId: string, itemId: string): Promise<SimulationSlotMutationResult>;
+    removeItemFromSlotAsync(containerId: string, slotId: string): Promise<SimulationSlotMutationResult>;
+    getSlotContainersAsync(): Promise<SimulationSlotContainer[]>;
+    getSlotAssignmentsAsync(containerId: string): Promise<SimulationAssignment[]>;
+    getStateAsync(roomId?: string): Promise<SimulationState>;
+    getConfigAsync(roomId?: string): Promise<RundotGameSimulationConfig>;
+    executeRecipeAsync(recipeId: string, inputs?: Record<string, unknown>, options?: ExecuteRecipeOptions): Promise<ExecuteRecipeResponse>;
+    collectRecipeAsync(runId: string): Promise<CollectRecipeResult>;
+    resetStateAsync(options?: ResetStateOptions): Promise<ResetStateResult>;
+    getActiveRunsAsync(options?: GetActiveRunsOptions): Promise<SimulationRunSummary[]>;
+    executeScopedRecipeAsync(recipeId: string, entity: string, inputs?: Record<string, unknown>, options?: ExecuteScopedRecipeOptions): Promise<ExecuteScopedRecipeResult>;
+    getAvailableRecipesAsync(options?: GetAvailableRecipesOptions): Promise<GetAvailableRecipesResult>;
+    getRecipeRequirementsAsync(recipe: Recipe): Promise<RecipeRequirementResult>;
+    getBatchRecipeRequirementsAsync(recipes: Recipe[]): Promise<GetBatchRecipeRequirements>;
+    triggerRecipeChainAsync(recipeId: string, options?: TriggerRecipeChainOptions): Promise<ExecuteRecipeResponse>;
+    getEntityMetadataAsync(entityId: string): Promise<Record<string, unknown>>;
+    resolveFieldValueAsync(entityId: string, fieldPath: string, entity?: string): Promise<unknown>;
+    private handleSimulationUpdate;
+    private ensureValidSubscribeOptions;
+}
+
+declare function initializeSimulation(rundotGameApi: RundotGameAPI, host: Host): void;
+
+interface RoomNotificationSubscriptionState {
+    data: Record<string, Array<(event: RoomDataUpdate) => void>>;
+    messages: Record<string, Array<(event: RoomMessageEvent) => void>>;
+    gameEvents: Record<string, Array<(event: ProposedMoveEvent) => void>>;
+}
+/**
+ * Set up room notification listeners using the transport's onRundotGameMessage hook.
+ * This routes host-sent room notifications (H5_ROOM_DATA_UPDATED, etc.) to the
+ * callbacks registered in the RoomsApi instance.
+ * @param transport The RUN.game transport to listen for messages
+ * @param getSubscriptions Function to retrieve subscription state from RoomsApi
+ */
+declare function setupRoomNotifications(transport: RundotGameTransport, getSubscriptions: () => RoomNotificationSubscriptionState): Subscription;
+
+declare class RpcRoomsApi implements RoomsApi {
+    private readonly rpcClient;
+    private readonly subscriptions;
+    constructor(rpcClient: RpcClient);
+    /**
+     * Get the subscription state for external access (used by setupRoomNotifications)
+     */
+    getSubscriptions(): RoomNotificationSubscriptionState;
+    /**
+     * Set up room notification routing from the transport
+     */
+    setupNotifications(transport: RundotGameTransport): void;
+    createRoomAsync(options: CreateRoomOptions): Promise<RundotGameRoom>;
+    joinOrCreateRoomAsync(options: JoinOrCreateRoomOptions): Promise<JoinOrCreateResult>;
+    joinRoomByCodeAsync(roomCode: string): Promise<RundotGameRoom>;
+    getUserRoomsAsync(options?: ListRoomsOptions): Promise<RundotGameRoom[]>;
+    /**
+     * @deprecated Prefer server-authoritative flows (e.g. `proposeMoveAsync` / `startRoomGameAsync`)
+     * and treat `customMetadata.rules.gameState` as the canonical room lifecycle state.
+     */
+    updateRoomDataAsync(room: RundotGameRoom, updates: Record<string, unknown>, options?: UpdateRoomDataOptions): Promise<void>;
+    getRoomDataAsync(room: RundotGameRoom): Promise<Record<string, unknown>>;
+    sendRoomMessageAsync(rundotGameRoom: RundotGameRoom, request: RoomMessageRequest): Promise<string>;
+    leaveRoomAsync(room: RundotGameRoom): Promise<void>;
+    kickPlayerAsync(room: RundotGameRoom, targetProfileId: string, options?: {
+        reason?: string;
+    }): Promise<void>;
+    startRoomGameAsync(room: RundotGameRoom, options?: StartRoomGameOptions): Promise<void>;
+    proposeMoveAsync(room: RundotGameRoom, proposalPayload: ProposeMoveRequest): Promise<ProposeMoveResult>;
+    validateMoveAsync(_room: RundotGameRoom, moveId: string, verdict: ValidateMoveVerdict): Promise<ValidateMoveResult>;
+    subscribeAsync(room: RundotGameRoom, options?: RoomSubscriptionOptions): Promise<() => void>;
+}
+
+declare function initializeRoomsApi(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class MockLoggingApi implements LoggingApi {
+    logDebug(message?: any, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+}
+
+declare class RpcLoggingApi implements LoggingApi {
+    private readonly host;
+    private readonly rpcClient;
+    constructor(host: Host, rpcClient: RpcClient);
+    logDebug(message: string, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+    private buildMessage;
+    private toStringArg;
+}
+
+declare function initializeLoggingApi(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcIapApi implements IapApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    getHardCurrencyBalance(): Promise<number>;
+    spendCurrency(productId: string, cost: number, options?: SpendCurrencyOptions): Promise<void>;
+    openStore(): Promise<void>;
+    getCurrencyIcon(): Promise<LoadEmbeddedAssetsResponse>;
+}
+
+declare class MockSharedAssetsApi implements SharedAssetsApi {
+    private readonly rundotGameApi;
+    constructor(rundotGameApi: RundotGameAPI);
+    loadAssetsBundle(game: string, bundleKey: string, fileType?: string): Promise<ArrayBuffer>;
+}
+
+type ModuleSpecifierMatch = 'exact' | 'prefix';
+interface ModuleSpecifierConfig {
+    match: ModuleSpecifierMatch;
+    value: string;
+    behavior?: 'default' | 'react-jsx-runtime' | 'react-jsx-dev-runtime' | 'namespace';
+}
+interface EmbeddedLibraryDefinition {
+    libraryKey: string;
+    assetKey: string;
+    packageName: string;
+    version: string;
+    globalVar: string;
+    cdnPath: string;
+    moduleSpecifiers: ModuleSpecifierConfig[];
+    loadStage: number;
+    enabled: boolean;
+}
+declare const DEFAULT_SHARED_LIB_CDN_BASE = "https://venus-static-01293ak.web.app/libs";
+declare const EMBEDDED_LIBRARIES: EmbeddedLibraryDefinition[];
+declare const EMBEDDED_LIBRARY_BY_KEY: Record<string, EmbeddedLibraryDefinition>;
+declare const MODULE_TO_LIBRARY_SPECIFIERS: {
+    libraryKey: string;
+    match: ModuleSpecifierMatch;
+    value: string;
+    behavior?: "default" | "react-jsx-runtime" | "react-jsx-dev-runtime" | "namespace";
+}[];
+/**
+ * Get library definition by key, throwing if not found.
+ * @param libraryKey - Library key (e.g., 'phaser@3.90.0')
+ * @returns Library definition
+ * @throws Error if library key is not found
+ */
+declare function getLibraryDefinition(libraryKey: string): EmbeddedLibraryDefinition;
+
+/**
+ * Base64 encoding/decoding utilities for embedded assets and libraries.
+ *
+ * These utilities handle base64 data received from the RUN.game host via RPC,
+ * converting it to ArrayBuffer or UTF-8 strings with appropriate fallbacks
+ * for different JavaScript environments.
+ */
+/**
+ * Convert base64 string to ArrayBuffer.
+ * Uses native atob() when available for best performance.
+ */
+declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+/**
+ * Convert base64 string to UTF-8 string.
+ * Tries multiple decoding strategies for maximum compatibility.
+ */
+declare function base64ToUtf8(base64: string): string;
+
+declare class MockIapApi implements IapApi {
+    private _hardCurrency;
+    get hardCurrency(): number;
+    set hardCurrency(value: number);
+    spendCurrency(productId: string, cost: number, options?: SpendCurrencyOptions): Promise<void>;
+    getHardCurrencyBalance(): Promise<number>;
+    openStore(): Promise<void>;
+    getCurrencyIcon(): Promise<LoadEmbeddedAssetsResponse>;
+}
+
+declare function initializeIap(rundotGameApiInstance: RundotGameAPI, host: Host): void;
+
+declare class RpcLeaderboardApi implements LeaderboardApi {
+    private readonly rpcClient;
+    /** Cache of score tokens for automatic hash computation */
+    private tokenCache;
+    constructor(rpcClient: RpcClient);
+    /**
+     * Create a score token for submitting a score.
+     * Token is cached for automatic hash computation if score sealing is enabled.
+     *
+     * @param mode - Optional game mode
+     * @returns Score token with sealing data if enabled
+     */
+    createScoreToken(mode?: string): Promise<ScoreToken>;
+    /**
+     * Submit a score to the leaderboard.
+     * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
+     *
+     * @param params - Score submission parameters
+     * @returns Submission result with acceptance status and rank
+     * @throws Error if token not found in cache
+     */
+    submitScore(params: SubmitScoreParams): Promise<SubmitScoreResult>;
+    getPagedScores(options?: GetPagedScoresOptions): Promise<PagedScoresResponse>;
+    getMyRank(options?: PlayerRankOptions): Promise<PlayerRankResult>;
+    getPodiumScores(options?: GetPodiumScoresOptions): Promise<PodiumScoresResponse>;
+}
+
+declare class MockLeaderboardApi implements LeaderboardApi {
+    private tokens;
+    /** Cache of score tokens for automatic hash computation */
+    private tokenCache;
+    private entriesByMode;
+    private tokenCounter;
+    private enableScoreSealing;
+    private scoreSealingSecret;
+    constructor(options?: {
+        enableScoreSealing?: boolean;
+        scoreSealingSecret?: string;
+    });
+    /**
+     * Configure mock leaderboard settings
+     *
+     * @param options - Configuration options
+     */
+    configure(options: {
+        enableScoreSealing?: boolean;
+        scoreSealingSecret?: string;
+    }): void;
+    private generateNonce;
+    private getModeKey;
+    private getEntriesForMode;
+    /**
+     * Create a mock score token for testing.
+     * Token is cached for automatic hash computation if score sealing is enabled.
+     *
+     * @param mode - Optional game mode
+     * @returns Score token with sealing data if enabled
+     */
+    createScoreToken(mode?: string): Promise<ScoreToken>;
+    /**
+     * Submit a mock score to the leaderboard.
+     * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
+     *
+     * @param params - Score submission parameters
+     * @returns Submission result with acceptance status and rank
+     * @throws Error if token not found in cache or validation fails
+     */
+    submitScore(params: SubmitScoreParams): Promise<SubmitScoreResult>;
+    getPagedScores(options?: GetPagedScoresOptions): Promise<PagedScoresResponse>;
+    getMyRank(_options?: PlayerRankOptions): Promise<PlayerRankResult>;
+    getPodiumScores(options?: GetPodiumScoresOptions): Promise<PodiumScoresResponse>;
+}
+
+/**
+ * Hash algorithm used for score sealing
+ */
+declare const HASH_ALGORITHM_WEB_CRYPTO = "SHA-256";
+declare const HASH_ALGORITHM_NODE = "sha256";
+/**
+ * Compute HMAC-SHA256 hash for score sealing.
+ * Hash always includes: score, duration, token
+ * Matches server-side hash computation exactly.
+ *
+ * @param score - The score value
+ * @param duration - Duration in seconds
+ * @param token - Score token
+ * @param sealingNonce - One-time nonce for this submission
+ * @param sealingSecret - Secret key for HMAC
+ * @returns Hex-encoded hash string
+ */
+declare function computeScoreHash(score: number, duration: number, token: string, sealingNonce: string, sealingSecret: string): Promise<string>;
+
+declare function initializeLeaderboard(rundotGameApiInstance: RundotGameAPI, host: Host): void;
+
+declare class MockPreloaderApi implements PreloaderApi {
+    showLoadScreen(): Promise<void>;
+    hideLoadScreen(): Promise<void>;
+    setLoaderText(text: string): Promise<void>;
+    setLoaderProgress(progress: number): Promise<void>;
+}
+
+declare class RpcPreloaderApi implements PreloaderApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    showLoadScreen(): Promise<void>;
+    hideLoadScreen(): Promise<void>;
+    setLoaderText(text: string): Promise<void>;
+    setLoaderProgress(progress: number): Promise<void>;
+}
+
+declare function initializePreloader(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcSocialApi implements SocialApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    shareLinkAsync(options: {
+        shareParams: Record<string, string>;
+        metadata?: ShareMetadata;
+    }): Promise<ShareLinkResult>;
+    createQRCodeAsync(options: {
+        shareParams: Record<string, string>;
+        metadata?: ShareMetadata;
+        qrOptions?: SocialQRCodeOptions;
+    }): Promise<QRCodeResult>;
+}
+
+declare class MockSocialApi implements SocialApi {
+    shareLinkAsync(options: {
+        shareParams: Record<string, string>;
+    }): Promise<ShareLinkResult>;
+    createQRCodeAsync(options: {
+        shareParams: Record<string, string>;
+        qrOptions?: SocialQRCodeOptions;
+    }): Promise<QRCodeResult>;
+    private createMockUrl;
+}
+
+declare function initializeSocial(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcAvatarApi implements Avatar3dApi {
+    private readonly rundotGameApi;
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient, rundotGameApi: RundotGameAPI);
+    downloadAssetPaths(): Promise<Record<string, string[]>>;
+    downloadManifest(): Promise<AssetManifest>;
+    loadAvatar(avatarId?: string): Promise<Avatar3dConfig | null>;
+    saveAvatar(config: Avatar3dConfig): Promise<string>;
+    deleteAvatar(): Promise<void>;
+    showEditor(options?: ShowEditorOptions): Promise<Avatar3dEdits>;
+    private fetchFromCdn;
+    private log;
+}
+
+declare function initializeAvatar3d(rundotGameApi: RundotGameAPI, host: Host): void;
+
+declare class RpcAdsApi implements AdsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    showInterstitialAd(options?: ShowInterstitialAdOptions): Promise<boolean>;
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    showRewardedAdAsync(options?: ShowRewardedAdOptions): Promise<boolean>;
+}
+
+declare class MockAdsApi implements AdsApi {
+    private mockOverlay;
+    constructor(mockOverlay: MockOverlay);
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    showRewardedAdAsync(options?: ShowRewardedAdOptions): Promise<boolean>;
+    showInterstitialAd(options?: ShowInterstitialAdOptions): Promise<boolean>;
+    private log;
+}
+
+declare function initializeAds(rundotGameApiInstance: RundotGameAPI, host: Host): void;
+
+/**
+ * HTTP wrapper for calling Cloud Functions.
+ *
+ * Gets the ID token from Firebase Auth (user signs in once via Google).
+ * Token is refreshed automatically by Firebase SDK.
+ *
+ * @example
+ * ```typescript
+ * const state = await callRemoteFunction<SimulationState>('apiGetSimulationState', {
+ *   appId: 'my-game',
+ * })
+ * ```
+ *
+ * ⚠️ SANDBOX-ONLY: This file depends on Firebase and should ONLY be imported by SandboxHost
+ * and other sandbox-only modules. Do NOT import from barrel exports (http/index.ts).
+ * This ensures Firebase is not bundled in production builds.
+ */
+/**
+ * Type for a function that invokes a remote Cloud Function.
+ */
+type RemoteFunctionInvoker = <TResponse>(functionName: string, payload?: unknown) => Promise<TResponse>;
+
+declare const SDK_VERSION: string;
+
+declare enum RundotGameMessageId {
+    H5_RESPONSE = "H5_RESPONSE",
+    IS_REWARDED_AD_READY = "H5_IS_REWARDED_AD_READY",
+    SHOW_REWARDED_AD = "H5_SHOW_REWARDED_AD",
+    LOG_ANALYTICS_EVENT = "H5_LOG_ANALYTICS_EVENT",
+    TRACK_FUNNEL_STEP = "H5_TRACK_FUNNEL_STEP",
+    DEVICE_CACHE_GET_ITEM = "H5_DEVICE_CACHE_GET_ITEM",
+    DEVICE_CACHE_SET_ITEM = "H5_DEVICE_CACHE_SET_ITEM",
+    DEVICE_CACHE_REMOVE_ITEM = "H5_DEVICE_CACHE_REMOVE_ITEM",
+    DEVICE_CACHE_CLEAR = "H5_DEVICE_CACHE_CLEAR",
+    DEVICE_CACHE_KEY = "H5_DEVICE_CACHE_KEY",
+    DEVICE_CACHE_LENGTH = "H5_DEVICE_CACHE_LENGTH",
+    APP_STORAGE_GET_ITEM = "H5_APP_STORAGE_GET_ITEM",
+    APP_STORAGE_SET_ITEM = "H5_APP_STORAGE_SET_ITEM",
+    APP_STORAGE_REMOVE_ITEM = "H5_APP_STORAGE_REMOVE_ITEM",
+    APP_STORAGE_CLEAR = "H5_APP_STORAGE_CLEAR",
+    APP_STORAGE_KEY = "H5_APP_STORAGE_KEY",
+    APP_STORAGE_LENGTH = "H5_APP_STORAGE_LENGTH",
+    APP_STORAGE_GET_ALL_ITEMS = "H5_APP_STORAGE_GET_ALL_ITEMS",
+    APP_STORAGE_SET_MULTIPLE_ITEMS = "H5_APP_STORAGE_SET_MULTIPLE_ITEMS",
+    APP_STORAGE_REMOVE_MULTIPLE_ITEMS = "H5_APP_STORAGE_REMOVE_MULTIPLE_ITEMS",
+    GLOBAL_STORAGE_GET_ITEM = "H5_GLOBAL_STORAGE_GET_ITEM",
+    GLOBAL_STORAGE_SET_ITEM = "H5_GLOBAL_STORAGE_SET_ITEM",
+    GLOBAL_STORAGE_REMOVE_ITEM = "H5_GLOBAL_STORAGE_REMOVE_ITEM",
+    GLOBAL_STORAGE_CLEAR = "H5_GLOBAL_STORAGE_CLEAR",
+    GLOBAL_STORAGE_KEY = "H5_GLOBAL_STORAGE_KEY",
+    GLOBAL_STORAGE_LENGTH = "H5_GLOBAL_STORAGE_LENGTH",
+    GLOBAL_STORAGE_GET_ALL_ITEMS = "H5_GLOBAL_STORAGE_GET_ALL_ITEMS",
+    GLOBAL_STORAGE_SET_MULTIPLE_ITEMS = "H5_GLOBAL_STORAGE_SET_MULTIPLE_ITEMS",
+    GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS = "H5_GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS",
+    AVATAR3D_LOAD = "H5_AVATAR3D_LOAD",
+    AVATAR3D_SAVE = "H5_AVATAR3D_SAVE",
+    AVATAR3D_DELETE = "H5_AVATAR3D_DELETE",
+    H5_STACK_PUSH_REQUEST = "H5_STACK_PUSH_REQUEST",
+    H5_STACK_POP_REQUEST = "H5_STACK_POP_REQUEST",
+    SCHEDULE_LOCAL_NOTIFICATION = "H5_SCHEDULE_LOCAL_NOTIFICATION",
+    CANCEL_LOCAL_NOTIFICATION = "H5_CANCEL_LOCAL_NOTIFICATION",
+    GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS = "H5_GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS",
+    IS_LOCAL_NOTIFICATIONS_ENABLED = "H5_IS_LOCAL_NOTIFICATIONS_ENABLED",
+    SET_LOCAL_NOTIFICATIONS_ENABLED = "H5_SET_LOCAL_NOTIFICATIONS_ENABLED",
+    TOAST = "H5_TOAST",
+    REQUEST_SERVER_TIME = "H5_REQUEST_SERVER_TIME",
+    SHARE_LINK = "H5_SHARE_LINK",
+    CREATE_SHARE_QRCODE = "H5_CREATE_SHARE_QRCODE",
+    AI_CHAT_COMPLETION = "H5_AI_CHAT_COMPLETION",
+    AI_GET_AVAILABLE_MODELS = "H5_AI_GET_AVAILABLE_MODELS",
+    TRIGGER_HAPTIC = "H5_TRIGGER_HAPTIC",
+    DEBUG = "H5_DEBUG",
+    H5_IAP_GET_WALLET = "H5_IAP_GET_WALLET",
+    H5_IAP_SPEND_CURRENCY = "H5_IAP_SPEND_CURRENCY",
+    SHOW_INTERSTITIAL_AD = "H5_SHOW_INTERSTITIAL_AD",
+    IAP_SPEND_CURRENCY_COMPLETE = "IAP_SPEND_CURRENCY_COMPLETE",
+    IAP_WALLET_UPDATE = "IAP_WALLET_UPDATE",
+    READY = "READY",
+    INIT_SDK = "INITIALIZE_SDK",
+    PAUSE = "PAUSE",
+    RESUME = "RESUME",
+    AWAKE = "AWAKE",
+    SLEEP = "SLEEP",
+    QUIT = "QUIT",
+    /** given the experiment name, returns the entire experiment object as configured for the current user */
+    GET_EXPERIMENT = "H5_GET_EXPERIMENT",
+    /** returns the boolean value for a feature flag using the statsig parameter store, or the feature flags constants as fallback */
+    GET_FEATURE_FLAG = "H5_GET_FEATURE_FLAG",
+    /** returns the gate value (boolean) for a given feature gate for the current user */
+    GET_FEATURE_GATE = "H5_GET_FEATURE_GATE",
+    H5_SIMULATION_EXECUTE_RECIPE = "H5_SIMULATION_EXECUTE_RECIPE",
+    H5_SIMULATION_GET_ACTIVE_RUNS = "H5_SIMULATION_GET_ACTIVE_RUNS",
+    H5_SIMULATION_COLLECT_RECIPE = "H5_SIMULATION_COLLECT_RECIPE",
+    H5_SIMULATION_EXECUTE_SCOPED_RECIPE = "H5_SIMULATION_EXECUTE_SCOPED_RECIPE",
+    H5_SIMULATION_GET_AVAILABLE_RECIPES = "H5_SIMULATION_GET_AVAILABLE_RECIPES",
+    H5_SIMULATION_GET_RECIPE_REQUIREMENTS = "H5_SIMULATION_GET_RECIPE_REQUIREMENTS",
+    H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS = "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS",
+    H5_SIMULATION_TRIGGER_RECIPE_CHAIN = "H5_SIMULATION_TRIGGER_RECIPE_CHAIN",
+    H5_SIMULATION_RESOLVE_VALUE = "H5_SIMULATION_RESOLVE_VALUE",
+    H5_SIMULATION_GET_ENTITY_METADATA = "H5_SIMULATION_GET_ENTITY_METADATA",
+    H5_SIMULATION_GET_STATE = "H5_SIMULATION_GET_STATE",
+    H5_SIMULATION_GET_CONFIG = "H5_SIMULATION_GET_CONFIG",
+    H5_SIMULATION_GET_CONTAINERS = "H5_SIMULATION_GET_CONTAINERS",
+    H5_SIMULATION_GET_ASSIGNMENTS = "H5_SIMULATION_GET_ASSIGNMENTS",
+    H5_SIMULATION_ASSIGN_ITEM = "H5_SIMULATION_ASSIGN_ITEM",
+    H5_SIMULATION_REMOVE_ITEM = "H5_SIMULATION_REMOVE_ITEM",
+    H5_SIMULATION_CALCULATE_POWER_PREVIEW = "H5_SIMULATION_CALCULATE_POWER_PREVIEW",
+    H5_SIMULATION_GET_AVAILABLE_ITEMS = "H5_SIMULATION_GET_AVAILABLE_ITEMS",
+    H5_SIMULATION_VALIDATE_ASSIGNMENT = "H5_SIMULATION_VALIDATE_ASSIGNMENT",
+    H5_SIMULATION_BATCH_OPERATIONS = "H5_SIMULATION_BATCH_OPERATIONS",
+    H5_SIMULATION_SUBSCRIBE = "H5_SIMULATION_SUBSCRIBE",
+    H5_SIMULATION_UNSUBSCRIBE = "H5_SIMULATION_UNSUBSCRIBE",
+    H5_SIMULATION_UPDATE = "H5_SIMULATION_UPDATE",
+    H5_SIMULATION_RESET_STATE = "H5_SIMULATION_RESET_STATE",
+    H5_LEADERBOARD_CREATE_SCORE_TOKEN = "H5_LEADERBOARD_CREATE_SCORE_TOKEN",
+    H5_LEADERBOARD_SUBMIT_SCORE = "H5_LEADERBOARD_SUBMIT_SCORE",
+    H5_LEADERBOARD_GET_PAGED_SCORES = "H5_LEADERBOARD_GET_PAGED_SCORES",
+    H5_LEADERBOARD_GET_PODIUM_SCORES = "H5_LEADERBOARD_GET_PODIUM_SCORES",
+    H5_LEADERBOARD_GET_MY_RANK = "H5_LEADERBOARD_GET_MY_RANK",
+    H5_ROOM_CREATE = "H5_ROOM_CREATE",
+    H5_ROOM_JOIN = "H5_ROOM_JOIN",
+    H5_ROOM_JOIN_OR_CREATE = "H5_ROOM_JOIN_OR_CREATE",
+    H5_ROOM_LEAVE = "H5_ROOM_LEAVE",
+    H5_ROOM_UPDATE_DATA = "H5_ROOM_UPDATE_DATA",
+    H5_ROOM_GET_DATA = "H5_ROOM_GET_DATA",
+    H5_ROOM_SUBSCRIBE = "H5_ROOM_SUBSCRIBE",
+    H5_ROOM_UNSUBSCRIBE = "H5_ROOM_UNSUBSCRIBE",
+    H5_ROOM_SEND_MESSAGE = "H5_ROOM_SEND_MESSAGE",
+    H5_ROOM_GET_MESSAGES = "H5_ROOM_GET_MESSAGES",
+    H5_ROOM_LIST_ROOMS = "H5_ROOM_LIST_ROOMS",
+    H5_ROOM_LIST_PUBLIC = "H5_ROOM_LIST_PUBLIC",
+    H5_ROOM_SEARCH = "H5_ROOM_SEARCH",
+    H5_ROOM_JOIN_BY_CODE = "H5_ROOM_JOIN_BY_CODE",
+    H5_ROOM_GET_USER_ROOMS = "H5_ROOM_GET_USER_ROOMS",
+    H5_ROOM_GET_PLAYERS = "H5_ROOM_GET_PLAYERS",
+    H5_ROOM_UPDATE_PLAYER_DATA = "H5_ROOM_UPDATE_PLAYER_DATA",
+    H5_ROOM_START_GAME = "H5_ROOM_START_GAME",
+    H5_ROOM_PROPOSE_MOVE = "h5:room:proposeMove",
+    H5_ROOM_END_GAME = "H5_ROOM_END_GAME",
+    H5_ROOM_KICK_PLAYER = "H5_ROOM_KICK_PLAYER",
+    H5_ROOM_PROMOTE_TO_SPECTATOR = "H5_ROOM_PROMOTE_TO_SPECTATOR",
+    H5_LOAD_EMBEDDED_ASSET = "H5_LOAD_EMBEDDED_ASSET",
+    H5_SHOW_LOAD_SCREEN = "H5_SHOW_LOAD_SCREEN",
+    H5_HIDE_LOAD_SCREEN = "H5_HIDE_LOAD_SCREEN",
+    H5_SET_LOADER_TEXT = "H5_SET_LOADER_TEXT",
+    H5_SET_LOADER_PROGRESS = "H5_SET_LOADER_PROGRESS",
+    H5_IAP_OPEN_STORE = "H5_IAP_OPEN_STORE",
+    H5_IAP_GET_CURRENCY_ICON = "H5_IAP_GET_CURRENCY_ICON"
+}
+
+declare class RemoteHost implements Host {
+    readonly ads: AdsApi;
+    readonly analytics: AnalyticsApi;
+    readonly deviceCache: StorageApi;
+    readonly appStorage: StorageApi;
+    readonly globalStorage: StorageApi;
+    readonly avatar3d: Avatar3dApi;
+    readonly navigation: NavigationApi;
+    readonly notifications: NotificationsApi;
+    readonly popups: PopupsApi;
+    readonly profile: ProfileApi;
+    readonly system: SystemApi;
+    readonly cdn: CdnApi;
+    readonly time: TimeApi;
+    readonly ai: AiApi;
+    readonly haptics: HapticsApi;
+    readonly features: FeaturesApi;
+    readonly lifecycle: LifecycleApi;
+    readonly simulation: SimulationApi;
+    readonly rooms: RoomsApi;
+    readonly logging: LoggingApi;
+    readonly iap: IapApi;
+    readonly leaderboard: LeaderboardApi;
+    readonly preloader: PreloaderApi;
+    readonly social: SocialApi;
+    context?: InitializationContext;
+    get isInitialized(): boolean;
+    private readonly rundotGameApi;
+    private readonly rpcClient;
+    private _isInitialized;
+    constructor(rundotGameApi: RundotGameAPI);
+    initialize(options?: InitializationOptions): Promise<InitializationContext>;
+    private log;
+}
+interface InitResponse {
+    initializeAsleep: boolean;
+    instanceId: string;
+    profile: {
+        id: string;
+        username: string;
+        avatarUrl?: string | null;
+        isAnonymous?: boolean;
+    };
+    safeArea?: SafeArea;
+    launchParams: Record<string, string>;
+    shareParams: Record<string, string>;
+    environment: EnvironmentInfo;
+    device: DeviceInfo;
+    locale: string;
+    languageCode: string;
+    rooms?: {
+        gameType?: string;
+        rulesPreset?: string;
+        matchmaking?: Record<string, any>;
+        createOptions?: Record<string, any>;
+        privateMatchDefaults?: Record<string, any>;
+        [key: string]: any;
+    };
+}
+
+export { AdsApi, AiApi, AiChatCompletionData, AiChatCompletionRequest, AnalyticsApi, AssetManifest, Avatar3dApi, Avatar3dConfig, Avatar3dEdits, AwakeCallback, BaseCdnApi, CdnApi, CollectRecipeResult, CreateRoomOptions, DEFAULT_SHARED_LIB_CDN_BASE, DeviceApi, DeviceInfo, EMBEDDED_LIBRARIES, EMBEDDED_LIBRARY_BY_KEY, type EmbeddedLibraryDefinition, EnvironmentApi, EnvironmentInfo, ExecuteRecipeOptions, ExecuteRecipeResponse, ExecuteScopedRecipeOptions, ExecuteScopedRecipeResult, Experiment, FeaturesApi, FetchFromCdnOptions, GetActiveRunsOptions, GetAvailableRecipesOptions, GetAvailableRecipesResult, GetBatchRecipeRequirements, GetFutureTimeOptions, GetPagedScoresOptions, GetPodiumScoresOptions, HASH_ALGORITHM_NODE, HASH_ALGORITHM_WEB_CRYPTO, HapticFeedbackStyle, HapticsApi, Host, HostCdnApi, HostDeviceApi, HostEnvironmentApi, HostProfileApi, HostSystemApi, HostTimeApi, IapApi, type InitResponse, InitializationContext, InitializationOptions, JoinOrCreateResult, JoinOrCreateRoomOptions, LeaderboardApi, LifecycleApi, ListRoomsOptions, LoadEmbeddedAssetsResponse, LoggingApi, MODULE_TO_LIBRARY_SPECIFIERS, type MethodIds, MockAdsApi, MockAiApi, MockAnalyticsApi, MockCdnApi, MockDeviceApi, MockEnvironmentApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLeaderboardApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockPreloaderApi, MockProfileApi, MockSharedAssetsApi, MockSocialApi, MockStorageApi, MockSystemApi, MockTimeApi, type ModuleSpecifierConfig, type ModuleSpecifierMatch, NavigationApi, NavigationStackInfo, type NotificationContent, NotificationsApi, PagedScoresResponse, PauseCallback, PlayerRankOptions, PlayerRankResult, PodiumScoresResponse, PopupsApi, PreloaderApi, ProfileApi, ProposeMoveRequest, ProposeMoveResult, ProposedMoveEvent, PushAppOptions, QRCodeResult, QuitCallback, QuitOptions, Recipe, type RemoteFunctionInvoker, RemoteHost, ResetStateOptions, ResetStateResult, ResumeCallback, RoomDataUpdate, RoomMessageEvent, RoomMessageRequest, type RoomNotificationSubscriptionState, RoomSubscriptionOptions, RoomsApi, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLeaderboardApi, RpcLifecycleApi, RpcLoggingApi, type RpcMessage, RpcNavigationApi, RpcNotification, RpcNotificationsApi, RpcPopupsApi, RpcPreloaderApi, RpcRequest, RpcResponse, RpcRoomsApi, RpcSimulationApi, RpcSocialApi, RpcStorageApi, RundotGameMessageId, RundotGameRoom, SDK_VERSION, SafeArea, SandboxProfileApi, ScheduleLocalNotification, ScheduleNotificationOptions, ScoreToken, ServerTimeData, ShareLinkResult, ShareMetadata, SharedAssetsApi, ShowEditorOptions, ShowInterstitialAdOptions, ShowRewardedAdOptions, ShowToastOptions, type ShowToastResponse, SimulationApi, SimulationAssignment, SimulationAvailableItem, SimulationBatchOperation, SimulationBatchOperationsResult, SimulationPowerPreview, SimulationRunSummary, SimulationSlotContainer, SimulationSlotMutationResult, SimulationSlotValidationResult, SimulationState, SleepCallback, SocialApi, SocialQRCodeOptions, SpendCurrencyOptions, StartRoomGameOptions, StorageApi, type StorageType, SubmitScoreParams, SubmitScoreResult, Subscription, SystemApi, TimeApi, TriggerRecipeChainOptions, UpdateRoomDataOptions, ValidateMoveResult, ValidateMoveVerdict, base64ToArrayBuffer, base64ToUtf8, computeScoreHash, createMockStorageApi, getLibraryDefinition, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLeaderboard, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializePreloader, initializeProfile, initializeRoomsApi, initializeSimulation, initializeSocial, initializeStackNavigation, initializeStorage, initializeSystem, initializeTime, isPacificDaylightTime, setupRoomNotifications };