@arkadiuminc/sdk 0.0.55 → 2.0.0

package/README.md

@@ -22,13 +22,30 @@ const Game = {
 async function main() {
   Game.pause();
   const { ads } = await getInstance(Env.DEV);
-  await ads.interstitial.show();
+  await ads.showInterstitialAd();
   Game.resume();
 }
 
 main();
 ```
 
+## using the sandbox with a local game sdk
+
+```
+cd arkadium-sdk
+http-server . -p 8080 -c-1 --cors
+npm run build-fast
+
+cd arkadium-dev-portal
+# in the sandbox.tsx file, change SDK_PATH to 'http://localhost:8080/dist/arena/arena-sdk.umd.js'
+npm run start
+# visit the dev portal sandbox page: http://localhost:3511/sandbox
+```
+
+set the following fields:
+- gameId: arkadium-sdk-test-game
+- gameURL: http://localhost:8080/example/simple/analytics.html
+
 
 ## Reference documents
 

package/dist/pkg/api/core/rpc.d.ts

@@ -8,9 +8,11 @@ declare class RpcPublisher {
     private rpcCallbacks;
     private target;
     private instanceId;
+    private eventListener;
     constructor(instanceId: string);
     init(target: any): void;
     sendMessage(message: RpcRequest): Promise<any>;
+    unsubscribe(): void;
     private genId;
     private processMessages;
     private registerCb;
@@ -18,11 +20,13 @@ declare class RpcPublisher {
 }
 declare class RpcSubscriber {
     private instanceId;
+    private eventListener;
     constructor(instanceId: string);
     private registry;
     private target;
     init(target: any): void;
     addToRegistry(module: string, name: string, bindTo: any, fn: any): void;
+    unsubscribe(): void;
     private getId;
     private processMessages;
     private sendResponse;

package/dist/pkg/api/features/ads/display-ad.d.ts

@@ -1,9 +1,8 @@
 export declare class DisplayAd {
-    private lastRefreshDate;
-    private adRefreshTimeMs;
     static getInstance(): DisplayAd;
     protected _scriptLoaded: Promise<void>;
+    private ads;
     constructor();
-    show(adId: string, dimensions: number[][]): void;
-    private refresh;
+    removeAllAds(): void;
+    show(containerId: string, dimensions: number[][]): void;
 }

package/dist/pkg/api/features/ads/index.d.ts

@@ -1,18 +1,17 @@
 import { RpcProvider } from '../../core/rpc';
 import { ApiEnv } from '../backend/backend.api';
-import { UserStateApi } from '../user-state/user-state.api';
-declare type InterstitialAdContract = {
-    show(options: {
+import { Auth } from '../auth/';
+export interface GameAdsContract {
+    showInterstitialAd(options: {
         duration?: number;
     }): Promise<void>;
-};
-declare type RewardAdContract = {
-    show(options: {
+    showRewardAd(options: {
         duration?: number;
     }): Promise<{
         value: number;
     }>;
-};
+    showBannerAd(adId: string, dimensions: AdTypes[]): any;
+}
 export declare enum AdTypes {
     AD_300x250 = "AD_300x250",
     AD_250x250 = "AD_250x250",
@@ -26,17 +25,33 @@ export declare enum AdTypes {
     AD_468x60 = "AD_468x60",
     AD_160x600 = "AD_160x600"
 }
-declare class BannerAds {
-    private displayAd;
-    show(adId: string, dimensions: AdTypes[]): void;
-    private matchAdSize;
+export declare class GameAds implements GameAdsContract {
+    private interstitial;
+    private rewarded;
+    constructor(rpcProvider: RpcProvider, auth: Auth);
+    showInterstitialAd({ duration }?: {
+        duration?: number | undefined;
+    }): Promise<void>;
+    showRewardAd({ duration }?: {
+        duration?: number | undefined;
+    }): Promise<{
+        value: number;
+    }>;
+    showBannerAd(): void;
 }
-export declare class AdsApi {
-    interstitial: InterstitialAdContract;
-    rewarded: RewardAdContract;
-    bannerAd: BannerAds | undefined;
-    constructor(interstitial: InterstitialAdContract, rewarded: RewardAdContract, bannerAd: BannerAds | undefined);
-    static getArenaApi(rpcProvider: RpcProvider, userStateApi: UserStateApi): AdsApi;
-    static getGameApi(rpcProvider: RpcProvider, env: ApiEnv): AdsApi;
+export declare class GameAdsProxy implements GameAdsContract {
+    bannerSizes: typeof AdTypes;
+    private interstitial;
+    private rewarded;
+    private banner;
+    constructor(rpcProvider: RpcProvider, env: ApiEnv, auth: Auth);
+    showInterstitialAd({ duration }?: {
+        duration?: number | undefined;
+    }): Promise<void>;
+    showRewardAd({ duration }?: {
+        duration?: number | undefined;
+    }): Promise<{
+        value: number;
+    }>;
+    showBannerAd(adId: string, dimensions: AdTypes[]): any;
 }
-export {};

package/dist/pkg/api/features/ads/video-ad.d.ts

@@ -2,6 +2,7 @@ import { ApiEnv } from "../backend/backend.api";
 export declare class VideoAd {
     static getInstance(): VideoAd;
     protected _scriptLoaded: Promise<void>;
+    protected timer: any;
     constructor();
     interstitial({ duration, env }: {
         duration?: number | undefined;

package/dist/pkg/api/features/analytics/analytics.api.d.ts

@@ -1,12 +1,12 @@
 import { RpcProvider } from '../../core/rpc';
-import { GameIdReaderContract } from '../environment/environment.api';
 import { AnalyticProviderEnum, IAnalyticConfig } from './defs';
 import { DimensionsObject } from './dimensions';
+import { IHost } from '../host';
 interface EnvironmentVersion {
-    gameKey: string;
-    gameVersion: string;
-    nestVersion: string;
-    sdkVersion: string;
+    GameKey: string;
+    GameVersion: string;
+    NestVersion: string;
+    SdkVersion: string;
 }
 export interface AnalyticsApiContract {
     setGameVersion(v: string): Promise<void>;
@@ -18,12 +18,12 @@ export interface AnalyticsApiContract {
     trackException(exception: Error): Promise<void>;
 }
 export declare class AnalyticsApi implements AnalyticsApiContract {
-    private gameReader;
+    private host;
     private rpcProvider;
     private providers;
     private activeProvidersTypes;
     private info;
-    constructor(gameReader: GameIdReaderContract, rpcProvider: RpcProvider);
+    constructor(host: IHost, rpcProvider: RpcProvider);
     getEnvVersion(): Promise<EnvironmentVersion>;
     setGameVersion(v: string): Promise<void>;
     setNestVersion(v: string): Promise<void>;

package/dist/pkg/api/features/{user-state/user-state.api.d.ts → auth/index.d.ts}

@@ -1,7 +1,7 @@
-import { ApiEnv, BackendApi } from '../backend/backend.api';
+import { ApiEnv, Backend } from '../backend/backend.api';
 import { createStore } from '../../utils/observable';
 import { RpcProvider } from '../../core/rpc';
-import { GameIdReaderContract } from '../environment/environment.api';
+import { IHost } from '../host';
 interface Image {
     png: string;
     webp: string;
@@ -24,11 +24,17 @@ interface AuthUIManagerContract {
     openAuthRequest: ReturnType<typeof createStore<boolean>>;
     openAuthForm(): Promise<void>;
 }
-export declare class UserStateApi {
-    userProfileReader: UserProfileReaderContract;
-    authUIManager: AuthUIManagerContract;
+export declare class Auth {
+    private userProfileReader;
+    private authUIManager;
     constructor(userProfileReader: UserProfileReaderContract, authUIManager: AuthUIManagerContract);
-    static getArenaApi(backendApi: BackendApi, gameIdReader: GameIdReaderContract, rpcProvider: RpcProvider): UserStateApi;
-    static getGameApi(backendApi: BackendApi, gameIdReader: GameIdReaderContract, rpcProvider: RpcProvider): UserStateApi;
+    init(env: ApiEnv): Promise<void>;
+    isUserAuthorized(): Promise<boolean>;
+    getUserProfile(): Promise<UserProfile | null>;
+    onAuthStatusChange(observer: any): () => void;
+    openAuthForm(): Promise<void>;
+    onOpenAuthForm(observer: any): () => void;
+    static getArenaApi(backendApi: Backend, host: IHost, rpcProvider: RpcProvider): Auth;
+    static getGameApi(backendApi: Backend, host: IHost, rpcProvider: RpcProvider): Auth;
 }
 export {};

package/dist/pkg/api/features/backend/backend.api.d.ts

@@ -9,10 +9,8 @@ export declare enum PaymentsApiEnv {
     PROD = "https://arenacloud.cdn.arkadiumhosted.com/eagle-payment-api-prod/"
 }
 export declare type SessionStorageType = ReturnType<typeof UserApiGateway.prototype.getSessionStorage>;
-export declare class BackendApi {
+export declare class Backend {
     user: Awaited<ReturnType<typeof UserApiGateway.prototype.getAuthApi>> | null;
-    private paymentsApiGateway;
-    private virtualItemApiGateway;
     private userGateway;
     userGameData: UserGameDataApi | null;
     uiOpenRequest: import("../../utils/observable").Observable<boolean>;

package/dist/pkg/api/features/game-lifecycle/game-lifecycle.api.d.ts

@@ -11,41 +11,41 @@ declare enum LifecycleEvent {
 }
 declare type LifecycleFn = (event: LifecycleEvent, payload?: any) => void;
 export interface GameLifecycleContract {
-    OnTestReady(): Promise<void>;
-    OnPauseReady(): Promise<void>;
-    OnGamePause(): Promise<void>;
-    OnGameResume(): Promise<void>;
-    OnGameStart(): Promise<void>;
-    OnInteract(): Promise<void>;
-    OnChangeScore(score: number): Promise<void>;
-    OnGameEnd(): Promise<void>;
+    onTestReady(): Promise<void>;
+    onPauseReady(): Promise<void>;
+    onGamePause(): Promise<void>;
+    onGameResume(): Promise<void>;
+    onGameStart(): Promise<void>;
+    onInteract(): Promise<void>;
+    onChangeScore(score: number): Promise<void>;
+    onGameEnd(): Promise<void>;
     subscribe(fn: LifecycleFn): void;
 }
 export declare class GameLifecycle implements GameLifecycleContract {
     private rpcProvider;
     private cb;
     constructor(rpcProvider: RpcProvider);
-    OnTestReady(): Promise<void>;
-    OnGameStart(): Promise<void>;
-    OnInteract(): Promise<void>;
-    OnChangeScore(score: number): Promise<void>;
-    OnGameEnd(): Promise<void>;
+    onTestReady(): Promise<void>;
+    onGameStart(): Promise<void>;
+    onInteract(): Promise<void>;
+    onChangeScore(score: number): Promise<void>;
+    onGameEnd(): Promise<void>;
     subscribe(cb: LifecycleFn): void;
-    OnGamePause(): Promise<void>;
-    OnGameResume(): Promise<void>;
-    OnPauseReady(): Promise<void>;
+    onGamePause(): Promise<void>;
+    onGameResume(): Promise<void>;
+    onPauseReady(): Promise<void>;
 }
 export declare class GameLifecycleProxy implements GameLifecycleContract {
     private rpcProvider;
     constructor(rpcProvider: RpcProvider);
-    OnTestReady(): Promise<void>;
-    OnGameStart(): Promise<void>;
-    OnInteract(): Promise<void>;
-    OnChangeScore(score: number): Promise<void>;
-    OnGameEnd(): Promise<void>;
+    onTestReady(): Promise<void>;
+    onGameStart(): Promise<void>;
+    onInteract(): Promise<void>;
+    onChangeScore(score: number): Promise<void>;
+    onGameEnd(): Promise<void>;
     subscribe(fn: LifecycleFn): void;
-    OnGamePause(): Promise<void>;
-    OnGameResume(): Promise<void>;
-    OnPauseReady(): Promise<void>;
+    onGamePause(): Promise<void>;
+    onGameResume(): Promise<void>;
+    onPauseReady(): Promise<void>;
 }
 export {};

package/dist/pkg/api/features/host/index.d.ts

@@ -0,0 +1,58 @@
+import { RpcProvider } from '../../core/rpc';
+export interface IHost {
+    getQueryParameter(key: string): Promise<string | null>;
+    getGameId(): Promise<string>;
+    setGameId(id: string): void;
+    getDetails(): Promise<WebEnvironmentDetails>;
+    setDetails?(p: Partial<WebEnvironmentDetails>): Promise<void>;
+    openPurchaseForm(r: PurchaseRequest): Promise<void>;
+    onOpenPurchaseForm?(observer: any): any;
+}
+export declare type PurchaseRequest = {
+    type: string;
+    currencySku: string;
+};
+declare class WebEnvironmentDetails {
+    siteName: string;
+    siteDomain: string;
+    referrer: string;
+    activeLocale: string;
+    devEnvironment: string;
+    darkMode: boolean;
+    constructor(siteName?: string, siteDomain?: string, referrer?: string, activeLocale?: string, devEnvironment?: string, darkMode?: boolean);
+    clone(p: Partial<WebEnvironmentDetails>): WebEnvironmentDetails;
+}
+export declare class HostArena implements IHost {
+    private rpcProvider;
+    private gameIdOverride;
+    private data;
+    private openRequest;
+    /**
+     * @internal
+     */
+    constructor(rpcProvider: RpcProvider);
+    getQueryParameter(key: string): Promise<string | null>;
+    getGameId(): Promise<string>;
+    setGameId(id: string): Promise<void>;
+    getDetails(): Promise<WebEnvironmentDetails>;
+    setDetails(p: Partial<WebEnvironmentDetails>): Promise<void>;
+    openPurchaseForm(pr: PurchaseRequest): Promise<void>;
+    onOpenPurchaseForm(observer: any): () => void;
+    purchaseFormClosed(madePurchase: boolean): Promise<void>;
+}
+export declare class HostGame implements IHost {
+    private rpcProvider;
+    private purchaseFormState;
+    /**
+     * @internal
+     */
+    constructor(rpcProvider: RpcProvider);
+    getQueryParameter(key: string): Promise<string | null>;
+    getGameId(): Promise<string>;
+    setGameId(id: string): Promise<any>;
+    getDetails(): Promise<WebEnvironmentDetails>;
+    openPurchaseForm(r: PurchaseRequest): Promise<void>;
+    onPurchaseFormStateChange(observer: any): () => void;
+    private purchaseFormClosed;
+}
+export {};

package/dist/pkg/api/features/persistence/index.d.ts

@@ -0,0 +1,29 @@
+import { RpcProvider } from '../../core/rpc';
+export interface IPersistence {
+    getLocalStorageItem(key: string): Promise<string | null>;
+    setLocalStorageItem(key: string, value: string): Promise<void>;
+    removeLocalStorageItem(key: string): Promise<void>;
+    getCookie(cookieName: string): Promise<string>;
+}
+export declare class PersistenceArena implements IPersistence {
+    private ls;
+    /**
+     * @internal
+     */
+    constructor(rpcProvider: RpcProvider);
+    getLocalStorageItem(key: string): Promise<string | null>;
+    setLocalStorageItem(key: string, value: string): Promise<void>;
+    removeLocalStorageItem(key: string): Promise<void>;
+    getCookie(cookieName: string): Promise<string>;
+}
+export declare class PersistenceGame implements IPersistence {
+    private rpcProvider;
+    /**
+     * @internal
+     */
+    constructor(rpcProvider: RpcProvider);
+    getLocalStorageItem(key: string): Promise<string | null>;
+    setLocalStorageItem(key: string, value: string): Promise<void>;
+    removeLocalStorageItem(key: string): Promise<void>;
+    getCookie(cookieName: string): Promise<string>;
+}

package/dist/pkg/arkadium-arena-sdk.d.ts

@@ -1,37 +1,43 @@
-import { ApiEnv, BackendApi, SessionStorageType } from './api/features/backend/backend.api';
-import { GameStateContract } from './api/features/game-state/game-state.api';
+import { ApiEnv, Backend, SessionStorageType } from './api/features/backend/backend.api';
 import { GameLifecycleContract } from './api/features/game-lifecycle/game-lifecycle.api';
-import { EnvironmentApi } from './api/features/environment/environment.api';
 import { RpcProvider } from './api/core/rpc';
-import { AdsApi } from './api/features/ads/';
-import { UserStateApi } from './api/features/user-state/user-state.api';
+import { GameAdsContract } from './api/features/ads/';
+import { Auth } from './api/features/auth/';
 import { AnalyticsApiContract } from './api/features/analytics/analytics.api';
 import { Observable } from './api/utils/observable';
 import { TimeoutTesterContract } from './api/core/timeout-tester';
-import { PurchasesApi } from './api/features/purchases/purchases.api';
+import { PersistenceArena } from './api/features/persistence';
+import { HostArena } from './api/features/host';
 export declare class ArkadiumGameSdk {
     private rpcProvider;
-    backendApi: BackendApi;
-    environment: EnvironmentApi;
-    gameState: GameStateContract;
+    backendApi: Backend;
+    host: HostArena;
     lifecycle: GameLifecycleContract;
-    ads: AdsApi;
-    userStateApi: UserStateApi;
+    ads: GameAdsContract;
+    auth: Auth;
     analytics: AnalyticsApiContract;
-    purchases: PurchasesApi;
     private timeoutTester;
+    persistence: PersistenceArena;
+    private currentEnv;
+    private currentTarget;
     private gamePingSender;
     private gamePingListener;
     $pingNotification: Observable<number>;
-    constructor(rpcProvider: RpcProvider, backendApi: BackendApi, environment: EnvironmentApi, gameState: GameStateContract, lifecycle: GameLifecycleContract, ads: AdsApi, userStateApi: UserStateApi, analytics: AnalyticsApiContract, purchases: PurchasesApi, timeoutTester: TimeoutTesterContract);
+    version: string;
+    constructor(rpcProvider: RpcProvider, backendApi: Backend, host: HostArena, lifecycle: GameLifecycleContract, ads: GameAdsContract, auth: Auth, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena);
+    setEnv(e: ApiEnv): void;
     initialize(env: ApiEnv, isGameSide: boolean, sessionStorage?: SessionStorageType | null): Promise<void>;
+    private envDiscoverListener;
     updateWinReference(target: any): void;
     debugMode(enabled: boolean): void;
     ping(): Promise<any>;
+    dispose(): void;
 }
 export { ApiEnv };
 export declare class ArenaApi {
-    version: string;
+    static version: string;
     private static sdk;
+    static onGameSDKLoaded(target: any, callback: any): void;
+    static dispose(): void;
     static getInstance(env: ApiEnv, deferInit?: boolean): Promise<ArkadiumGameSdk>;
 }

package/dist/pkg/arkadium-game-sdk.d.ts

@@ -1,27 +1,26 @@
-import { ApiEnv, BackendApi, SessionStorageType } from './api/features/backend/backend.api';
-import { GameStateContract } from './api/features/game-state/game-state.api';
+import { ApiEnv, Backend, SessionStorageType } from './api/features/backend/backend.api';
 import { GameLifecycleContract } from './api/features/game-lifecycle/game-lifecycle.api';
-import { EnvironmentApi } from './api/features/environment/environment.api';
-import { AdsApi } from './api/features/ads/';
-import { UserStateApi } from './api/features/user-state/user-state.api';
+import { GameAdsContract } from './api/features/ads/';
+import { Auth } from './api/features/auth/';
 import { AnalyticsApiContract } from './api/features/analytics/analytics.api';
 import { RpcProvider } from './api/core/rpc';
 import { TimeoutTesterContract } from './api/core/timeout-tester';
-import { PurchasesApi } from './api/features/purchases/purchases.api';
+import { PersistenceGame } from './api/features/persistence';
+import { HostGame } from './api/features/host';
 export declare class ArkadiumGameSdk {
     private rpcProvider;
-    backendApi: BackendApi;
-    environment: EnvironmentApi;
-    gameState: GameStateContract;
+    backendApi: Backend;
+    host: HostGame;
     lifecycle: GameLifecycleContract;
-    ads: AdsApi;
-    userStateApi: UserStateApi;
+    ads: GameAdsContract;
+    auth: Auth;
     analytics: AnalyticsApiContract;
-    purchases: PurchasesApi;
     private timeoutTester;
+    persistence: PersistenceGame;
+    version: string;
     private arenaPingSender;
     private arenaPingListener;
-    constructor(rpcProvider: RpcProvider, backendApi: BackendApi, environment: EnvironmentApi, gameState: GameStateContract, lifecycle: GameLifecycleContract, ads: AdsApi, userStateApi: UserStateApi, analytics: AnalyticsApiContract, purchases: PurchasesApi, timeoutTester: TimeoutTesterContract);
+    constructor(rpcProvider: RpcProvider, backendApi: Backend, host: HostGame, lifecycle: GameLifecycleContract, ads: GameAdsContract, auth: Auth, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceGame);
     initialize(env: ApiEnv, isGameSide: boolean, sessionStorage?: SessionStorageType | null): Promise<void>;
     updateWinReference(target: any): void;
     debugMode(enabled: boolean): void;
@@ -29,8 +28,14 @@ export declare class ArkadiumGameSdk {
 export { ApiEnv };
 export { Dimension } from './api/features/analytics/dimensions';
 export { Event } from './api/features/analytics/events';
+interface EnvDiscoverer {
+    discover(): Promise<ApiEnv>;
+}
 export declare class GameApi {
-    version: string;
+    static version: string;
     private static sdk;
-    static getInstance(env: ApiEnv): Promise<ArkadiumGameSdk>;
+    private static envDiscoverer;
+    static onGameSDKLoaded(): void;
+    static getInstance(): Promise<ArkadiumGameSdk>;
+    static setEnvDiscoverer(d: EnvDiscoverer): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkadiuminc/sdk",
-  "version": "0.0.55",
+  "version": "2.0.0",
   "description": "",
   "keywords": [],
   "main": "dist/pkg/arkadium-sdk.umd.js",
@@ -58,8 +58,7 @@
   },
   "devDependencies": {
     "@arkadium/eagle-payments-api-client": "^0.0.35",
-    "@arkadium/eagle-user-client": "^0.0.89",
-    "@arkadium/eagle-virtual-items-api-client": "^0.0.27",
+    "@arkadium/eagle-user-client": "^0.0.90",
     "@commitlint/cli": "^17.0.3",
     "@commitlint/config-conventional": "^17.0.3",
     "@types/jest": "^28.1.6",
@@ -95,4 +94,4 @@
     "nanoid": "^5.0.4",
     "vite-plugin-string-replace": "^1.1.2"
   }
-}
+}

package/dist/pkg/api/features/environment/environment.api.d.ts

@@ -1,60 +0,0 @@
-import { RpcProvider } from '../../core/rpc';
-export interface LocalStorageContract {
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem(key: string): Promise<void>;
-}
-export declare class DefaultLocalStorage implements LocalStorageContract {
-    private ls;
-    constructor(rpcProvider: RpcProvider);
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem(key: string): Promise<void>;
-}
-interface CookieStorageContract {
-    GetKey(key: string): Promise<string>;
-}
-interface UrlParamsReaderContract {
-    GetParam(key: string): Promise<string | null>;
-}
-export interface GameIdReaderContract {
-    readGameId(): Promise<string>;
-    setGameId(id: string): void;
-}
-export declare class GameIdReader implements GameIdReaderContract {
-    private gameIdOverride;
-    constructor(rpcProvider: RpcProvider);
-    readGameId(): Promise<string>;
-    setGameId(id: string): void;
-}
-export declare class GameIdReaderProxy implements GameIdReaderContract {
-    private rpcProvider;
-    constructor(rpcProvider: RpcProvider);
-    readGameId(): Promise<string>;
-    setGameId(id: string): Promise<any>;
-}
-declare class WebEnvironmentDetails {
-    siteName: string;
-    siteDomain: string;
-    referrer: string;
-    activeLocale: string;
-    devEnvironment: string;
-    darkMode: boolean;
-    constructor(siteName?: string, siteDomain?: string, referrer?: string, activeLocale?: string, devEnvironment?: string, darkMode?: boolean);
-    clone(p: Partial<WebEnvironmentDetails>): WebEnvironmentDetails;
-}
-interface WebEnvironmentDetailsProvider {
-    setParams(p: Partial<WebEnvironmentDetails>): Promise<void>;
-    getParams(): Promise<WebEnvironmentDetails>;
-}
-export declare class EnvironmentApi {
-    localStorage: LocalStorageContract;
-    cookieStorage: CookieStorageContract;
-    urlParamsReader: UrlParamsReaderContract;
-    gameIdReader: GameIdReaderContract;
-    webEnvironmentDetailsStorage: WebEnvironmentDetailsProvider;
-    constructor(localStorage: LocalStorageContract, cookieStorage: CookieStorageContract, urlParamsReader: UrlParamsReaderContract, gameIdReader: GameIdReaderContract, webEnvironmentDetailsStorage: WebEnvironmentDetailsProvider);
-    static getArenaApi(rpcProvider: RpcProvider): EnvironmentApi;
-    static getGameApi(rpcProvider: RpcProvider): EnvironmentApi;
-}
-export {};

package/dist/pkg/api/features/game-state/game-state.api.d.ts

@@ -1,59 +0,0 @@
-import { RpcProvider } from '../../core/rpc';
-import { GameIdReaderContract } from '../environment/environment.api';
-import { BackendApi } from '../backend/backend.api';
-declare class SaveDataContract<T> {
-    __cloudMeta__: {
-        __version: number;
-    };
-    data: T | null;
-    clone<T>(p: Partial<SaveDataContract<T>>): SaveDataContract<T>;
-}
-export declare const ErrSaveIsOutdated: Error;
-export interface GameStateContract {
-    setSerializer(s: Serializer): void;
-    loadGameState(key: string): Promise<any>;
-    saveGameState(key: string, state: any): Promise<void>;
-}
-export interface Serializer {
-    pack(data: Record<any, any>): Promise<string>;
-    unpack(data: string): Promise<Record<any, any> | null>;
-}
-export declare class GameStateApi {
-    private rpcProvider;
-    private ls;
-    private backendApi;
-    private gameIdReader;
-    private knownStates;
-    private serializer;
-    private useGameSerializer;
-    constructor(backendApi: BackendApi, gameIdReader: GameIdReaderContract, rpcProvider: RpcProvider);
-    private getGameId;
-    private packData;
-    private unpackData;
-    private isUserAuthorized;
-    private getStorageKey;
-    useSerializer(value: boolean): void;
-    setSerializer(s: Serializer): void;
-    loadGameState<T>(key: string): Promise<{
-        cloud: SaveDataContract<T> | null;
-        local: SaveDataContract<T> | null;
-    }>;
-    private loadData;
-    private isStateOutdated;
-    saveGameState<T>(key: string, state: SaveDataContract<T>): Promise<void>;
-    private saveDataToStorage;
-}
-export declare class GameStateApiProxy {
-    private rpcProvider;
-    constructor(rpcProvider: RpcProvider);
-    private serializer;
-    setSerializer(serializer: Serializer | null): void;
-    customPack(data: Record<any, any>): Promise<string | undefined>;
-    customUnpack(data: string): Promise<Record<any, any> | null | undefined>;
-    loadGameState<T>(key: string): Promise<{
-        cloud: SaveDataContract<T>;
-        local: SaveDataContract<T>;
-    }>;
-    saveGameState<T>(key: string, state: SaveDataContract<T>): Promise<void>;
-}
-export {};

package/dist/pkg/api/features/purchases/purchases.api.d.ts

@@ -1,15 +0,0 @@
-import { RpcProvider } from '../../core/rpc';
-export declare type PurchaseRequest = {
-    type: string;
-    currencySku: string;
-};
-interface UIManagerContract {
-    purchaseRequest(r: PurchaseRequest): Promise<void>;
-}
-export declare class PurchasesApi {
-    ui: UIManagerContract;
-    constructor(ui: UIManagerContract);
-    static getArenaApi(rpcProvider: RpcProvider): PurchasesApi;
-    static getGameApi(rpcProvider: RpcProvider): PurchasesApi;
-}
-export {};