@series-inc/venus-sdk 2.2.0

package/dist/index.d.mts

@@ -0,0 +1,702 @@
+import { A as AnalyticsApi, V as VenusAPI, N as NavigationApi, Q as QuitOptions, a as NavigationStackInfo, P as PushAppOptions, b as PopupsApi, c as ActionSheetItem, S as ShowActionSheetOptions, d as ShowAlertOptions, e as ShowConfirmOptions, f as ShowToastOptions, g as Profile, h as AiApi, i as AiChatCompletionRequest, j as AiChatCompletionData, H as HapticsApi, k as HapticFeedbackStyle, L as LifecycleApi, O as OnCleanupCallback, l as OnShowCallback, m as OnHideCallback, n as OnPauseCallback, o as OnPlayCallback, p as OnQuitCallback, q as OnResumeCallback, r as PlayContext, s as ShowContext, t as VenusSimulationConfig, R as RecipeRequirementResult, I as IapApi, u as SpendCurrencyOptions, v as AdsApi, w as Avatar3dApi, C as CdnApi, x as AssetManifest, y as Avatar3dConfig, z as ShowEditorOptions, B as Avatar3dEdits, D as SubPath, F as FetchBlobOptions } from './AdsApi-BbMHVPYM.mjs';
+export { E as AiMessage, G as Asset, J as Category, K as Insets, M as MockAvatarApi, T as PostInfo } from './AdsApi-BbMHVPYM.mjs';
+
+declare class MockAnalyticsApi implements 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;
+}
+
+type RpcMessage = RpcRequest | RpcResponse | RpcNotification;
+
+declare class RpcAnalyticsApi implements AnalyticsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    recordCustomEvent(eventName: string, payload: Record<string, any>): Promise<void>;
+    trackFunnelStep(stepNumber: number, stepName: string, funnelName?: string): Promise<void>;
+}
+
+declare function initializeAnalytics(venusApiInstance: VenusAPI, host: Host): void;
+
+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>;
+}
+
+declare class MockNavigationApi implements NavigationApi {
+    private readonly venusApi;
+    constructor(venusApi: VenusAPI);
+    requestPopOrQuit(options?: QuitOptions): Promise<boolean>;
+    getStackInfo(): NavigationStackInfo;
+    popApp(): Promise<void>;
+    pushApp(appId: string, options?: PushAppOptions): Promise<void>;
+    private log;
+}
+
+declare class RpcNavigationApi implements NavigationApi {
+    private readonly venusApi;
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient, venusApi: VenusAPI);
+    requestPopOrQuit(options?: QuitOptions): Promise<boolean>;
+    getStackInfo(): NavigationStackInfo;
+    popApp(): Promise<void>;
+    pushApp(appId: string, options?: PushAppOptions): Promise<void>;
+}
+
+declare function initializeStackNavigation(venusApi: VenusAPI, host: Host): void;
+
+interface ScheduleLocalNotificationOptions {
+    priority?: number;
+    groupId?: string;
+    payload?: Record<string, any>;
+}
+interface ScheduleLocalNotification {
+    id: string;
+    title?: string | null;
+    body?: string | null;
+    payload?: Record<string, any>;
+}
+interface NotificationsApi {
+    scheduleLocalNotification(title: string, body: string, options?: ScheduleLocalNotificationOptions): Promise<string | null>;
+    cancelLocalNotification(notificationId: string): Promise<boolean>;
+    getAllScheduledLocalNotifications(): Promise<ScheduleLocalNotification[]>;
+    isLocalNotificationsEnabled(): Promise<boolean>;
+    setLocalNotificationsEnabled(enabled: boolean): Promise<boolean>;
+}
+
+declare class MockNotificationsApi implements NotificationsApi {
+    private readonly venusApi;
+    constructor(venusApi: VenusAPI);
+    cancelLocalNotification(notificationId: string): Promise<boolean>;
+    getAllScheduledLocalNotifications(): Promise<ScheduleLocalNotification[]>;
+    isLocalNotificationsEnabled(): Promise<boolean>;
+    scheduleLocalNotification(title: string, body: string, options?: ScheduleLocalNotificationOptions): Promise<string | null>;
+    setLocalNotificationsEnabled(enabled: boolean): Promise<boolean>;
+}
+
+declare function initializeLocalNotifications(venusApi: VenusAPI, host: Host): void;
+
+declare class RpcPopupsApi implements PopupsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    showActionSheet(items: ActionSheetItem[], options?: ShowActionSheetOptions): Promise<string | number | null>;
+    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>;
+}
+interface ShowToastResponse {
+    shown: boolean;
+    actionTriggered: boolean;
+}
+
+interface MockOverlay {
+    container: HTMLElement;
+    elements: OverlayElements;
+    adOverlay: HTMLElement;
+    actionSheetOverlay: HTMLElement;
+    appVisibilityState: 'visible' | 'hidden';
+    showAdOverlay: () => Promise<boolean>;
+    showActionSheet: (items: ActionSheetItem[], options?: ShowActionSheetOptions) => Promise<string | number | null>;
+}
+interface OverlayElements {
+    visibility: HTMLElement;
+    play: HTMLElement;
+    close: HTMLElement;
+    [id: string]: HTMLElement;
+}
+
+declare class MockPopupsApi implements PopupsApi {
+    private readonly overlay;
+    constructor(override: MockOverlay);
+    showActionSheet(items: ActionSheetItem[], options?: ShowActionSheetOptions): Promise<string | number | null>;
+    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>;
+}
+
+declare function initializePopups(venusApi: VenusAPI, host: Host): void;
+
+interface ProfileApi {
+    getCurrentProfile(): Profile;
+}
+
+declare class HostProfileApi implements ProfileApi {
+    getCurrentProfile(): Profile;
+}
+
+declare class MockProfileApi implements ProfileApi {
+    getCurrentProfile(): Profile;
+}
+
+declare function initializeProfile(venusApi: VenusAPI, host: Host): void;
+
+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>;
+}
+
+declare class HostTimeApi implements TimeApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    requestTimeAsync(): Promise<ServerTimeData>;
+    formatTime(timestamp: number, options?: any): string;
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    getFutureTimeAsync(options?: GetFutureTimeOptions): Promise<number>;
+}
+
+declare function isPacificDaylightTime(date: Date): boolean;
+
+declare class MockTimeApi implements TimeApi {
+    private readonly venusApi;
+    constructor(venusApi: VenusAPI);
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    formatTime(timestamp: number, options?: any): string;
+    getFutureTimeAsync(options?: GetFutureTimeOptions): Promise<number>;
+    requestTimeAsync(): Promise<ServerTimeData>;
+    private getLocale;
+}
+
+declare function initializeTime(venusApi: VenusAPI, host: Host): void;
+
+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 ShareContext {
+    message?: string;
+    title?: string;
+    senderId?: string | null;
+    additionalInfo?: Record<string, any>;
+}
+interface SharePostResult {
+    shared: true;
+    platform: string;
+    customMessage?: string;
+}
+interface PostApi {
+    getPostInfo(): Promise<PostInfo>;
+    toggleLikeAsync(): Promise<ToggleLikeResult>;
+    openCommentsAsync(): Promise<OpenCommentsResult>;
+    toggleFollowAsync(): Promise<ToggleFollowResult>;
+    sharePostAsync(context: ShareContext): Promise<SharePostResult>;
+}
+
+declare class RpcAiApi implements AiApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    requestChatCompletionAsync(request: AiChatCompletionRequest): Promise<AiChatCompletionData>;
+    getAvailableCompletionModels(): Promise<Array<string>>;
+}
+
+declare class MockAiApi implements AiApi {
+    requestChatCompletionAsync(request: AiChatCompletionRequest): Promise<AiChatCompletionData>;
+    getAvailableCompletionModels(): Promise<Array<string>>;
+}
+
+declare function initializeAi(venusApi: VenusAPI, host: Host): void;
+
+declare class RpcHapticsApi implements HapticsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    triggerHapticAsync(style: HapticFeedbackStyle): Promise<void>;
+}
+
+declare class MockHapticsApi implements HapticsApi {
+    private readonly venusApi;
+    constructor(venusApi: VenusAPI);
+    triggerHapticAsync(style: HapticFeedbackStyle): Promise<void>;
+}
+
+declare function initializeHaptics(venusApi: VenusAPI, host: Host): 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>;
+}
+
+declare class RpcFeaturesApi implements FeaturesApi {
+    private readonly rpcClient;
+    constructor(rcpClient: RpcClient);
+    getExperiment(experimentName: string): Promise<Experiment | null>;
+    getFeatureFlag(flagName: string): Promise<boolean>;
+    getFeatureGate(gateName: string): Promise<boolean>;
+}
+
+declare class MockFeaturesApi implements FeaturesApi {
+    getExperiment(experimentName: string): Promise<Experiment | null>;
+    getFeatureFlag(flagName: string): Promise<boolean>;
+    getFeatureGate(gateName: string): Promise<boolean>;
+}
+
+declare function initializeFeaturesApi(venusApi: VenusAPI, host: Host): void;
+
+declare class MockLifecycleApi implements LifecycleApi {
+    private playCallbacks;
+    private pauseCallbacks;
+    private resumeCallbacks;
+    private quitCallbacks;
+    private showCallbacks;
+    private hideCallbacks;
+    onCleanup(callback: OnCleanupCallback): void;
+    onShow(callback: OnShowCallback): void;
+    onHide(callback: OnHideCallback): void;
+    onPause(callback: OnPauseCallback): void;
+    onPlay(callback: OnPlayCallback): void;
+    onQuit(callback: OnQuitCallback): void;
+    onResume(callback: OnResumeCallback): void;
+    triggerOnPlayCallbacks(context: PlayContext): void;
+    triggerOnPauseCallbacks(): void;
+    triggerOnResumeCallbacks(): void;
+    triggerOnShowCallbacks(context: ShowContext): void;
+    triggerOnHideCallbacks(): void;
+    triggerOnQuitCallbacks(): void;
+}
+
+declare class RpcLifecycleApi implements LifecycleApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    onCleanup(callback: OnCleanupCallback): void;
+    onHide(callback: OnHideCallback): void;
+    onPause(callback: OnPauseCallback): void;
+    onPlay(callback: OnPlayCallback): void;
+    onQuit(callback: OnQuitCallback): void;
+    onResume(callback: OnResumeCallback): void;
+    onShow(callback: OnShowCallback): void;
+}
+
+declare function initializeLifecycleApi(venusApi: VenusAPI, host: Host): void;
+
+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>;
+}
+
+declare class RpcSimulationApi implements SimulationApi {
+    private readonly rpcClient;
+    private _simulationConfig;
+    constructor(rpcClient: RpcClient);
+    validateSlotAssignmentAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    sumContributions(contributions: Record<string, any>): Record<string, number>;
+    executeBatchOperationsAsync(operations: Array<any>, validateOnly?: boolean): Promise<any>;
+    getAvailableItemsAsync(containerId: string, slotId: string): Promise<Array<any>>;
+    calculatePowerPreviewAsync(containerId: string, slotId: string, candidateItemId: string): Promise<any>;
+    assignItemToSlotAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    removeItemFromSlotAsync(containerId: string, slotId: string): Promise<any>;
+    getSlotContainersAsync(): Promise<any>;
+    getSlotAssignmentsAsync(containerId: string): Promise<any>;
+    getStateAsync(roomId?: string): Promise<any>;
+    getConfigAsync(roomId?: string): Promise<VenusSimulationConfig>;
+    executeRecipeAsync(recipeId: string, inputs?: any, options?: ExecuteRecipeOptions): Promise<any>;
+    collectRecipeAsync(runId: string): Promise<CollectRecipeResult>;
+    getActiveRunsAsync(options?: GetActiveRunsOptions): Promise<any>;
+    executeScopedRecipeAsync(recipeId: string, entity: string, inputs?: any, options?: any): Promise<ExecuteScopedRecipeResult>;
+    getAvailableRecipesAsync(options?: GetAvailableRecipesOptions): Promise<GetAvailableRecipesResult>;
+    getRecipeRequirementsAsync(recipe: Recipe): Promise<any>;
+    getBatchRecipeRequirementsAsync(recipes: Recipe[]): Promise<GetBatchRecipeRequirements>;
+    triggerRecipeChainAsync(recipeId: string, options?: TriggerRecipeChainOptions): Promise<any>;
+    getEntityMetadataAsync(entityId: string): Promise<any>;
+    resolveFieldValueAsync(entityId: string, fieldPath: string, entity?: string): Promise<any>;
+}
+
+declare class MockSimulationApi implements SimulationApi {
+    private readonly mockSimulationConfigs;
+    private readonly mockSimulationStates;
+    private readonly mockActiveTimers;
+    private readonly appId;
+    private readonly providedSimulationConfig;
+    constructor(simulationConfig?: VenusSimulationConfig | null);
+    sumContributions(contributions: Record<string, any>): Record<string, number>;
+    validateSlotAssignmentAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    executeBatchOperationsAsync(operations: Array<any>, validateOnly?: boolean): Promise<any>;
+    getAvailableItemsAsync(containerId: string, slotId: string): Promise<Array<any>>;
+    calculatePowerPreviewAsync(containerId: string, slotId: string, candidateItemId: string): Promise<any>;
+    getSlotContainersAsync(): Promise<any>;
+    getSlotAssignmentsAsync(containerId: string): Promise<any>;
+    resolveFieldValueAsync(entityId: string, fieldPath: string, entity?: string): Promise<any>;
+    getEntityMetadataAsync(entityId: string): Promise<any>;
+    collectRecipeAsync(runId: string): Promise<CollectRecipeResult>;
+    executeRecipeAsync(recipeId: string, inputs?: any, options?: ExecuteRecipeOptions): Promise<any>;
+    executeScopedRecipeAsync(recipeId: string, entity: string, inputs?: any, options?: any): Promise<ExecuteScopedRecipeResult>;
+    getActiveRunsAsync(options?: GetActiveRunsOptions): Promise<any>;
+    getAvailableRecipesAsync(options?: GetAvailableRecipesOptions): Promise<GetAvailableRecipesResult>;
+    getBatchRecipeRequirementsAsync(recipes: Recipe[]): Promise<GetBatchRecipeRequirements>;
+    getRecipeRequirementsAsync(recipe: Recipe): Promise<RecipeRequirementResult>;
+    triggerRecipeChainAsync(recipeId: string, options?: TriggerRecipeChainOptions): Promise<any>;
+    private log;
+    private executeRecipe;
+    private initializeSimulationState;
+    private generateRunId;
+    private completeRun;
+    private createSeededRandom;
+    private applyEffects;
+    getConfigAsync(): Promise<any>;
+    getStateAsync(roomId?: string): Promise<any>;
+    assignItemToSlotAsync(containerId: string, slotId: string, itemId: string): Promise<any>;
+    removeItemFromSlotAsync(containerId: string, slotId: string): Promise<any>;
+}
+
+declare function initializeSimulation(venusApi: VenusAPI, host: Host): void;
+
+interface RoomsApi {
+    createRoom(options: any): Promise<any>;
+    join(roomId: string): Promise<any>;
+}
+
+interface LoggingApi {
+    logDebug(message: string, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+}
+
+declare class MockLoggingApi implements LoggingApi {
+    logDebug(message?: any, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+}
+
+declare class RpcLoggingApi implements LoggingApi {
+    private readonly host;
+    private readonly rpcClient;
+    constructor(host: Host, rpcClient: RpcClient);
+    logDebug(message: string, ...args: any[]): void;
+    logError(message: string, ...args: any[]): void;
+    private buildMessage;
+    private toStringArg;
+}
+
+declare function initializeLoggingApi(venusApi: VenusAPI, host: Host): void;
+
+declare class RpcIapApi implements IapApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    getHardCurrencyBalance(): Promise<number>;
+    spendCurrency(productId: string, cost: number, options?: SpendCurrencyOptions): Promise<void>;
+}
+
+declare class MockIapApi implements IapApi {
+    private _hardCurrency;
+    get hardCurrency(): number;
+    set hardCurrency(value: number);
+    spendCurrency(productId: string, cost: number, options?: SpendCurrencyOptions): Promise<void>;
+    getHardCurrencyBalance(): Promise<number>;
+}
+
+declare function initializeIap(venusApiInstance: VenusAPI, host: Host): void;
+
+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 isInitialized: boolean;
+    initialize(): Promise<void>;
+    readonly iap: IapApi;
+}
+
+declare class RpcAvatarApi implements Avatar3dApi {
+    private readonly venusApi;
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient, venusApi: VenusAPI);
+    downloadAssetPaths(): Promise<Record<string, string[]>>;
+    downloadManifest(): Promise<AssetManifest>;
+    loadAvatar(avatarId?: string): Promise<Avatar3dConfig | null>;
+    saveAvatar(config: Avatar3dConfig): Promise<string>;
+    deleteAvatar(): Promise<void>;
+    showEditor(options?: ShowEditorOptions): Promise<Avatar3dEdits>;
+    private fetchFromCdn;
+    private log;
+}
+
+declare function initializeAvatar3d(venusApi: VenusAPI, host: Host): void;
+
+declare class HostCdnApi implements CdnApi {
+    private readonly baseUrl;
+    constructor(baseUrl: string);
+    fetchBlob(path: SubPath, options?: FetchBlobOptions): Promise<Blob>;
+    fetchFromCdn(url: string, request?: RequestInit): Promise<Response>;
+    getAssetCdnBaseUrl(): string;
+    resolveAssetUrl(subPath: string): string;
+    resolveAvatarAssetUrl(subPath: string): string;
+    resolveSharedLibUrl(subPath: string): string;
+}
+
+declare class MockCdnApi implements CdnApi {
+    private readonly baseUrl;
+    constructor();
+    fetchBlob(path: SubPath, options?: FetchBlobOptions): Promise<Blob>;
+    getAssetCdnBaseUrl(): string;
+    resolveAssetUrl(subPath: string): string;
+    resolveAvatarAssetUrl(subPath: string): string;
+    resolveSharedLibUrl(subPath: string): string;
+    fetchFromCdn(url: string, options?: RequestInit): Promise<Response>;
+}
+
+declare function initializeCdn(venusApi: VenusAPI, host: Host): void;
+
+declare class RpcAdsApi implements AdsApi {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    showInterstitialAd(): Promise<boolean>;
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    showRewardedAdAsync(): Promise<boolean>;
+}
+
+declare class MockAdsApi implements AdsApi {
+    private mockOverlay;
+    constructor(mockOverlay: MockOverlay);
+    isRewardedAdReadyAsync(): Promise<boolean>;
+    showRewardedAdAsync(): Promise<boolean>;
+    showInterstitialAd(): Promise<boolean>;
+    private log;
+}
+
+declare function initializeAds(venusApiInstance: VenusAPI, host: Host): void;
+
+type StorageType = 'globalStorage' | 'deviceCache' | 'appStorage';
+declare function createMockStorageApi(storageType: StorageType, appUrl?: string): MockStorageApi;
+declare class MockStorageApi implements StorageApi {
+    private readonly prefix;
+    private readonly syncDelay;
+    constructor(prefix: string, syncDelay: number);
+    clear(): Promise<void>;
+    getAllItems(): Promise<string[]>;
+    getItem(key: string): Promise<string | null>;
+    key(index: number): Promise<string | null>;
+    length(): Promise<number>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, item: string): Promise<void>;
+    setMultipleItems(entries: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+    removeMultipleItems(keys: string[]): Promise<void>;
+    private buildKey;
+    private extractKey;
+    private keys;
+    private simulateSyncDelay;
+}
+
+interface MethodIds {
+    clear: string;
+    getItem: string;
+    getKey: string;
+    length: string;
+    removeItem: string;
+    setItem: string;
+    getAllItems?: string;
+    removeMultipleItems?: string;
+    setMultipleItems?: string;
+}
+declare class RpcStorageApi implements StorageApi {
+    private readonly rpcClient;
+    private readonly methodIds;
+    constructor(rpcClient: RpcClient, methodIds: MethodIds);
+    clear(): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    key(index: number): Promise<string | null>;
+    length(): Promise<number>;
+    removeItem(key: string): Promise<void>;
+    removeMultipleItems(keys: string[]): Promise<void>;
+    getAllItems(): Promise<string[]>;
+    setMultipleItems(items: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+}
+
+declare function initializeStorage(venusApiInstance: VenusAPI, host: Host): void;
+
+declare const SDK_VERSION: string;
+
+export { ActionSheetItem, AdsApi, AiApi, AiChatCompletionData, AiChatCompletionRequest, AnalyticsApi, AssetManifest, Avatar3dApi, Avatar3dConfig, Avatar3dEdits, CdnApi, type CollectRecipeResult, type ExecuteRecipeOptions, type ExecuteScopedRecipeOptions, type ExecuteScopedRecipeResult, type Experiment, type FeaturesApi, FetchBlobOptions, type GetActiveRunsOptions, type GetAvailableRecipesOptions, type GetAvailableRecipesResult, type GetBatchRecipeRequirements, type GetFutureTimeOptions, HapticFeedbackStyle, HapticsApi, HostCdnApi, HostProfileApi, HostTimeApi, IapApi, LifecycleApi, type LoggingApi, type MethodIds, MockAdsApi, MockAiApi, MockAnalyticsApi, MockCdnApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockProfileApi, MockSimulationApi, MockStorageApi, MockTimeApi, NavigationApi, NavigationStackInfo, type NotificationsApi, OnCleanupCallback, OnHideCallback, type OnNotificationCallback, OnPauseCallback, OnPlayCallback, OnQuitCallback, type OnRequestCallback, type OnResponseCallback, OnResumeCallback, OnShowCallback, PlayContext, PopupsApi, type ProfileApi, PushAppOptions, QuitOptions, type Recipe, type RecipeInfo, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLifecycleApi, RpcLoggingApi, type RpcMessage, RpcNavigationApi, type RpcNotification, RpcPopupsApi, type RpcRequest, type RpcResponse, RpcSimulationApi, RpcStorageApi, type RpcTransport, SDK_VERSION, type ScheduleLocalNotification, type ScheduleLocalNotificationOptions, type ServerTimeData, ShowActionSheetOptions, ShowAlertOptions, ShowConfirmOptions, ShowContext, ShowEditorOptions, ShowToastOptions, type ShowToastResponse, type SimulationApi, SpendCurrencyOptions, type StorageApi, type StorageType, SubPath, type Subscription, type TimeApi, type TriggerRecipeChainOptions, createMockStorageApi, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializeProfile, initializeSimulation, initializeStackNavigation, initializeStorage, initializeTime, isPacificDaylightTime };