@series-inc/venus-sdk 2.4.1 → 3.0.0

package/dist/AdsApi-3DEYUUuj.d.mts

@@ -0,0 +1,1414 @@
+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 generateId;
+    private handleRpcResponse;
+    private handleRpcNotification;
+}
+
+interface StorageApi {
+    key(index: number): Promise<string | null>;
+    clear(): Promise<void>;
+    length(): Promise<number>;
+    getAllItems(): Promise<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 ShowConfirmOptions {
+    confirmText?: string;
+    cancelText?: string;
+}
+interface ShowAlertOptions {
+    buttonText?: string;
+}
+interface ShowToastOptions {
+    duration?: number;
+    variant?: 'success' | 'error' | 'warning' | 'info';
+    action?: {
+        label: string;
+    };
+}
+interface PopupsApi {
+    showAlert(title: string, message: string, options?: ShowAlertOptions): Promise<void>;
+    showConfirm(title: string, message: string, options?: ShowConfirmOptions): Promise<boolean>;
+    showToast(message: string, options?: ShowToastOptions): Promise<boolean>;
+    showActionSheet(items: ActionSheetItem[], options?: ShowActionSheetOptions): Promise<string | number | null>;
+}
+interface ActionSheetItem {
+    id?: string;
+    label: string;
+    icon?: string;
+}
+interface ShowActionSheetOptions {
+    title?: string;
+    message?: string;
+    cancelButtonText?: string;
+    disableCancel?: boolean;
+}
+
+interface ProfileApi {
+    getCurrentProfile(): Profile;
+}
+
+type SubPath = string;
+interface FetchBlobOptions {
+    timeout?: number;
+}
+interface CdnApi {
+    resolveAssetUrl(subPath: string): string;
+    resolveAvatarAssetUrl(subPath: string): string;
+    resolveSharedLibUrl(subPath: string): string;
+    getAssetCdnBaseUrl(): string;
+    fetchFromCdn(url: string, request?: RequestInit): Promise<Response>;
+    fetchBlob(path: SubPath, options?: FetchBlobOptions): 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 PostInfo {
+    isLiked: boolean;
+    isFollowing: boolean;
+    likesCount: number;
+    commentsCount: number;
+}
+interface ToggleLikeResult {
+    isLiked: boolean;
+    likesCount: number;
+    action: 'liked' | 'unliked';
+}
+interface ToggleFollowResult {
+    isFollowing: boolean;
+    action: 'followed' | 'unfollowed';
+}
+interface OpenCommentsResult {
+    opened: boolean;
+    commentsCount: number;
+}
+interface PostApi {
+    getPostInfo(): Promise<PostInfo>;
+    toggleLikeAsync(): Promise<ToggleLikeResult>;
+    openCommentsAsync(): Promise<OpenCommentsResult>;
+    toggleFollowAsync(): Promise<ToggleFollowResult>;
+}
+
+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 venus.
+     * This gets ignored when the game using the sdk is used within a venus 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?: any;
+}
+interface CollectRecipeResult {
+    success: boolean;
+    runId: string;
+    rewards: any;
+    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 SimulationApi {
+    getStateAsync(roomId?: string): Promise<any>;
+    getConfigAsync(roomId?: string): Promise<VenusSimulationConfig>;
+    executeRecipeAsync(recipeId: string, inputs?: any, options?: ExecuteRecipeOptions): Promise<any>;
+    getActiveRunsAsync(options?: GetActiveRunsOptions): Promise<any>;
+    collectRecipeAsync(runId: string): Promise<CollectRecipeResult>;
+    executeScopedRecipeAsync(recipeId: string, entity: string, inputs?: any, options?: ExecuteScopedRecipeOptions | any): Promise<ExecuteScopedRecipeResult>;
+    triggerRecipeChainAsync(recipeId: string, options?: TriggerRecipeChainOptions): Promise<any>;
+    getAvailableRecipesAsync(options?: GetAvailableRecipesOptions): Promise<GetAvailableRecipesResult>;
+    getRecipeRequirementsAsync(recipe: Recipe): Promise<RecipeRequirementResult>;
+    getBatchRecipeRequirementsAsync(recipes: Recipe[]): Promise<GetBatchRecipeRequirements>;
+    resolveFieldValueAsync(entityId: string, fieldPath: string, entity?: string): Promise<any>;
+    getEntityMetadataAsync(entityId: string): Promise<any>;
+    getSlotContainersAsync(): Promise<any>;
+    getSlotAssignmentsAsync(containerId: string): Promise<any>;
+    assignItemToSlotAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    removeItemFromSlotAsync(containerId: string, slotId: string): Promise<any>;
+    getAvailableItemsAsync(containerId: string, slotId: string): Promise<Array<any>>;
+    calculatePowerPreviewAsync(containerId: string, slotId: string, candidateItemId: string): Promise<any>;
+    validateSlotAssignmentAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    executeBatchOperationsAsync(operations: Array<any>, validateOnly?: boolean): Promise<any>;
+    sumContributions(contributions: Record<string, any>): Record<string, number>;
+}
+
+interface VenusMessage {
+    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 {
+        _venusInitState?: {
+            poolId: string;
+            apiInjected: boolean;
+            gameInitialized: boolean;
+        };
+        ReactNativeWebView?: {
+            postMessage(message: string): void;
+        };
+        venus: {
+            _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 OnVenusMessageCallback = (message: VenusMessage) => void;
+declare class VenusTransport implements RpcTransport {
+    private readonly messageHandler;
+    private readonly onNotificationCallbacks;
+    private readonly onNotificationCallbacksToRemove;
+    private readonly onVenusMessageCallbacks;
+    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;
+    sendVenusMessage(message: VenusMessage): void;
+    sendResponse(response: RpcResponse): void;
+    start(): void;
+    stop(): void;
+    private handleNotification;
+    private handleResponse;
+    private removeOnResponseCallback;
+    private removeOnNotificationCallback;
+    private logInfo;
+    private logWarn;
+    onVenusMessage(callback: OnVenusMessageCallback): Subscription;
+    private notifyVenusMessageReceived;
+}
+
+declare class VenusRoom {
+    readonly id: string;
+    name: string;
+    players: any[];
+    maxPlayers: number;
+    gameType: string;
+    appId: string;
+    type: any;
+    createdBy: string;
+    createdAt: number;
+    updatedAt: number;
+    isPrivate: boolean;
+    currentPlayers: string[];
+    status: any;
+    customMetadata: Record<string, any>;
+    admins: string[];
+    roomCode: string;
+    description: string;
+    data: Record<string, any>;
+    version: string;
+    private _subscriptions;
+    constructor(roomData: any);
+    private updateFromRoomData;
+}
+
+interface CreateRoomOptions {
+    maxPlayers?: number;
+    gameType?: string;
+    isPrivate?: boolean;
+    roomCode?: string;
+    name?: string;
+    description?: string;
+    customMetadata?: Record<string, any>;
+}
+interface JoinOrCreateResult {
+    action: 'created' | 'joined';
+    room: VenusRoom;
+    playersJoined: number;
+}
+interface RoomSubscriptionOptions {
+    onData?: (roomData: any) => void;
+    onMessages?: (messagePayload: any) => void;
+    onMoves?: (movePayload: any) => void;
+    onGameEvents?: (eventPayload: any) => void;
+}
+interface ProposeMovePayload {
+    gameSpecificState: any;
+    moveType: string;
+    clientContext?: Record<string, any>;
+    clientProposalId?: string;
+}
+interface ProposeMoveResult {
+    proposedMoveId: string;
+}
+interface ValidateMoveResult {
+    success: boolean;
+    moveId: string;
+    isValid: boolean;
+    reason?: string | null;
+}
+interface RoomsApi {
+    createRoom(options: CreateRoomOptions): Promise<VenusRoom>;
+    joinOrCreateRoom(options: CreateRoomOptions): Promise<JoinOrCreateResult>;
+    joinRoomByCode?(roomCode: string): Promise<VenusRoom>;
+    getUserRooms?(includeArchived?: boolean): Promise<VenusRoom[]>;
+    subscribe?(room: VenusRoom, options: RoomSubscriptionOptions): (() => void) | {
+        unsubscribe(): void;
+    };
+    updateData?(room: VenusRoom, updates: Record<string, any>, merge?: boolean): Promise<any>;
+    getData?(room: VenusRoom): Promise<any>;
+    sendMessage?(room: VenusRoom, messageData: any): Promise<string>;
+    leave?(room: VenusRoom): Promise<any>;
+    startGame?(room: VenusRoom, gameConfig?: Record<string, any>, turnOrder?: string[] | null): Promise<any>;
+    proposeMove?(room: VenusRoom, proposalPayload: ProposeMovePayload): Promise<ProposeMoveResult>;
+    validateMove?(room: VenusRoom, moveId: string, isValid: boolean, reason?: string | null, validatorId?: string | null): Promise<ValidateMoveResult>;
+}
+
+interface LoggingApi {
+    logDebug(message: string, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+}
+
+interface SharedAssetsApi {
+    loadCharactersBundle(): Promise<ArrayBuffer>;
+    loadBurgerTimeAssetsBundle(): Promise<ArrayBuffer>;
+}
+
+declare class RpcSharedAssetsApi implements SharedAssetsApi {
+    private readonly venusApi;
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient, venusApi: VenusAPI);
+    loadBurgerTimeAssetsBundle(): Promise<ArrayBuffer>;
+    loadCharactersBundle(): 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;
+    requiresHash: boolean;
+    scoringFields: string[];
+    modes: Record<string, LeaderboardModeConfig>;
+    periods: Record<string, LeaderboardPeriodConfig>;
+    antiCheat: LeaderboardAntiCheatConfig;
+    displaySettings: LeaderboardDisplaySettings;
+}
+interface StartRunResult {
+    sessionId: string;
+    startTime: number;
+    expiresAt: number;
+    hashNonce?: string | null;
+    mode: string;
+}
+interface SubmitScoreOptions {
+    mode?: string;
+    telemetry?: Record<string, any>;
+    metadata?: Record<string, any>;
+    hash?: string;
+}
+interface SubmitScoreResult {
+    accepted: boolean;
+    rank?: number | null;
+    zScore?: number | null;
+    isAnomaly?: boolean;
+}
+interface GetLeaderboardOptions {
+    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;
+    durationSec: number;
+    submittedAt: number;
+    sessionId?: 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 LeaderboardResponse {
+    variant: 'standard' | 'highlight';
+    entries: LeaderboardEntry[];
+    totalEntries: number;
+    nextCursor?: string | null;
+    playerRank: number | null;
+    periodInstance: string;
+}
+interface PlayerStatsOptions {
+    mode?: string;
+    period?: string;
+    periodDate?: number | string;
+}
+interface PlayerStats {
+    rank: number | null;
+    score?: number;
+    totalPlayers: number;
+    percentile?: number;
+    trustScore: number;
+    periodInstance: string;
+}
+interface LeaderboardHighlightContext {
+    topEntries: LeaderboardEntry[];
+    beforePlayer: LeaderboardEntry[];
+    playerEntry?: LeaderboardEntry | null;
+    afterPlayer: LeaderboardEntry[];
+    totalBefore: number;
+    totalAfter: number;
+    omittedBefore: number;
+    omittedAfter: number;
+}
+interface LeaderboardHighlightResponse extends LeaderboardResponse {
+    variant: 'highlight';
+    context: LeaderboardHighlightContext;
+}
+interface LeaderboardHighlightOptions extends Omit<GetLeaderboardOptions, 'variant'> {
+}
+interface LeaderboardApi {
+    startRun(mode?: string): Promise<StartRunResult>;
+    submitScore(sessionId: string, score: number, durationSec: number, options?: SubmitScoreOptions): Promise<SubmitScoreResult>;
+    getLeaderboard(options?: GetLeaderboardOptions): Promise<LeaderboardResponse>;
+    getPlayerStats(options?: PlayerStatsOptions): Promise<PlayerStats>;
+    getLeaderboardHighlight(options?: LeaderboardHighlightOptions): Promise<LeaderboardHighlightResponse>;
+}
+
+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.launchParams Arbitrary launch parameters (must include gameId).
+     * @param options.metadata Optional OpenGraph metadata for rich previews.
+     * @returns The generated share URL.
+     */
+    shareLinkAsync(options: {
+        launchParams: 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.launchParams Arbitrary launch parameters (must include gameId).
+     * @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: {
+        launchParams: Record<string, string>;
+        metadata?: ShareMetadata;
+        qrOptions?: SocialQRCodeOptions;
+    }): Promise<QRCodeResult>;
+}
+
+interface InitializeOptions {
+    usePreloader?: boolean;
+    mock?: Record<string, any>;
+    [key: string]: any;
+}
+interface HudInsets {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+interface InitializationOptions {
+    helpText?: string;
+    hardDisableMock?: boolean;
+    mock?: Record<string, any>;
+    usePreloader?: boolean;
+}
+interface InitializationContext {
+    hudInsets?: HudInsets;
+    initializeAsleep: boolean;
+}
+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 cdn: CdnApi;
+    readonly time: TimeApi;
+    readonly post: PostApi;
+    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;
+    initialize(options?: InitializationOptions): Promise<InitializationContext>;
+}
+declare function createHost(venusApi: VenusAPI, isMock: boolean): 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 {
+        VenusPrototyping?: {
+            showAvatarEditorOverlay: (options: any, resolve: (args: any) => void) => Promise<void>;
+        };
+    }
+}
+declare class MockAvatarApi implements Avatar3dApi {
+    private readonly _venusApi;
+    private cachedAssets;
+    private cachedVersion;
+    constructor(venusApi: VenusAPI);
+    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 Venus H5 API
+ *
+ * This is the single source of truth for all H5 games.
+ *
+ * Usage in H5 games:
+ * ```typescript
+ * import type { VenusAPI } from '../../venus-api/types';
+ * declare const VenusAPI: VenusAPI;
+ * ```
+ */
+
+interface RecipeRequirementResult {
+    recipeId: string;
+    entity: string | null;
+    amount?: number;
+    inputs: Record<string, any>;
+    canAfford: boolean;
+    disabled: boolean;
+}
+interface VenusSimulationState {
+    inventory: Record<string, number | string>;
+    activeRuns: Array<{
+        id: string;
+        recipeId: string;
+        status: string;
+        startTime: number;
+        expiresAt: number;
+        inputs?: Record<string, number | string>;
+        outputs?: Record<string, number | string>;
+        entity?: string;
+    }>;
+    disabledRecipes: string[];
+}
+interface VenusSimulationEffect {
+    type: string;
+    target: any;
+    value: any;
+}
+interface VenusSimulationRecipe {
+    scope: 'player' | 'room' | 'actor';
+    inputs: Record<string, any>;
+    autoRestart?: boolean;
+    beginEffects?: VenusSimulationEffect[];
+    endEffects?: VenusSimulationEffect[];
+    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 VenusSimulationConfig {
+    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, VenusSimulationRecipe>;
+    fieldResolution?: Record<string, any>;
+    matchmaking?: Record<string, any>;
+}
+interface RecipeRequirementQuery {
+    recipeId: string;
+    entity?: string;
+    batchAmount?: number;
+}
+interface BatchRecipeRequirementsResult {
+    success: boolean;
+    results: RecipeRequirementResult[];
+    errors?: Array<any>;
+}
+interface VenusSimulationAPI {
+    isEnabled(): boolean;
+    getStateAsync(options?: {
+        roomId?: string;
+    }): Promise<VenusSimulationState>;
+    getConfigAsync(): Promise<VenusSimulationConfig>;
+    executeRecipeAsync(recipeId: string, inputs?: Record<string, any>, options?: any): Promise<any>;
+    executeScopedRecipeAsync(recipeId: string, entity: string, inputs?: Record<string, any>, roomId?: string, options?: any): Promise<any>;
+    getActiveRunsAsync(): Promise<any[]>;
+    collectRecipeAsync(runId: string): Promise<any>;
+    triggerRecipeChainAsync(triggerRecipeId: string, context?: any, roomId?: string): Promise<any>;
+    getRecipeRequirementsAsync(recipeId: string, entity?: string, amount?: number): Promise<RecipeRequirementResult>;
+    getBatchRecipeRequirementsAsync(queries: RecipeRequirementQuery[]): Promise<BatchRecipeRequirementsResult>;
+    getAvailableRecipesAsync(roomId?: string, includeActorRecipes?: boolean): Promise<Array<any>>;
+    resolveFieldValueAsync(entityId: string, fieldPath: string, entity?: string): Promise<any>;
+    getEntityMetadataAsync(entityId: string): Promise<any>;
+    getSlotContainersAsync(): Promise<Array<any>>;
+    getSlotAssignmentsAsync(containerId: string): Promise<Array<any>>;
+    assignItemToSlotAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    removeItemFromSlotAsync(containerId: string, slotId: string): Promise<any>;
+    getAvailableItemsAsync(containerId: string, slotId: string): Promise<Array<any>>;
+    calculatePowerPreviewAsync(containerId: string, slotId: string, candidateItemId: string): Promise<any>;
+    validateSlotAssignmentAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    executeBatchOperationsAsync(operations: Array<any>, validateOnly?: boolean): Promise<any>;
+    sumContributions(contributions: Record<string, any>): Record<string, number>;
+}
+interface VenusConfig {
+    user?: {
+        id: string;
+        username?: string;
+        languageCode: string;
+        locale: string;
+    };
+    profile?: {
+        id: string;
+        username: string;
+        avatarUrl?: string;
+        isAnonymous?: boolean;
+    };
+    device?: {
+        screenSize: {
+            width: number;
+            height: number;
+        };
+        viewportSize: {
+            width: number;
+            height: number;
+        };
+        orientation: string;
+        hapticsEnabled: boolean;
+    };
+    theme?: Record<string, any>;
+    environment?: {
+        isDevelopment: boolean;
+        platform: string;
+        platformVersion: string;
+        browserInfo?: {
+            browser: string;
+            isMobile: boolean;
+        };
+    };
+    ui: {
+        safeArea: {
+            top: number;
+            left: number;
+            right: number;
+            bottom: number;
+        };
+        controls: Record<string, any>;
+    };
+    rooms?: VenusRoomsConfig;
+}
+interface VenusRoomsConfig {
+    gameType?: string;
+    rulesPreset?: string;
+    matchmaking?: {
+        defaultCriteria?: Record<string, any>;
+        [key: string]: any;
+    };
+    createOptions?: Record<string, any>;
+    privateMatchDefaults?: {
+        createOptions?: Record<string, any>;
+        allowCustomCode?: boolean;
+    };
+    [key: string]: any;
+}
+interface ActionSheetOption {
+    label: string;
+    icon?: string;
+    id?: string;
+}
+interface Profile {
+    id: string;
+    username: string;
+    name?: string;
+    avatarUrl?: string | null;
+    isAnonymous?: boolean;
+}
+interface VenusAPI {
+    config: VenusConfig;
+    launchParams: Record<string, string>;
+    _mock: any;
+    _bootstrap: {
+        apiInjected: boolean;
+        venus: any;
+    };
+    initializeAsync(options?: InitializationOptions): Promise<InitializationContext>;
+    simulation: VenusSimulationAPI;
+    leaderboard: LeaderboardApi;
+    log(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    isAvailable(): boolean;
+    isMobile(): boolean;
+    isWeb(): boolean;
+    isMock(): boolean;
+    /**
+     * @deprecated Please use the new analytics API. VenusAPI.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>;
+    getCurrentProfile(): Profile;
+    getLaunchParams(): Record<string, string>;
+    /**
+     * @deprecated Please use the popups API. (e.g, VenusAPI.popups)
+     */
+    showToast(message: string | {
+        message: string;
+        duration?: number;
+        variant?: string;
+        action?: {
+            label: string;
+        };
+    }): Promise<boolean>;
+    /**
+     * @deprecated Please use the popups API. (e.g, VenusAPI.popups)
+     */
+    showAlert(options: {
+        title: string;
+        message: string;
+        buttonText?: string;
+    }): Promise<void>;
+    /**
+     * @deprecated Please use the popups API. (e.g, VenusAPI.popups)
+     */
+    showConfirm(options: {
+        title: string;
+        message: string;
+        confirmText?: string;
+        cancelText?: string;
+    }): Promise<boolean>;
+    /**
+     * @deprecated Please use the popups API. (e.g, VenusAPI.popups)
+     */
+    showActionSheet(options: {
+        title: string;
+        message?: string;
+        options: ActionSheetOption[];
+        cancelButtonText?: string;
+        disableCancel?: boolean;
+    }): Promise<string | number | null>;
+    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>;
+    getPostInteractionsAsync(): Promise<any>;
+    getPostInteractions(): Promise<any>;
+    toggleLikeAsync(): Promise<any>;
+    toggleFollowAsync(): Promise<any>;
+    openCommentsAsync(options?: any): Promise<void>;
+    /**
+     * @deprecated Please use the ads API. (e.g, VenusAPI.ads)
+     */
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    /**
+     * @deprecated Please use the ads API. (e.g, VenusAPI.ads)
+     */
+    showRewardedAdAsync(): Promise<boolean>;
+    requestTimeAsync(): Promise<{
+        serverTime: number;
+    }>;
+    getFutureTimeAsync(options: {
+        days?: number;
+        hours?: number;
+        minutes?: number;
+        timeOfDay?: any;
+        timezone?: string;
+    }): Promise<number>;
+    formatTime(timestamp: number, options?: any): string;
+    formatNumber(value: number, options?: any): string;
+    /**
+     * @deprecated Please use the cdn API. VenusAPI.cdn
+     */
+    fetchFromCdn(url: string, options?: RequestInit): Promise<Response>;
+    /**
+     * @deprecated Please use the cdn API. VenusAPI.cdn
+     */
+    resolveAssetUrl(path: string): string;
+    /**
+     * @deprecated Please use the cdn API. VenusAPI.cdn
+     */
+    resolveAvatarAssetUrl(path: string): string;
+    /**
+     * @deprecated Please use the cdn API. VenusAPI.cdn
+     */
+    resolveSharedLibUrl(path: string): string;
+    /**
+     * @deprecated Please use the cdn API. VenusAPI.cdn
+     */
+    getAssetCdnBaseUrl(): 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: {
+        create(options: any): Promise<VenusRoom>;
+        joinOrCreate(options: any): Promise<{
+            action: 'created' | 'joined';
+            room: VenusRoom;
+            playersJoined: number;
+        }>;
+        joinByCode(roomCode: string): Promise<VenusRoom>;
+        list(includeArchived?: boolean): Promise<VenusRoom[]>;
+        subscribeToRoom(room: VenusRoom, options: {
+            onData?: (event: any) => void;
+            onMessages?: (event: any) => void;
+            onMoves?: (event: any) => void;
+            onGameEvents?: (event: any) => void;
+        }): () => void;
+        proposeMove(room: VenusRoom, proposalPayload: {
+            gameSpecificState: any;
+            moveType: string;
+            clientContext?: Record<string, any>;
+            clientProposalId?: string;
+        }): Promise<{
+            proposedMoveId: string;
+        }>;
+        validateMove(room: VenusRoom, moveId: string, isValid: boolean, reason?: string, validatorId?: string): Promise<any>;
+        updateRoomData(room: VenusRoom, updates: any, merge?: boolean): Promise<any>;
+        getRoomData(room: VenusRoom): Promise<any>;
+        sendRoomMessage(room: VenusRoom, messageData: any): Promise<string>;
+        startRoomGame(room: VenusRoom, gameConfig?: any, turnOrder?: any): Promise<any>;
+        leaveRoom(room: VenusRoom): Promise<any>;
+    };
+    notifyCleanupComplete(): void;
+    RoomEvents: {
+        OPTIMISTIC_GAME_STATE_UPDATED: string;
+        PROPOSED_MOVE_VALIDATION_UPDATED: string;
+    };
+    numbers?: {
+        normalize(value: string | number): string;
+    };
+    iap: IapApi;
+    cdn: CdnApi;
+    ads: AdsApi;
+    ai: AiApi;
+    popups: PopupsApi;
+    analytics: AnalyticsApi;
+    sharedAssets: SharedAssetsApi;
+    preloader: PreloaderApi;
+    notifications: NotificationsApi;
+    lifecycles: LifecycleApi;
+    social: SocialApi;
+}
+
+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 Recipe as $, type AnalyticsApi as A, type Subscription as B, type CdnApi as C, type AwakeCallback as D, type Experiment as E, type FetchBlobOptions as F, type GetFutureTimeOptions as G, type Host as H, type PauseCallback as I, type ResumeCallback as J, type QuitCallback as K, type LifecycleApi as L, type SimulationApi as M, type NavigationApi as N, type VenusSimulationConfig as O, type PushAppOptions as P, type QuitOptions as Q, type RpcRequest as R, type StorageApi as S, type TimeApi as T, type ExecuteRecipeOptions as U, type VenusAPI as V, type CollectRecipeResult as W, type GetActiveRunsOptions as X, type ExecuteScopedRecipeResult as Y, type GetAvailableRecipesOptions as Z, type GetAvailableRecipesResult as _, type RpcResponse as a, type LeaderboardEntry as a$, type GetBatchRecipeRequirements as a0, type TriggerRecipeChainOptions as a1, type RecipeRequirementResult as a2, VenusTransport as a3, type LoggingApi as a4, type IapApi as a5, type SpendCurrencyOptions as a6, type LoadEmbeddedAssetsResponse as a7, type SharedAssetsApi as a8, type LeaderboardApi as a9, type AiMessage as aA, type Asset as aB, type Category as aC, MockAvatarApi as aD, type TimeIntervalTriggerInput as aE, type NotificationTriggerInput as aF, type OnRequestCallback as aG, type OnResponseCallback as aH, type OnNotificationCallback as aI, type RpcTransport as aJ, VenusRoom as aK, type CreateRoomOptions as aL, type JoinOrCreateResult as aM, type RoomSubscriptionOptions as aN, type ProposeMovePayload as aO, type ProposeMoveResult as aP, type ValidateMoveResult as aQ, type ExecuteScopedRecipeOptions as aR, type RecipeInfo as aS, RpcSharedAssetsApi as aT, type LoadEmbeddedAssetsRequest as aU, type LeaderboardModeConfig as aV, type LeaderboardPeriodType as aW, type LeaderboardPeriodConfig as aX, type LeaderboardAntiCheatConfig as aY, type LeaderboardDisplaySettings as aZ, type LeaderboardConfig as a_, type StartRunResult as aa, type SubmitScoreOptions as ab, type SubmitScoreResult as ac, type GetLeaderboardOptions as ad, type LeaderboardResponse as ae, type PlayerStatsOptions as af, type PlayerStats as ag, type LeaderboardHighlightOptions as ah, type LeaderboardHighlightResponse as ai, type PreloaderApi as aj, type Avatar3dApi as ak, type AssetManifest as al, type Avatar3dConfig as am, type ShowEditorOptions as an, type Avatar3dEdits as ao, type SocialApi as ap, type ShareMetadata as aq, type ShareLinkResult as ar, type SocialQRCodeOptions as as, type QRCodeResult as at, type AdsApi as au, type PostApi as av, type RoomsApi as aw, type InitializationOptions as ax, type InitializationContext as ay, type HudInsets as az, type RpcNotification as b, type LeaderboardHighlightContext as b0, type InitializeOptions as b1, createHost as b2, type VenusSimulationState as b3, type VenusSimulationEffect as b4, type VenusSimulationRecipe as b5, type RecipeRequirementQuery as b6, type BatchRecipeRequirementsResult as b7, type VenusSimulationAPI as b8, type VenusConfig as b9, type VenusRoomsConfig as ba, type ActionSheetOption as bb, RpcClient as c, type NavigationStackInfo as d, type NotificationsApi as e, type ScheduleLocalNotification as f, type ScheduleNotificationOptions as g, type PopupsApi as h, type ActionSheetItem as i, type ShowActionSheetOptions as j, type ShowAlertOptions as k, type ShowConfirmOptions as l, type ShowToastOptions as m, type ShowInterstitialAdOptions as n, type ShowRewardedAdOptions as o, type ProfileApi as p, type Profile as q, type SubPath as r, type ServerTimeData as s, type AiApi as t, type AiChatCompletionRequest as u, type AiChatCompletionData as v, type HapticsApi as w, HapticFeedbackStyle as x, type FeaturesApi as y, type SleepCallback as z };