@series-inc/rundot-game-sdk 5.0.0

package/dist/AdsApi-B_d_w_jB.d.ts

@@ -0,0 +1,1667 @@
+interface AnalyticsApi {
+    recordCustomEvent(eventName: string, payload?: Record<string, any>): Promise<void>;
+    trackFunnelStep(stepNumber: number, stepName: string, funnelName?: string): Promise<void>;
+}
+
+interface RpcRequest {
+    type: 'rpc-request';
+    id: string;
+    method: string;
+    args?: any[];
+}
+
+interface RpcResponse {
+    type: 'rpc-response';
+    id: string;
+    method: string;
+    result?: any;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+}
+
+interface RpcNotification {
+    type: 'rpc-notification';
+    id: string;
+    payload?: any;
+}
+
+type OnRequestCallback = (request: RpcRequest) => Promise<boolean>;
+type OnResponseCallback = (response: RpcResponse) => Promise<boolean>;
+type OnNotificationCallback = (notification: RpcNotification) => void;
+interface RpcTransport {
+    onRequest(callback: OnRequestCallback): Subscription;
+    onResponse(callback: OnResponseCallback): Subscription;
+    onNotification(callback: OnNotificationCallback): Subscription;
+    sendRequest(request: RpcRequest): void;
+    sendResponse(response: RpcResponse): void;
+}
+
+interface Subscription {
+    unsubscribe: () => void;
+}
+declare class RpcClient {
+    private readonly pendingCalls;
+    private readonly notificationCallbacks;
+    private onResponseSub;
+    private onNotificationSub;
+    private transport;
+    start(transport: RpcTransport): void;
+    stop(): void;
+    onNotification<TPayload>(id: string, callback: (payload: TPayload) => void): Subscription;
+    callT<TArgs, TResult>(method: string, args: TArgs, timeout?: number): Promise<TResult>;
+    call<TResponse>(method: string, args?: any, timeout?: number): Promise<TResponse>;
+    private hasPendingCall;
+    private addPendingCall;
+    private removePendingCall;
+    private getPendingCall;
+    private handleRpcResponse;
+    private handleRpcNotification;
+}
+
+interface StorageApi {
+    key(index: number): Promise<string | null>;
+    clear(): Promise<void>;
+    length(): Promise<number>;
+    getAllItems(): Promise<string[]>;
+    getAllData(): Promise<Record<string, string>>;
+    setMultipleItems(items: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+    removeMultipleItems(keys: string[]): Promise<void>;
+    setItem(key: string, item: string): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+}
+
+interface NavigationStackInfo {
+    isInStack: boolean;
+    stackPosition: number;
+    isTopOfStack: boolean;
+    stackDepth: number;
+    parentInstanceId: string;
+}
+interface PushAppOptions {
+    contextData?: any;
+    appParams?: any;
+}
+interface QuitOptions {
+    reason?: string;
+    forceClose?: boolean;
+    [key: string]: any;
+}
+interface NavigationApi {
+    pushApp(appId: string, options?: PushAppOptions): Promise<void>;
+    popApp(): Promise<void>;
+    getStackInfo(): NavigationStackInfo;
+    requestPopOrQuit(options?: QuitOptions): Promise<boolean>;
+}
+
+type TimeIntervalTriggerInput = {
+    type: 'timeInterval';
+    seconds: number;
+    repeats?: boolean;
+    channelId?: string;
+};
+type NotificationTriggerInput = TimeIntervalTriggerInput | null;
+interface ScheduleNotificationOptions {
+    priority?: number;
+    groupId?: string;
+    payload?: Record<string, any>;
+}
+interface ScheduleLocalNotification {
+    id: string;
+    title?: string | null;
+    body?: string | null;
+    payload?: Record<string, any>;
+    trigger?: NotificationTriggerInput;
+}
+interface NotificationsApi {
+    scheduleAsync(title: string, body: string, seconds: number, notificationId?: string, options?: ScheduleNotificationOptions): Promise<string | null>;
+    cancelNotification(notificationId: string): Promise<boolean>;
+    getAllScheduledLocalNotifications(): Promise<ScheduleLocalNotification[]>;
+    isLocalNotificationsEnabled(): Promise<boolean>;
+    setLocalNotificationsEnabled(enabled: boolean): Promise<boolean>;
+}
+
+interface ShowToastOptions {
+    duration?: number;
+    variant?: 'success' | 'error' | 'warning' | 'info';
+    action?: {
+        label: string;
+    };
+}
+interface PopupsApi {
+    showToast(message: string, options?: ShowToastOptions): Promise<boolean>;
+}
+
+interface ProfileApi {
+    getCurrentProfile(): Profile;
+}
+
+interface DeviceInfo {
+    readonly screenSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly viewportSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly orientation: string;
+    readonly pixelRatio: number;
+    readonly fontScale: number;
+    readonly deviceType: string;
+    readonly hapticsEnabled: boolean;
+    readonly haptics: {
+        readonly supported: boolean;
+        readonly enabled: boolean;
+    };
+}
+interface DeviceApi {
+    getDevice(): DeviceInfo;
+}
+
+interface EnvironmentInfo {
+    readonly isDevelopment: boolean;
+    readonly platform: string;
+    readonly platformVersion: string;
+    readonly browserInfo?: {
+        readonly browser: string;
+        readonly userAgent: string;
+        readonly isMobile: boolean;
+        readonly isTablet: boolean;
+        readonly language: string;
+    };
+}
+interface EnvironmentApi {
+    getEnvironment(): EnvironmentInfo;
+}
+
+/**
+ * System API provides access to device and environment information.
+ * This is a unified namespace for system-level configuration data.
+ */
+interface SystemApi {
+    /**
+     * Get device information (screen size, orientation, capabilities, etc.)
+     * @throws Error if called before RundotGameAPI.initializeAsync() completes
+     */
+    getDevice(): DeviceInfo;
+    /**
+     * Get environment information (platform, browser, development mode, etc.)
+     * @throws Error if called before RundotGameAPI.initializeAsync() completes
+     */
+    getEnvironment(): EnvironmentInfo;
+    /**
+     * Get safe area insets (padding to avoid device notches and host UI).
+     * This includes the toolbar/feedHeader height plus device safe areas.
+     * Safe area is static - it's set once during initialization and doesn't change.
+     * @returns SafeArea with top, right, bottom, left padding values in pixels
+     * @throws Error if called before RundotGameAPI.initializeAsync() completes
+     */
+    getSafeArea(): SafeArea;
+    /**
+     * Check if running on mobile device
+     * @returns true if on mobile device (iOS, Android, or mobile browser)
+     */
+    isMobile(): boolean;
+    /**
+     * Check if running on web platform
+     * @returns true if on web platform
+     */
+    isWeb(): boolean;
+}
+
+type SubPath = string;
+interface FetchFromCdnOptions {
+    timeout?: number;
+}
+interface CdnApi {
+    resolveAssetUrl(subPath: string): string;
+    resolveAvatarAssetUrl(subPath: string): string;
+    resolveSharedLibUrl(subPath: string): string;
+    getAssetCdnBaseUrl(): string;
+    fetchAsset(assetPath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+    fetchFromCdn(subPath: string, options?: FetchFromCdnOptions): Promise<Blob>;
+}
+
+interface ServerTimeData {
+    serverTime: number;
+    localTime: number;
+    timezoneOffset: number;
+    formattedTime: string;
+    locale: string;
+}
+interface GetFutureTimeOptions {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    timeOfDay?: {
+        hour: number;
+        minute: number;
+        second: number;
+    };
+    timezone?: any;
+}
+interface TimeApi {
+    requestTimeAsync(): Promise<ServerTimeData>;
+    formatTime(timestamp: number, options?: any): string;
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    getFutureTimeAsync(options?: GetFutureTimeOptions): Promise<number>;
+}
+
+interface AiMessage {
+    /**
+     * Depends on the model you are using. Most common is user, system, and assistant.
+     * If you are unsure, look up the specific model you are using.
+     */
+    role: string;
+    content: string;
+}
+type AiChatCompletionRequest = {
+    model: string;
+    messages?: Array<AiMessage>;
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    n?: number;
+    stop?: string | string[];
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    logitBias?: Record<string, number>;
+    seed?: number;
+    /**
+     * This is ONLY ever used when running the sdk outside of RUN.game.
+     * This gets ignored when the game using the sdk is used within a RUN.game instance.
+     *
+     * In other words, this should only be uswed when developing a game locally.
+     */
+    apiKey?: string;
+};
+type AiChatCompletionData = {
+    id: string;
+    ullm_id: string;
+    cost: {
+        prompt_cost: number;
+        completion_cost: number;
+    };
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: string;
+            content: string;
+        };
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        reasoning_tokens?: number;
+        cache_read_tokens?: number;
+        cache_write_tokens?: number;
+    };
+};
+interface AiApi {
+    requestChatCompletionAsync(request: AiChatCompletionRequest): Promise<AiChatCompletionData>;
+    getAvailableCompletionModels(): Promise<Array<string>>;
+}
+
+declare enum HapticFeedbackStyle {
+    Light = "light",
+    Medium = "medium",
+    Heavy = "heavy",
+    Success = "success",
+    Warning = "warning",
+    Error = "error"
+}
+interface HapticsApi {
+    triggerHapticAsync(style: HapticFeedbackStyle): Promise<void>;
+}
+
+interface Experiment {
+    readonly name: string;
+    readonly ruleID: string;
+    readonly value: Record<string, unknown>;
+    readonly groupName: string | null;
+}
+interface FeaturesApi {
+    getExperiment(experimentName: string): Promise<Experiment | null>;
+    getFeatureFlag(flagName: string): Promise<boolean>;
+    getFeatureGate(gateName: string): Promise<boolean>;
+}
+
+type AwakeCallback = () => void;
+type SleepCallback = () => void;
+type ResumeCallback = () => void;
+type PauseCallback = () => void;
+type QuitCallback = () => void;
+interface LifecycleApi {
+    /**
+     * Registers a callback for when the game transitions from "idle" to "active" state.
+     *
+     * This occurs when the game comes to the foreground. Use this to load heavy resources
+     * or resume activities that were paused during sleep.
+     *
+     * @param callback - Function to execute when the game awakens
+     * @returns Subscription object that can be used to unsubscribe from the event
+     */
+    onAwake(callback: AwakeCallback): Subscription;
+    /**
+     * Registers a callback for when the game transitions from "active" to "idle" state.
+     *
+     * This occurs when the game goes to the background. Use this to unload heavy resources,
+     * save state, or pause non-essential activities.
+     *
+     * @param callback - Function to execute when the game goes to sleep
+     * @returns Subscription object that can be used to unsubscribe from the event
+     */
+    onSleep(callback: SleepCallback): Subscription;
+    /**
+     * Registers a callback for when gameplay should resume.
+     *
+     * This occurs when the platform dismisses dialogs or overlays, or when players
+     * return from a temporary switch. Use this to resume game logic and animations.
+     *
+     * @param callback - Function to execute when gameplay resumes
+     * @returns Subscription object that can be used to unsubscribe from the event
+     */
+    onResume(callback: ResumeCallback): Subscription;
+    /**
+     * Registers a callback for when gameplay should pause.
+     *
+     * This occurs when the platform brings up dialogs or overlays, or when players
+     * temporarily switch away. Use this to pause game logic and animations.
+     *
+     * @param callback - Function to execute when gameplay pauses
+     * @returns Subscription object that can be used to unsubscribe from the event
+     */
+    onPause(callback: PauseCallback): Subscription;
+    /**
+     * Registers a callback for final teardown before the game instance is destroyed.
+     *
+     * This is the last chance to clean up resources, save state, and perform any
+     * necessary cleanup before the game instance is destroyed or replaced.
+     *
+     * @param callback - Function to execute during cleanup
+     * @returns Subscription object that can be used to unsubscribe from the event
+     */
+    onQuit(callback: QuitCallback): Subscription;
+}
+
+interface ExecuteRecipeOptions {
+    roomId?: string;
+    batchAmount?: number;
+    allowPartialBatch?: boolean;
+    entity?: string;
+}
+interface GetActiveRunsOptions {
+    roomId?: string;
+}
+interface ExecuteScopedRecipeOptions {
+    roomId?: string;
+}
+interface GetAvailableRecipesOptions {
+    roomId?: string;
+    includeActorRecipes?: boolean;
+}
+interface Recipe {
+    recipeId: string;
+    entity?: string;
+    batchAmount?: number;
+}
+interface TriggerRecipeChainOptions {
+    roomId?: string;
+    context?: Record<string, unknown>;
+}
+interface CollectRecipeResult {
+    success: boolean;
+    runId: string;
+    rewards: Record<string, unknown>;
+    message: string;
+}
+interface ExecuteScopedRecipeResult {
+    success: boolean;
+    message: string;
+}
+interface RecipeInfo {
+    id: string;
+    scope: string;
+    clientViewable: boolean;
+}
+interface GetAvailableRecipesResult {
+    success: boolean;
+    recipes: RecipeInfo[];
+}
+interface GetBatchRecipeRequirements {
+    success: boolean;
+    results: RecipeRequirementResult[];
+}
+interface SimulationPersonalState {
+    entities: Record<string, number | string>;
+    activeRuns: SimulationRunSummary[];
+    disabledRecipes: string[];
+}
+interface SimulationRoomActiveRecipe {
+    recipeId: string;
+    scope: 'room' | 'actor';
+    startedAt: number;
+    expiresAt: number;
+    commitmentEndsAt?: number;
+}
+interface SimulationRoomState {
+    activeRecipes: Record<string, SimulationRoomActiveRecipe>;
+    sharedAssets: Record<string, number | string>;
+    actors: Array<Record<string, unknown>>;
+    activeRuns: SimulationRunSummary[];
+}
+type SimulationState = SimulationPersonalState | SimulationRoomState;
+interface SimulationSlotContainer {
+    entityId: string;
+    slots: Record<string, unknown>;
+    isOwned: boolean;
+    powerCalculationRecipe?: string;
+}
+interface SimulationAvailableItem {
+    entityId: string;
+    quantity: number;
+    metadata: Record<string, unknown>;
+    tags: string[];
+    isCompatible: boolean;
+}
+interface SimulationSlotValidationResult {
+    valid: boolean;
+    error?: string;
+}
+interface SimulationAssignment {
+    id: string;
+    containerId: string;
+    slotId: string;
+    itemId: string | null;
+    profileId: string;
+    appId: string;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+interface SimulationSlotMutationResult {
+    success: boolean;
+    error?: string;
+    association?: SimulationAssignment;
+}
+interface SimulationBatchOperationAssign {
+    type: 'assign';
+    containerId: string;
+    slotId: string;
+    itemId: string;
+}
+interface SimulationBatchOperationRemove {
+    type: 'remove';
+    containerId: string;
+    slotId: string;
+    itemId?: string;
+}
+type SimulationBatchOperation = SimulationBatchOperationAssign | SimulationBatchOperationRemove;
+interface SimulationBatchOperationResult {
+    success: boolean;
+    error?: string;
+    association?: SimulationAssignment;
+    operation: SimulationBatchOperation;
+}
+interface SimulationBatchOperationsResult {
+    success: boolean;
+    results: SimulationBatchOperationResult[];
+    affectedContainers: string[];
+}
+interface SimulationPowerPreview {
+    currentPower: number;
+    previewPower: number;
+    powerDelta: number;
+    breakdown: Record<string, number>;
+}
+interface ResetStateOptions {
+    /** Optional recipe to run after reset (overrides lifecycle.onReset) */
+    initializeRecipe?: string;
+}
+interface ResetStateResult {
+    success: boolean;
+    /** Number of active runs that were cancelled */
+    clearedRuns: number;
+    /** Number of slot assignments that were deleted */
+    clearedSlots: number;
+    /** Recipe that was executed after reset (if any) */
+    recipeExecuted: string | null;
+}
+interface ExecuteRecipeResponse {
+    success: boolean;
+    status?: string;
+    runId?: string;
+    expiresAt?: string;
+    queuePosition?: number;
+    outputs?: Record<string, number | string>;
+    data?: Record<string, unknown>;
+    message?: string;
+    amountRequested?: number;
+    amountFulfilled?: number;
+    partialSuccess?: boolean;
+}
+interface SimulationApi {
+    isEnabled(): boolean;
+    getStateAsync(roomId?: string): Promise<SimulationState>;
+    getConfigAsync(roomId?: string): Promise<RundotGameSimulationConfig>;
+    executeRecipeAsync(recipeId: string, inputs?: Record<string, unknown>, options?: ExecuteRecipeOptions): Promise<ExecuteRecipeResponse>;
+    getActiveRunsAsync(options?: GetActiveRunsOptions): Promise<SimulationRunSummary[]>;
+    collectRecipeAsync(runId: string): Promise<CollectRecipeResult>;
+    executeScopedRecipeAsync(recipeId: string, entity: string, inputs?: Record<string, unknown>, options?: ExecuteScopedRecipeOptions): Promise<ExecuteScopedRecipeResult>;
+    triggerRecipeChainAsync(recipeId: string, options?: TriggerRecipeChainOptions): Promise<ExecuteRecipeResponse>;
+    getAvailableRecipesAsync(options?: GetAvailableRecipesOptions): Promise<GetAvailableRecipesResult>;
+    getRecipeRequirementsAsync(recipe: Recipe): Promise<RecipeRequirementResult>;
+    getBatchRecipeRequirementsAsync(recipes: Recipe[]): Promise<GetBatchRecipeRequirements>;
+    resolveFieldValueAsync(entityId: string, fieldPath: string, entity?: string): Promise<unknown>;
+    getEntityMetadataAsync(entityId: string): Promise<Record<string, unknown>>;
+    getSlotContainersAsync(): Promise<SimulationSlotContainer[]>;
+    getSlotAssignmentsAsync(containerId: string): Promise<SimulationAssignment[]>;
+    assignItemToSlotAsync(containerId: string, slotId: string, itemId: string): Promise<SimulationSlotMutationResult>;
+    removeItemFromSlotAsync(containerId: string, slotId: string): Promise<SimulationSlotMutationResult>;
+    getAvailableItemsAsync(containerId: string, slotId: string): Promise<SimulationAvailableItem[]>;
+    calculatePowerPreviewAsync(containerId: string, slotId: string, candidateItemId: string): Promise<SimulationPowerPreview>;
+    validateSlotAssignmentAsync(containerId: string, slotId: string, itemId: string): Promise<SimulationSlotValidationResult>;
+    executeBatchOperationsAsync(operations: Array<SimulationBatchOperation>, validateOnly?: boolean): Promise<SimulationBatchOperationsResult>;
+    subscribeAsync(options: SimulationSubscribeOptions): Promise<() => void>;
+    /**
+     * Reset all simulation state for the current player.
+     * Clears inventory, cancels active runs, and removes slot assignments.
+     * Optionally runs an initialization recipe after reset.
+     */
+    resetStateAsync(options?: ResetStateOptions): Promise<ResetStateResult>;
+}
+
+declare const ROOM_GAME_PHASES: readonly ["waiting", "playing", "ended"];
+type RoomGamePhase = (typeof ROOM_GAME_PHASES)[number];
+interface RundotGameRoomRulesGameState extends Record<string, unknown> {
+    phase?: RoomGamePhase;
+    currentPlayer?: string | null;
+    turnOrder?: string[];
+    turnCount?: number;
+    turnBased?: boolean;
+    playerStates?: Record<string, unknown>;
+    startParams?: {
+        gameConfig: Record<string, unknown>;
+        turnOrder?: string[] | null;
+        startedBy: string;
+        startedAt: unknown;
+    };
+}
+interface RundotGameRoomRules extends Record<string, unknown> {
+    hostProfileId?: string;
+    minPlayers?: number;
+    maxPlayers?: number;
+    turnBased?: boolean;
+    gameState?: RundotGameRoomRulesGameState;
+}
+interface RundotGameRoomCustomMetadata extends Record<string, unknown> {
+    rules?: RundotGameRoomRules;
+}
+interface RundotGameRoomPayload extends Record<string, unknown> {
+    id: string;
+    name?: string;
+    currentPlayers?: string[];
+    maxPlayers?: number;
+    gameType?: string;
+    appId?: string;
+    type?: string;
+    createdBy?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    isPrivate?: boolean;
+    status?: string;
+    customMetadata?: RundotGameRoomCustomMetadata;
+    admins?: string[];
+    roomCode?: string;
+    description?: string;
+    data?: Record<string, unknown>;
+    version?: number;
+}
+/**
+ * Server API response envelopes.
+ * These match the format returned by the H5 Rooms Cloud Functions.
+ */
+/**
+ * Standard envelope for endpoints that return a single room.
+ */
+interface RoomEnvelopeResponse {
+    success: boolean;
+    room: RundotGameRoomPayload;
+}
+/**
+ * Standard envelope for endpoints that return multiple rooms.
+ */
+interface RoomsEnvelopeResponse {
+    success: boolean;
+    rooms: RundotGameRoomPayload[];
+}
+/**
+ * Standard envelope for join-or-create room endpoint.
+ */
+interface JoinOrCreateRoomEnvelopeResponse {
+    success: boolean;
+    action: 'created' | 'joined';
+    room: RundotGameRoomPayload;
+    playersJoined: number;
+}
+declare class RundotGameRoom {
+    readonly id: string;
+    name?: string;
+    players: string[];
+    maxPlayers?: number;
+    gameType?: string;
+    appId?: string;
+    type?: string;
+    createdBy?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    isPrivate?: boolean;
+    status?: string;
+    customMetadata: RundotGameRoomCustomMetadata;
+    admins: string[];
+    roomCode?: string;
+    description?: string;
+    data: Record<string, unknown>;
+    version?: number;
+    constructor(roomData: RundotGameRoomPayload);
+}
+
+interface CreateRoomOptions {
+    maxPlayers?: number;
+    gameType?: string;
+    isPrivate?: boolean;
+    roomCode?: string;
+    name?: string;
+    description?: string;
+    customMetadata?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+}
+interface JoinRoomMatchCriteria {
+    isPrivate?: boolean;
+    hasSpace?: boolean;
+    gameType?: string;
+    [key: string]: unknown;
+}
+interface JoinOrCreateRoomOptions {
+    matchCriteria?: JoinRoomMatchCriteria;
+    createOptions: CreateRoomOptions;
+}
+interface JoinOrCreateResult {
+    action: 'created' | 'joined';
+    room: RundotGameRoom;
+    playersJoined: number;
+}
+interface ListRoomsOptions {
+    includeArchived?: boolean;
+}
+interface RoomDataUpdate {
+    type: 'H5_ROOM_DATA_UPDATED';
+    roomId: string;
+    roomData: RundotGameRoomPayload;
+    timestamp?: number;
+}
+type RoomMessageEventType = 'H5_ROOM_MESSAGE_RECEIVED' | 'H5_ROOM_MESSAGE_UPDATED' | 'H5_ROOM_MESSAGE_DELETED';
+interface RoomMessagePayload extends Record<string, unknown> {
+    id?: string;
+    roomId?: string;
+    senderId?: string;
+    type?: string;
+    content?: unknown;
+    metadata?: Record<string, unknown>;
+    timestamp?: unknown;
+}
+interface RoomMessageEvent {
+    type: RoomMessageEventType;
+    roomId: string;
+    message: RoomMessagePayload;
+    timestamp?: number;
+}
+interface ProposedMovePayload extends Record<string, unknown> {
+    id?: string;
+    proposerProfileId?: string;
+    timestamp?: unknown;
+    gameSpecificState?: Record<string, unknown>;
+    clientContext?: Record<string, unknown>;
+    moveType?: string;
+    clientProposalId?: string;
+    serverGenericValidationStatus?: string;
+    serverGenericValidationReason?: string;
+    serverCustomValidationStatus?: string;
+    serverCustomValidationReason?: string;
+    clientConsensusStatus?: string;
+    clientConsensusDetails?: unknown;
+    updatedAt?: unknown;
+}
+interface ProposedMoveEvent {
+    type: 'app:h5:proposedMoveValidationUpdated';
+    roomId: string;
+    proposedMoveData: ProposedMovePayload;
+    proposedMoveId?: string;
+    changeType?: string;
+    timestamp?: number;
+}
+interface RoomSubscriptionOptions {
+    onData?: (event: RoomDataUpdate) => void;
+    onMessages?: (event: RoomMessageEvent) => void;
+    onGameEvents?: (event: ProposedMoveEvent) => void;
+}
+interface ProposeMoveRequest {
+    gameSpecificState: Record<string, unknown>;
+    moveType: string;
+    clientContext?: Record<string, unknown>;
+    clientProposalId?: string;
+}
+interface ProposeMoveResult {
+    proposedMoveId: string;
+}
+interface ValidateMoveVerdict {
+    isValid: boolean;
+    reason?: string | null;
+    validatorId?: string | null;
+}
+interface ValidateMoveResult {
+    success: boolean;
+    moveId: string;
+    isValid: boolean;
+    reason?: string | null;
+}
+interface UpdateRoomDataOptions {
+    merge?: boolean;
+}
+interface RoomMessageRequest {
+    message: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface StartRoomGameOptions {
+    gameConfig?: Record<string, unknown>;
+    turnOrder?: string[] | null;
+}
+interface RoomsApi {
+    createRoomAsync(options: CreateRoomOptions): Promise<RundotGameRoom>;
+    joinOrCreateRoomAsync(options: JoinOrCreateRoomOptions): Promise<JoinOrCreateResult>;
+    joinRoomByCodeAsync(roomCode: string): Promise<RundotGameRoom>;
+    getUserRoomsAsync(options?: ListRoomsOptions): Promise<RundotGameRoom[]>;
+    subscribeAsync(room: RundotGameRoom, options?: RoomSubscriptionOptions): Promise<() => void>;
+    /**
+     * @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(room: RundotGameRoom, message: 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, request: ProposeMoveRequest): Promise<ProposeMoveResult>;
+    validateMoveAsync(room: RundotGameRoom, moveId: string, verdict: ValidateMoveVerdict): Promise<ValidateMoveResult>;
+}
+
+interface RundotGameMessage {
+    type: string;
+    direction: string;
+    data?: {
+        requestId?: string;
+        success?: boolean;
+        value?: any;
+        data?: any;
+        error?: string;
+        script?: string;
+    };
+    instanceId: string;
+    timestamp: number;
+}
+declare global {
+    interface Window {
+        _rundotGameInitState?: {
+            poolId: string;
+            apiInjected: boolean;
+            gameInitialized: boolean;
+        };
+        ReactNativeWebView?: {
+            postMessage(message: string): void;
+        };
+        rundotGame: {
+            _config: {
+                locale: string;
+                instanceId: string;
+                context?: any;
+                profile?: {
+                    id?: string;
+                    username?: string;
+                    name?: string;
+                    displayName?: string;
+                    avatarUrl?: string | null;
+                    isAnonymous?: boolean;
+                };
+                environment: {
+                    browserInfo?: {
+                        language: string;
+                    };
+                };
+                _handlers: Record<string, any>;
+            };
+            profile?: {
+                id?: string;
+                username?: string;
+                avatarUrl?: string | null;
+                name?: string;
+                displayName?: string;
+                isAnonymous?: boolean;
+            } | null;
+            _fetchFromCdn: (url: string) => Promise<string>;
+        };
+    }
+}
+type OnRundotGameMessageCallback = (message: RundotGameMessage) => void;
+declare class RundotGameTransport implements RpcTransport {
+    private readonly messageHandler;
+    private readonly onNotificationCallbacks;
+    private readonly onNotificationCallbacksToRemove;
+    private readonly onRundotGameMessageCallbacks;
+    private readonly onResponseCallbacks;
+    private readonly onResponseCallbacksToRemove;
+    private _instanceId;
+    private isStarted;
+    private isProcessingMessage;
+    constructor();
+    onNotification(callback: OnNotificationCallback): Subscription;
+    onRequest(callback: OnRequestCallback): Subscription;
+    onResponse(callback: OnResponseCallback): Subscription;
+    get instanceId(): string | null;
+    set instanceId(instanceId: string);
+    sendRequest(request: RpcRequest): void;
+    sendRundotGameMessage(message: RundotGameMessage): void;
+    sendResponse(response: RpcResponse): void;
+    start(): void;
+    stop(): void;
+    private handleNotification;
+    private handleResponse;
+    private removeOnResponseCallback;
+    private removeOnNotificationCallback;
+    private logInfo;
+    private logWarn;
+    onRundotGameMessage(callback: OnRundotGameMessageCallback): Subscription;
+    private notifyRundotGameMessageReceived;
+}
+
+interface LoggingApi {
+    logDebug(message: string, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+}
+
+interface SharedAssetsApi {
+    loadAssetsBundle(game: string, bundleKey: string): Promise<ArrayBuffer>;
+}
+
+declare class RpcSharedAssetsApi implements SharedAssetsApi {
+    private readonly rundotGameApi;
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient, rundotGameApi: RundotGameAPI);
+    loadAssetsBundle(game: string, bundleKey: string, fileType?: string): Promise<ArrayBuffer>;
+}
+interface LoadEmbeddedAssetsRequest {
+    assetKey: string;
+}
+interface LoadEmbeddedAssetsResponse {
+    base64Data: string;
+}
+
+interface SpendCurrencyOptions {
+    screenName?: string;
+}
+interface IapApi {
+    getHardCurrencyBalance(): Promise<number>;
+    spendCurrency(productId: string, amount: number, options?: SpendCurrencyOptions): Promise<void>;
+    openStore(): Promise<void>;
+    getCurrencyIcon(): Promise<LoadEmbeddedAssetsResponse>;
+}
+
+interface LeaderboardModeConfig {
+    displayName: string;
+    minDurationSec?: number;
+    maxDurationSec?: number;
+    minScore?: number;
+    maxScore?: number;
+}
+type LeaderboardPeriodType = 'daily' | 'weekly' | 'monthly' | 'alltime';
+interface LeaderboardPeriodConfig {
+    displayName: string;
+    type: LeaderboardPeriodType;
+}
+interface LeaderboardAntiCheatConfig {
+    enableZScoreDetection: boolean;
+    zScoreThreshold: number;
+    enableRateLimit: boolean;
+    minTimeBetweenSubmissionsSec: number;
+    trustScoreDecayPerFlag: number;
+    shadowBanThreshold: number;
+}
+interface LeaderboardDisplaySettings {
+    maxEntriesPerPage: number;
+}
+interface LeaderboardConfig {
+    minDurationSec: number;
+    maxDurationSec: number;
+    minScore: number;
+    maxScore: number;
+    requiresToken: boolean;
+    enableScoreSealing: boolean;
+    scoreSealingSecret?: string;
+    modes: Record<string, LeaderboardModeConfig>;
+    periods: Record<string, LeaderboardPeriodConfig>;
+    antiCheat: LeaderboardAntiCheatConfig;
+    displaySettings: LeaderboardDisplaySettings;
+}
+interface ScoreToken {
+    token: string;
+    startTime: number;
+    expiresAt: number;
+    sealingNonce?: string | null;
+    sealingSecret?: string | null;
+    mode: string;
+}
+interface SubmitScoreParams {
+    token?: string;
+    score: number;
+    duration: number;
+    mode?: string;
+    telemetry?: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+interface SubmitScoreResult {
+    accepted: boolean;
+    rank?: number | null;
+    zScore?: number | null;
+    isAnomaly?: boolean;
+}
+interface GetPagedScoresOptions {
+    mode?: string;
+    period?: string;
+    periodDate?: number | string;
+    cursor?: string | null;
+    limit?: number;
+    variant?: 'standard' | 'highlight';
+    topCount?: number;
+    contextAhead?: number;
+    contextBehind?: number;
+}
+interface LeaderboardEntry {
+    profileId: string;
+    username: string;
+    avatarUrl: string | null;
+    score: number;
+    duration: number;
+    submittedAt: number;
+    token?: string;
+    rank: number | null;
+    zScore?: number | null;
+    isAnomaly?: boolean;
+    trustScore?: number | null;
+    isShadowBanned?: boolean;
+    expiresAt?: number | null;
+    metadata?: Record<string, any> | null;
+    isSeed?: boolean;
+}
+interface PagedScoresResponse {
+    variant: 'standard' | 'highlight';
+    entries: LeaderboardEntry[];
+    totalEntries: number;
+    nextCursor?: string | null;
+    playerRank: number | null;
+    periodInstance: string;
+}
+interface PlayerRankOptions {
+    mode?: string;
+    period?: string;
+    periodDate?: number | string;
+}
+interface PlayerRankResult {
+    rank: number | null;
+    score?: number;
+    totalPlayers: number;
+    percentile?: number;
+    trustScore: number;
+    periodInstance: string;
+}
+interface PodiumScoresContext {
+    topEntries: LeaderboardEntry[];
+    beforePlayer: LeaderboardEntry[];
+    playerEntry?: LeaderboardEntry | null;
+    afterPlayer: LeaderboardEntry[];
+    totalBefore: number;
+    totalAfter: number;
+    omittedBefore: number;
+    omittedAfter: number;
+}
+interface PodiumScoresResponse extends PagedScoresResponse {
+    variant: 'highlight';
+    context: PodiumScoresContext;
+}
+interface GetPodiumScoresOptions extends Omit<GetPagedScoresOptions, 'variant'> {
+}
+interface LeaderboardApi {
+    createScoreToken(mode?: string): Promise<ScoreToken>;
+    submitScore(params: SubmitScoreParams): Promise<SubmitScoreResult>;
+    getPagedScores(options?: GetPagedScoresOptions): Promise<PagedScoresResponse>;
+    getMyRank(options?: PlayerRankOptions): Promise<PlayerRankResult>;
+    getPodiumScores(options?: GetPodiumScoresOptions): Promise<PodiumScoresResponse>;
+}
+
+interface PreloaderApi {
+    showLoadScreen(): Promise<void>;
+    hideLoadScreen(): Promise<void>;
+    setLoaderText(text: string): Promise<void>;
+    setLoaderProgress(progress: number): Promise<void>;
+}
+
+/**
+ * OpenGraph metadata for rich social previews.
+ *
+ * H5 games provide these values so social networks can render rich cards when
+ * a share link is posted.
+ */
+interface ShareMetadata {
+    /** Preview title shown in link cards (e.g. Twitter, iMessage). */
+    title?: string;
+    /** Preview description shown under the title. */
+    description?: string;
+    /** Preview image URL (must be HTTPS for most social platforms). */
+    imageUrl?: string;
+}
+interface SocialQRCodeOptions {
+    /** Size of the QR code image in pixels. */
+    size?: number;
+    /** Margin around the QR code in pixels. */
+    margin?: number;
+    /** Output format for the rendered QR code. */
+    format?: 'png' | 'svg';
+}
+interface ShareLinkResult {
+    shareUrl: string;
+}
+interface QRCodeResult {
+    shareUrl: string;
+    qrCode: string;
+}
+/**
+ * Social distribution API used by H5 games.
+ *
+ * This unified API powers both share links and QR codes, backed by a single
+ * Firestore document that stores arbitrary launch parameters supplied by the
+ * game.
+ */
+interface SocialApi {
+    /**
+     * Create a share link and invoke the host platform's native share UX.
+     *
+     * Platform behaviour:
+     * - iOS / Android: opens the native share sheet.
+     * - Web: copies the generated URL to the clipboard (with fallback toast).
+     *
+     * @param options.shareParams Arbitrary share parameters for your game.
+     * @param options.metadata Optional OpenGraph metadata for rich previews.
+     * @returns The generated share URL.
+     */
+    shareLinkAsync(options: {
+        shareParams: Record<string, string>;
+        metadata?: ShareMetadata;
+    }): Promise<ShareLinkResult>;
+    /**
+     * Create a share document and return both the URL and a QR code image.
+     *
+     * Games can render or print the returned QR image or re-use the share URL.
+     *
+     * @param options.shareParams Arbitrary share parameters for your game.
+     * @param options.metadata Optional OpenGraph metadata for the share.
+     * @param options.qrOptions Customisation for the generated QR code.
+     * @returns The generated share URL and QR code (as a data URL).
+     */
+    createQRCodeAsync(options: {
+        shareParams: Record<string, string>;
+        metadata?: ShareMetadata;
+        qrOptions?: SocialQRCodeOptions;
+    }): Promise<QRCodeResult>;
+}
+
+/**
+ * Safe area insets representing padding needed to avoid device notches and host UI.
+ * Includes toolbar/feedHeader height + device safe areas.
+ */
+interface SafeArea {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * @deprecated Use SafeArea instead. Will be removed in v4.0.0
+ */
+type HudInsets = SafeArea;
+interface InitializationOptions {
+    helpText?: string;
+    hardDisableMock?: boolean;
+    mock?: Record<string, any>;
+    usePreloader?: boolean;
+    launchParams?: Record<string, string>;
+    shareParams?: Record<string, string>;
+}
+interface InitializationContext {
+    /**
+     * Safe area insets from INIT_SDK response.
+     * @deprecated Use RundotGameAPI.system.getSafeArea() instead. Will be removed in v4.0.0
+     */
+    safeArea?: SafeArea;
+    initializeAsleep: boolean;
+    launchParams?: Record<string, string>;
+    shareParams?: Record<string, string>;
+}
+interface 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 leaderboard: LeaderboardApi;
+    readonly preloader: PreloaderApi;
+    readonly social: SocialApi;
+    readonly isInitialized: boolean;
+    readonly iap: IapApi;
+    readonly context?: InitializationContext;
+    initialize(options?: InitializationOptions): Promise<InitializationContext>;
+}
+/**
+ * Create a Host instance based on the runtime environment.
+ *
+ * ## Why SandboxHost uses dynamic import
+ *
+ * SandboxHost depends on Firebase (~200KB+ gzipped) for authentication and
+ * Firestore. This is ONLY needed during local development when using the
+ * RUN.game sandbox mode (connecting to real Firebase backend via Vite dev server).
+ *
+ * In production builds (H5 games deployed to RUN.game app):
+ * - `window.__RUNDOT_GAME_SANDBOX__` is never set (Vite plugin only runs in dev)
+ * - `isSandboxEnabled()` returns false
+ * - SandboxHost is never instantiated
+ *
+ * Using a static import like `import { SandboxHost } from './SandboxHost.ts'`
+ * would cause Rollup/Vite to bundle SandboxHost AND all its dependencies
+ * (including Firebase) into the production bundle, even though they're unused.
+ *
+ * Dynamic import (`await import('./SandboxHost.ts')`) tells the bundler to
+ * code-split SandboxHost into a separate chunk that's only loaded at runtime
+ * when the condition is true. In production, this chunk is never loaded.
+ *
+ * This keeps production bundles small (~200KB+ smaller) and faster to load.
+ */
+declare function createHost(rundotGameApi: RundotGameAPI, isMock: boolean): Promise<Host>;
+
+interface Avatar3dConfig {
+    headAsset: string | null;
+    outfitAsset: string | null;
+    hatAsset: string | null;
+    hairAsset: string | null;
+    faceAccessoryAsset: string | null;
+    animationAsset: string | null;
+    skinColor: string | null;
+}
+
+interface Asset {
+    id: string;
+    filename: string;
+    displayName: string;
+    preload?: boolean;
+    tags?: string[];
+    metadata?: Record<string, any>;
+}
+interface Category {
+    displayName?: string;
+    type: 'mesh';
+    assets: Asset[];
+}
+interface AssetManifest {
+    version: string;
+    generatedAt: string;
+    categories: Record<string, Category>;
+}
+
+interface Avatar3dEdits {
+    wasChanged: boolean;
+    config: Avatar3dConfig | null;
+    savedAvatarId: string | null;
+}
+interface ShowEditorOptions {
+    currentAvatar?: any;
+    contextData?: any;
+    onSave?: () => void;
+    onCancel?: () => void;
+}
+interface Avatar3dApi {
+    loadAvatar(avatarId?: string): Promise<Avatar3dConfig | null>;
+    saveAvatar(config: Avatar3dConfig): Promise<string>;
+    deleteAvatar(): Promise<void>;
+    downloadManifest(): Promise<AssetManifest>;
+    showEditor(options?: ShowEditorOptions): Promise<Avatar3dEdits>;
+    downloadAssetPaths(): Promise<Record<string, string[]>>;
+}
+
+declare global {
+    interface Window {
+        RundotGamePrototyping?: {
+            showAvatarEditorOverlay: (options: any, resolve: (args: any) => void) => Promise<void>;
+        };
+    }
+}
+declare class MockAvatarApi implements Avatar3dApi {
+    private readonly _rundotGameApi;
+    private cachedAssets;
+    private cachedVersion;
+    constructor(rundotGameApi: RundotGameAPI);
+    downloadAssetPaths(): Promise<Record<string, string[]>>;
+    deleteAvatar(): Promise<void>;
+    loadAvatar(avatar3dId?: string): Promise<Avatar3dConfig | null>;
+    saveAvatar(config: Avatar3dConfig): Promise<string>;
+    downloadManifest(): Promise<AssetManifest>;
+    showEditor(options?: ShowEditorOptions): Promise<Avatar3dEdits>;
+    private getAssets;
+    private loadAssetsManifest;
+    private selectAvatarConfig;
+    private selectAsset;
+    private seededRandom;
+    private simpleHash;
+    private getAllAssetPaths;
+    private log;
+}
+
+/**
+ * DEFINITIVE TypeScript definitions for Rundot Game API
+ *
+ * This is the single source of truth for all RUN.game games.
+ *
+ * Usage in RUN.game games:
+ * ```typescript
+ * import type { RundotGameAPI } from '../../rundot-game-api/types';
+ * declare const RundotGameAPI: RundotGameAPI;
+ * ```
+ */
+
+interface RecipeRequirementResult {
+    recipeId: string;
+    entity: string | null;
+    amount?: number;
+    inputs: Record<string, number | string>;
+    canAfford: boolean;
+    disabled: boolean;
+}
+interface SimulationRunSummary {
+    id: string;
+    recipeId: string;
+    status: string;
+    startTime: number;
+    expiresAt: number;
+    entity?: string;
+    inputs?: Record<string, number | string>;
+    outputs?: Record<string, number | string>;
+    commitmentEndsAt?: number;
+    participantCount?: number;
+}
+type RundotGameSimulationStateResponse = SimulationPersonalState | SimulationRoomState;
+type SimulationUpdateType = 'entity' | 'activeRuns' | 'snapshot';
+interface SimulationUpdateBase {
+    timestamp: number;
+    reason?: 'recipe_completed' | 'auto_restart' | 'manual_update' | 'state_sync';
+}
+interface SimulationEntityUpdate extends SimulationUpdateBase {
+    type: 'entity';
+    entities: Array<{
+        entityId: string;
+        quantity: number | string;
+    }>;
+}
+interface SimulationActiveRunsUpdate extends SimulationUpdateBase {
+    type: 'activeRuns';
+    activeRuns: Array<{
+        id: string;
+        recipeId: string;
+        status: string;
+        startTime: number;
+        expiresAt: number;
+        entity?: string;
+        inputs?: Record<string, number | string>;
+        outputs?: Record<string, number | string>;
+    }>;
+}
+interface SimulationSnapshotUpdate extends SimulationUpdateBase {
+    type: 'snapshot';
+    entities?: Array<{
+        entityId: string;
+        quantity: number | string;
+    }>;
+    activeRuns?: Array<{
+        id: string;
+        recipeId: string;
+        status: string;
+        startTime: number;
+        expiresAt: number;
+        entity?: string;
+        inputs?: Record<string, number | string>;
+        outputs?: Record<string, number | string>;
+    }>;
+}
+type SimulationUpdateData = SimulationEntityUpdate | SimulationActiveRunsUpdate | SimulationSnapshotUpdate;
+interface SimulationSubscribeOptions {
+    entities?: string[];
+    tags?: string[];
+    activeRuns?: boolean;
+    roomId?: string;
+    onUpdate: (data: SimulationUpdateData) => void;
+}
+interface RundotGameSimulationEffect {
+    type: string;
+    target: any;
+    value: any;
+}
+interface RundotGameSimulationRecipe {
+    scope: 'player' | 'room' | 'actor';
+    inputs: Record<string, any>;
+    autoRestart?: boolean;
+    beginEffects?: RundotGameSimulationEffect[];
+    endEffects?: RundotGameSimulationEffect[];
+    outputs?: Record<string, any>;
+    duration?: number;
+    maxRestartCondition?: any;
+    metadata?: {
+        startsDisabled?: boolean;
+        autoRestart?: boolean;
+        maxRestartCondition?: any;
+    };
+    guards?: Record<string, any>;
+    effects?: Array<any>;
+    clientViewable?: boolean;
+}
+interface RundotGameSimulationConfig {
+    version: string;
+    entities: Record<string, {
+        tags?: string[];
+        metadata?: Record<string, any>;
+        stackable?: boolean;
+        neverConsumable?: boolean;
+        clientViewable?: boolean;
+        slots?: Record<string, {
+            allowedTags: string[];
+            maxItems: number;
+        }>;
+        actorTemplate?: {
+            defaultState?: Record<string, any>;
+            availableRecipes?: string[];
+        };
+    }>;
+    recipes: Record<string, RundotGameSimulationRecipe>;
+    fieldResolution?: Record<string, any>;
+    matchmaking?: Record<string, any>;
+}
+interface RecipeRequirementQuery {
+    recipeId: string;
+    entity?: string;
+    batchAmount?: number;
+}
+interface BatchRecipeRequirementsResult {
+    success: boolean;
+    results: RecipeRequirementResult[];
+    errors?: Array<unknown>;
+}
+interface RundotGameExecuteRecipeOptions {
+    roomId?: string;
+    batchAmount?: number;
+    allowPartialBatch?: boolean;
+    entity?: string;
+}
+interface RundotGameExecuteScopedRecipeOptions {
+    roomId?: string;
+}
+interface RundotGameAvailableRecipe {
+    id: string;
+    scope: string;
+    clientViewable: boolean;
+}
+interface RundotGameCollectRecipeResult {
+    success: boolean;
+    runId: string;
+    rewards: Record<string, unknown>;
+    message: string;
+}
+interface RundotGameExecuteRecipeResult {
+    success: boolean;
+    status?: string;
+    runId?: string;
+    expiresAt?: string;
+    queuePosition?: number;
+    outputs?: Record<string, number | string>;
+    data?: Record<string, unknown>;
+    message?: string;
+    amountRequested?: number;
+    amountFulfilled?: number;
+    partialSuccess?: boolean;
+}
+interface Profile {
+    id: string;
+    username: string;
+    name?: string;
+    avatarUrl?: string | null;
+    isAnonymous?: boolean;
+}
+interface RundotGameAPI {
+    /**
+     * @deprecated All config properties have been removed. Use RundotGameAPI methods instead.
+     * Will be removed in v4.0.0
+     */
+    config: Record<string, never>;
+    _profileData?: Profile;
+    _deviceData?: DeviceInfo;
+    _environmentData?: EnvironmentInfo;
+    _safeAreaData?: SafeArea;
+    _localeData?: string;
+    _languageCodeData?: string;
+    _mock: any;
+    _bootstrap: {
+        apiInjected: boolean;
+        rundotGame: any;
+    };
+    /**
+     * @deprecated No longer need to call this method. This will get called on import.
+     */
+    initializeAsync(options?: InitializationOptions): Promise<InitializationContext>;
+    simulation: SimulationApi;
+    leaderboard: LeaderboardApi;
+    log(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    isAvailable(): boolean;
+    /**
+     * @deprecated Use RundotGameAPI.system.isMobile() instead
+     */
+    isMobile(): boolean;
+    /**
+     * @deprecated Use RundotGameAPI.system.isWeb() instead
+     */
+    isWeb(): boolean;
+    isMock(): boolean;
+    /**
+     * @deprecated Please use the new analytics API. RundotGameAPI.analytics
+     * @param options
+     */
+    logCustomEvent(options: {
+        eventName: string;
+        params?: Record<string, any>;
+    }): Promise<void>;
+    getExperiment(options: {
+        experimentName: string;
+    }): Promise<any>;
+    getFeatureFlag(options: {
+        flagName: string;
+    }): Promise<any>;
+    getFeatureGate(options: {
+        gateName: string;
+    }): Promise<any>;
+    system: SystemApi;
+    getProfile(): Profile;
+    /**
+     * @deprecated Use getProfile() instead
+     */
+    getCurrentProfile(): Profile;
+    getLocale(): string;
+    getLanguageCode(): string;
+    triggerHapticAsync(style: HapticFeedbackStyle): Promise<void>;
+    deviceCache: {
+        setItem(key: string, value: string): Promise<void>;
+        getItem(key: string): Promise<string | null>;
+        removeItem(key: string): Promise<void>;
+        clear(): Promise<void>;
+        length(): Promise<number>;
+        key(index: number): Promise<string | null>;
+    };
+    appStorage: {
+        setItem(key: string, value: string): Promise<void>;
+        getItem(key: string): Promise<string | null>;
+        removeItem(key: string): Promise<void>;
+        clear(): Promise<void>;
+        length(): Promise<number>;
+        key(index: number): Promise<string | null>;
+        getAllItems(): Promise<string[]>;
+        setMultipleItems(items: {
+            key: string;
+            value: string;
+        }[]): Promise<void>;
+        removeMultipleItems(keys: string[]): Promise<void>;
+    };
+    globalStorage: {
+        setItem(key: string, value: string): Promise<void>;
+        getItem(key: string): Promise<string | null>;
+        removeItem(key: string): Promise<void>;
+        clear(): Promise<void>;
+        length(): Promise<number>;
+        key(index: number): Promise<string | null>;
+    };
+    requestPopOrQuit(options?: QuitOptions): Promise<boolean>;
+    /**
+     * @deprecated Please use the ads API. (e.g, RundotGameAPI.ads)
+     */
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    /**
+     * @deprecated Please use the ads API. (e.g, RundotGameAPI.ads)
+     */
+    showRewardedAdAsync(): Promise<boolean>;
+    requestTimeAsync(): Promise<ServerTimeData>;
+    getFutureTimeAsync(options: GetFutureTimeOptions): Promise<number>;
+    formatTime(timestamp: number, options?: any): string;
+    formatNumber(value: number, options?: any): string;
+    loadAsset(url: string, options?: {
+        type?: string;
+        streaming?: boolean;
+        cache?: boolean;
+        timeout?: number;
+        isOptional?: boolean;
+    }): Promise<string>;
+    preloadAssets(assets: Array<string | {
+        url: string;
+        isOptional?: boolean;
+    }>, options?: {
+        onProgress?: (progress: number, info: any) => void;
+    }): Promise<Array<{
+        success: boolean;
+        isOptional?: boolean;
+    }>>;
+    cleanupAssets(): void;
+    assetLoader: {
+        getCached(url: string): string | null;
+    };
+    showAvatar3dEditorAsync(options: {
+        currentAvatar?: any;
+        contextData?: any;
+    }): Promise<Avatar3dEdits>;
+    loadAvatar3dAsync(avatarId?: string): Promise<any>;
+    saveAvatar3dAsync(config: any): Promise<string>;
+    deleteAvatar3dAsync(): Promise<void>;
+    downloadAvatar3dAssetPathsAsync(): Promise<Record<string, string[]>>;
+    downloadAvatar3dManifestAsync(): Promise<AssetManifest>;
+    pushAppAsync(appId: string, options?: {
+        contextData?: any;
+        appParams?: any;
+    }): Promise<any>;
+    popAppAsync(): Promise<void>;
+    getStackInfo(): {
+        isInStack: boolean;
+        stackPosition: number;
+    };
+    rooms: RoomsApi;
+    notifyCleanupComplete(): void;
+    RoomEvents: {
+        OPTIMISTIC_GAME_STATE_UPDATED: string;
+        PROPOSED_MOVE_VALIDATION_UPDATED: string;
+    };
+    numbers: {
+        isBigNumber(value: any): boolean;
+        normalize(value: string | number | any): any;
+        format: {
+            incremental(value: any): string;
+        };
+        calculateGeometricSeriesCost(baseCost: number | string, multiplier: number, currentQuantity: number, purchaseAmount: number): any;
+        calculateMaxAffordableDecimal(availableCash: number | string, baseCost: number | string, multiplier: number, currentQuantity: number): number;
+        formatDecimalCurrency(decimalValue: any): string;
+        Decimal: any;
+    };
+    iap: IapApi;
+    cdn: CdnApi;
+    ads: AdsApi;
+    ai: AiApi;
+    popups: PopupsApi;
+    analytics: AnalyticsApi;
+    sharedAssets: SharedAssetsApi;
+    preloader: PreloaderApi;
+    notifications: NotificationsApi;
+    lifecycles: LifecycleApi;
+    social: SocialApi;
+    context: InitializationContext;
+}
+
+interface ShowInterstitialAdOptions {
+    adDisplayId?: string;
+    adDisplayName?: string;
+}
+interface ShowRewardedAdOptions {
+    adDisplayId?: string;
+    adDisplayName?: string;
+}
+interface AdsApi {
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    showRewardedAdAsync(options?: ShowRewardedAdOptions): Promise<boolean>;
+    showInterstitialAd(options?: ShowInterstitialAdOptions): Promise<boolean>;
+}
+
+export { type AiChatCompletionRequest as $, type AnalyticsApi as A, type BatchRecipeRequirementsResult as B, type ScheduleLocalNotification as C, type ScheduleNotificationOptions as D, type PopupsApi as E, type ShowToastOptions as F, type ShowInterstitialAdOptions as G, type Host as H, type ShowRewardedAdOptions as I, type ProfileApi as J, type DeviceApi as K, type DeviceInfo as L, type EnvironmentApi as M, type NavigationApi as N, type EnvironmentInfo as O, type Profile as P, type QuitOptions as Q, type RundotGameAPI as R, type SimulationRunSummary as S, type SystemApi as T, type SafeArea as U, type CdnApi as V, type FetchFromCdnOptions as W, type TimeApi as X, type ServerTimeData as Y, type GetFutureTimeOptions as Z, type AiApi as _, type RecipeRequirementResult as a, type PlayerRankOptions as a$, type AiChatCompletionData as a0, type HapticsApi as a1, HapticFeedbackStyle as a2, type FeaturesApi as a3, type Experiment as a4, type LifecycleApi as a5, type SleepCallback as a6, type Subscription as a7, type AwakeCallback as a8, type PauseCallback as a9, type RoomMessageEvent as aA, type ProposedMoveEvent as aB, RundotGameTransport as aC, type RoomsApi as aD, type CreateRoomOptions as aE, type JoinOrCreateRoomOptions as aF, type JoinOrCreateResult as aG, type ListRoomsOptions as aH, type UpdateRoomDataOptions as aI, type RoomMessageRequest as aJ, type StartRoomGameOptions as aK, type ProposeMoveRequest as aL, type ProposeMoveResult as aM, type ValidateMoveVerdict as aN, type ValidateMoveResult as aO, type RoomSubscriptionOptions as aP, type LoggingApi as aQ, type IapApi as aR, type SpendCurrencyOptions as aS, type LoadEmbeddedAssetsResponse as aT, type SharedAssetsApi as aU, type LeaderboardApi as aV, type ScoreToken as aW, type SubmitScoreParams as aX, type SubmitScoreResult as aY, type GetPagedScoresOptions as aZ, type PagedScoresResponse as a_, type ResumeCallback as aa, type QuitCallback as ab, type SimulationApi as ac, type SimulationSlotValidationResult as ad, type SimulationBatchOperation as ae, type SimulationBatchOperationsResult as af, type SimulationAvailableItem as ag, type SimulationPowerPreview as ah, type SimulationSlotMutationResult as ai, type SimulationSlotContainer as aj, type SimulationAssignment as ak, type SimulationState as al, type ExecuteRecipeOptions as am, type ExecuteRecipeResponse as an, type CollectRecipeResult as ao, type ResetStateOptions as ap, type ResetStateResult as aq, type GetActiveRunsOptions as ar, type ExecuteScopedRecipeOptions as as, type ExecuteScopedRecipeResult as at, type GetAvailableRecipesOptions as au, type GetAvailableRecipesResult as av, type Recipe as aw, type GetBatchRecipeRequirements as ax, type TriggerRecipeChainOptions as ay, type RoomDataUpdate as az, type RundotGameSimulationStateResponse as b, type PlayerRankResult as b0, type GetPodiumScoresOptions as b1, type PodiumScoresResponse as b2, type PreloaderApi as b3, type SocialApi as b4, type ShareMetadata as b5, type ShareLinkResult as b6, type SocialQRCodeOptions as b7, type QRCodeResult as b8, type Avatar3dApi as b9, type RundotGameRoomCustomMetadata as bA, type RundotGameRoomPayload as bB, type RoomEnvelopeResponse as bC, type RoomsEnvelopeResponse as bD, type JoinOrCreateRoomEnvelopeResponse as bE, type RecipeInfo as bF, type SimulationPersonalState as bG, type SimulationRoomActiveRecipe as bH, type SimulationRoomState as bI, type SimulationBatchOperationAssign as bJ, type SimulationBatchOperationRemove as bK, type SimulationBatchOperationResult as bL, RpcSharedAssetsApi as bM, type LoadEmbeddedAssetsRequest as bN, type LeaderboardModeConfig as bO, type LeaderboardPeriodType as bP, type LeaderboardPeriodConfig as bQ, type LeaderboardAntiCheatConfig as bR, type LeaderboardDisplaySettings as bS, type LeaderboardConfig as bT, type LeaderboardEntry as bU, type PodiumScoresContext as bV, type HudInsets as bW, createHost as bX, type AssetManifest as ba, type Avatar3dConfig as bb, type ShowEditorOptions as bc, type Avatar3dEdits as bd, type AdsApi as be, type InitializationContext as bf, type InitializationOptions as bg, type AiMessage as bh, type Asset as bi, type Category as bj, MockAvatarApi as bk, type SubPath as bl, type TimeIntervalTriggerInput as bm, type NotificationTriggerInput as bn, type OnRequestCallback as bo, type OnResponseCallback as bp, type OnNotificationCallback as bq, type RpcTransport as br, type JoinRoomMatchCriteria as bs, type RoomMessageEventType as bt, type RoomMessagePayload as bu, type ProposedMovePayload as bv, ROOM_GAME_PHASES as bw, type RoomGamePhase as bx, type RundotGameRoomRulesGameState as by, type RundotGameRoomRules as bz, type SimulationUpdateType as c, type SimulationEntityUpdate as d, type SimulationActiveRunsUpdate as e, type SimulationSnapshotUpdate as f, type SimulationUpdateData as g, type SimulationSubscribeOptions as h, type RundotGameSimulationEffect as i, type RundotGameSimulationRecipe as j, type RundotGameSimulationConfig as k, type RecipeRequirementQuery as l, type RundotGameExecuteRecipeOptions as m, type RundotGameExecuteScopedRecipeOptions as n, type RundotGameAvailableRecipe as o, type RundotGameCollectRecipeResult as p, type RundotGameExecuteRecipeResult as q, RundotGameRoom as r, type RpcRequest as s, type RpcResponse as t, type RpcNotification as u, RpcClient as v, type StorageApi as w, type NavigationStackInfo as x, type PushAppOptions as y, type NotificationsApi as z };