@kalamba/sdk 0.1.0

package/dist/plugins.d.ts

@@ -0,0 +1,550 @@
+declare type AutoplayLimit = {
+    enabled: boolean;
+    showNoLimit: boolean;
+    showCustomLimit: boolean;
+    options: number[];
+};
+
+export declare class BasicPlugin extends CasinoPlugin {
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    registerToSdkEvents(): void;
+    registerFromSdkEvents(): void;
+}
+
+declare type Bet = {
+    base: number;
+    multiplier: number;
+};
+
+declare type Cashier = {
+    type: 'ON_DEMAND' | 'BALANCE_LOW' | 'BALANCE_INSUFFICIENT';
+};
+
+declare type CashierConfig = {
+    enabled: boolean;
+    balanceThreshold: number[];
+};
+
+declare type CasinoOnlyMessagePayloadMap = {
+    balance: {
+        balance: number;
+    };
+    bet: Bet;
+    cashier: Cashier;
+    choice: {
+        id: string;
+    };
+    close: never;
+    freeze: never;
+    help: {
+        show?: boolean;
+    };
+    history: History_2;
+    paytable: {
+        show?: boolean;
+    };
+    play: PlayRequest;
+    resume: never;
+    settings: Settings;
+    suspend: never;
+    unfreeze: never;
+};
+
+export declare abstract class CasinoPlugin {
+    config: SdkConfig;
+    constructor(config: SdkConfig);
+    protected on<M extends DomainMessage<'wrapper'> | ForwardToPluginsMessage<'casino'>>(message: M, listener: (payload: M extends DomainMessage<'wrapper'> ? DomainMessagePayload<'wrapper', M> : M extends ForwardToPluginsMessage<'casino'> ? ForwardToPluginsMessagePayload<'casino', M> : never) => void, options?: AddEventListenerOptions): void;
+    protected send<M extends DomainMessage<'casino'>>(message: M, ...[payload]: DomainMessagePayload<'casino', M> extends never ? [] : [payload: DomainMessagePayload<'casino', M>]): void;
+}
+
+export declare class DebuggingPlugin extends CasinoPlugin {
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    registerDebugToSdkEvents(): void;
+    registerSdkToDebugEvents(): void;
+    _send(...args: Parameters<typeof DebuggingPlugin.prototype.send>): ReturnType<typeof DebuggingPlugin.prototype.send>;
+}
+
+declare type DomainAllowedPayloadMap<P extends DomainPrefix> = DomainToMessagePayloadMap[P];
+
+declare type DomainMessage<P extends DomainPrefix> = keyof DomainAllowedPayloadMap<P>;
+
+declare type DomainMessagePayload<P extends DomainPrefix, M extends DomainMessage<P>> = DomainAllowedPayloadMap<P>[M];
+
+declare type DomainPrefix = keyof DomainToMessagePayloadMap & string;
+
+declare type DomainToMessagePayloadMap = {
+    sdk: SdkOnlyMessagePayloadMap;
+    wrapper: WrapperOnlyMessagePayloadMap;
+    casino: CasinoOnlyMessagePayloadMap;
+    rgs: RgsOnlyMessagePayloadMap;
+    telemetry: TelemetryOnlyMessagePayloadMap;
+};
+
+declare type Error_2 = {
+    message: string;
+    messageKey: string;
+    type: 'CLOSE' | 'RELOAD' | 'CONTINUE';
+};
+
+declare type ForwardToPluginsMessage<P extends PluginDomain> = keyof ForwardToPluginsMessageMap<'sdk'>[P] | keyof ForwardToPluginsMessageMap<'rgs'>[P] | keyof ForwardToPluginsMessageMap<'casino'>[P] | keyof ForwardToPluginsMessageMap<'telemetry'>[P];
+
+declare interface ForwardToPluginsMessageMap<SourceDomain extends DomainPrefix> {
+    casino: ToCasinoPluginsForwardedMessageMap[SourceDomain];
+    rgs: ToRgsPluginsForwardedMessageMap[SourceDomain];
+    telemetry: ToTelemetryPluginsForwardedMessageMap[SourceDomain];
+}
+
+declare type ForwardToPluginsMessagePayload<P extends PluginDomain, M extends ForwardToPluginsMessage<P>> = ForwardToPluginsMessageMap<'sdk'>[P][M] & ForwardToPluginsMessageMap<'rgs'>[P][M] & ForwardToPluginsMessageMap<'casino'>[P][M] & ForwardToPluginsMessageMap<'telemetry'>[P][M];
+
+declare type GameEventName = 'BG_RESULT' | 'OPEN_GAME' | 'SPIN_ERROR' | 'SPIN_RESULT';
+
+export declare class GigPlugin extends CasinoPlugin {
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    postMessage(event: unknown): void;
+    registerToSdkEvents(): void;
+    registerFromSdkEvents(): void;
+}
+
+declare type History_2 = {
+    source: 'realityCheck' | 'settings' | 'casino';
+};
+
+export declare class KalambaBullseyePlugin extends RgsPlygin {
+    #private;
+    socket: KalambaWebSocketClient;
+    constructor(...args: ConstructorParameters<typeof RgsPlygin>);
+    initialize(init: KalambaWebSocketClientInit): void;
+    reconnect(init: KalambaWebSocketClientInit): Promise<void>;
+    openGame(): Promise<{
+        balance: number;
+        balanceVersion: number;
+        correlationSeqId: number;
+        data: unknown;
+        event: "OPEN_GAME";
+    } & {
+        correlationSeqId?: number | undefined;
+        event: "BG_RESULT" | "OPEN_GAME" | "SPIN_ERROR" | "SPIN_RESULT";
+        seqId: number;
+    }>;
+    play(payload: PlayRequest): any;
+    registerFromSdkEvents(): void;
+}
+
+export declare class KalambaStargazerPlugin extends TelemetryPlugin {
+    #private;
+    FPS_SAMPLE_INTERVAL: number;
+    constructor(...args: ConstructorParameters<typeof TelemetryPlugin>);
+    registerEvents(): Promise<void>;
+    reportFpsSample(): void;
+    reportFpsRound(): void;
+    getExtraUiInteractionData(): {
+        orientation: string;
+        stateType: string;
+    };
+    deviceInfo(): Promise<Record<string, unknown>>;
+}
+
+export declare class KalambaStargazerTracker extends Tracker {
+    #private;
+    processQueueForced: OmitFirstParam<typeof KalambaStargazerTracker.processQueue>;
+    constructor(...args: ConstructorParameters<typeof Tracker>);
+    subscribe(): void;
+    schedule(): void;
+    send(payload: Record<string, unknown>[]): void;
+    addToQueue(payload: Record<string, unknown>): void;
+    processQueue(forced?: boolean): void;
+    track(eventName: unknown, eventParams: Record<string, unknown>): void;
+}
+
+declare class KalambaWebSocketClient extends WebSocketClient {
+    #private;
+    cId: number;
+    mId: number;
+    seqId: number;
+    gameCode: string;
+    eventListeners: KalambaWebSocketClientEventListeners;
+    constructor(init: KalambaWebSocketClientInit, options: KalambaWebSocketClientOptions);
+    private handleRealityCheck;
+    addEventListener<K extends keyof KalambaWebSocketClientEventMap>(type: K, listener: KalambaWebSocketClientEventListener<K>): void;
+    removeEventListener<K extends keyof KalambaWebSocketClientEventMap>(type: K, listener: KalambaWebSocketClientEventListener<K>): void;
+    onMessage: (event: any) => void;
+    private buildHeader;
+    private buildPayload;
+    private getBodyExtras;
+    private request;
+    activateFreeRound(body: any): Promise<WebSocketResponse<any, Record<string, unknown>, unknown>>;
+    authenticate(reconnect?: boolean): Promise<{
+        balance: number;
+        balanceVersion: number;
+        coinValueInCents: number;
+        countryCode: string;
+        currencyCode: string;
+        jurisdictionCode: string;
+        uiMessages: unknown[];
+        username: string;
+    }>;
+    openGame(): Promise<{
+        balance: number;
+        balanceVersion: number;
+        correlationSeqId: number;
+        data: unknown;
+        event: "OPEN_GAME";
+    } & {
+        correlationSeqId?: number | undefined;
+        event: GameEventName;
+        seqId: number;
+    }>;
+    private sendAcknowledgement;
+    private sendAction;
+    spin(payload: any): Promise<unknown>;
+    bgAction(payload: any): Promise<unknown>;
+    setRequestTimeoutMs(ms: number): void;
+}
+
+declare type KalambaWebSocketClientEventListener<K extends keyof KalambaWebSocketClientEventMap> = (ev: KalambaWebSocketClientEventMap[K]) => any;
+
+declare type KalambaWebSocketClientEventListeners = {
+    [K in keyof KalambaWebSocketClientEventMap]: KalambaWebSocketClientEventListener<K>[];
+};
+
+declare type KalambaWebSocketClientEventMap = WebSocketClientEventMap & {
+    realityCheck: RealityCheck['body'];
+};
+
+declare interface KalambaWebSocketClientInit {
+    apiUrl: string;
+    cageCode: string;
+    gameCode: string;
+    operatorCode: string;
+    playMode: string;
+    token: string;
+    username: string;
+}
+
+declare interface KalambaWebSocketClientOptions {
+    gameVersion: string;
+    requestTimeoutMs: number;
+}
+
+export declare class LoggingTracker extends Tracker {
+    track(event: unknown, data: Record<string, unknown>): void;
+}
+
+declare type OmitFirstParam<T extends (...args: any[]) => any> = T extends (arg: any, ...rest: infer R) => infer Result ? (...args: R) => Result : never;
+
+declare type OpenGameError = {
+    data: any;
+    type?: string;
+};
+
+declare type OpenGameRequest = {
+    gameName: string;
+    version: string;
+};
+
+declare type OpenGameResponse = {
+    balance: number;
+    data: any;
+};
+
+export declare class OryxPlugin extends CasinoPlugin {
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    registerToSdkEvents(): void;
+    registerFromSdkEvents(): void;
+}
+
+export declare class PariplayPlugin extends CasinoPlugin {
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    postMessage(type: string, data?: unknown): void;
+    coinsToCurrency(coins: number): number;
+    handleContinueButton(button: any, next: any): void;
+    handleLinkButton(button: any, next: any): void;
+    handleQuitButton(button: any, next: any): void;
+    handleCashierButton(button: any, next: any): void;
+    handleHistoryButton(button: any, next: any): void;
+    get buttonActions(): any;
+    processInfoUiMessages(uiMessages: any[]): any;
+    registerToSdkEvents(): void;
+    registerFromSdkEvents(): void;
+}
+
+declare type PlayError = {
+    data: any;
+    type?: string;
+};
+
+declare type PlayRequest = {
+    bet: Bet;
+} | {
+    userInput: unknown;
+} | {
+    opaqueGameAttributes: unknown;
+};
+
+declare type PlayResponse = {
+    balance: number;
+    data: any;
+};
+
+declare type PluginDomain = keyof ForwardToPluginsMessageMap<any>;
+
+declare type RealityCheck = WebSocketResponse<'RealityCheck', Record<string, unknown>, {
+    duration: number;
+    sumBetAmount: number;
+    sumWinAmount: number;
+}>;
+
+declare type RealityCheckConfig = {
+    sessionDurationPeriodFormat: 'seconds' | 'minutes' | 'hours';
+    showCloseGame: boolean;
+    showHistory: boolean;
+    showNetPosition: boolean;
+    showSessionDuration: boolean;
+    showSumBets: boolean;
+    showSumWins: boolean;
+};
+
+export declare class RelaxFEIMPlugin extends CasinoPlugin {
+    VERSION: string;
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    registerToSdkEvents(): void;
+    registerFromSdkEvents(): void;
+}
+
+declare type ResponseMessageName = 'Authenticate' | 'GameAction' | 'GameEvent' | 'OpenGame' | 'Ping' | 'RealityCheck';
+
+declare type RgsOnlyMessagePayloadMap = {
+    openGameError: OpenGameError;
+    openGameResponse: OpenGameResponse;
+    playError: PlayError;
+    playResponse: PlayResponse;
+    realityCheck: {
+        duration: number;
+        sumBetAmount: number;
+        sumWinAmount: number;
+    };
+};
+
+export declare abstract class RgsPlygin {
+    config: SdkConfig;
+    constructor(config: SdkConfig);
+    protected on<M extends DomainMessage<'wrapper'> | ForwardToPluginsMessage<'rgs'>>(message: M, listener: (payload: M extends DomainMessage<'wrapper'> ? DomainMessagePayload<'wrapper', M> : M extends ForwardToPluginsMessage<'rgs'> ? ForwardToPluginsMessagePayload<'rgs', M> : never) => void, options?: AddEventListenerOptions): void;
+    protected send<M extends DomainMessage<'rgs'>>(message: M, ...[payload]: DomainMessagePayload<'rgs', M> extends never ? [] : [payload: DomainMessagePayload<'rgs', M>]): void;
+}
+
+declare interface SdkConfig {
+    api: {
+        brand: string;
+        cashierUrl?: string;
+        coinValueInCents: number;
+        country: string;
+        currency: string;
+        game: string;
+        gameHistoryUrl: string;
+        homeUrl?: string;
+        integration: string;
+        integrationData?: unknown;
+        jurisdiction: string;
+        playMode: 'FUN' | 'REAL';
+        user: string;
+    };
+    ui: {
+        autoplay: {
+            enabled: boolean;
+            rounds: AutoplayLimit;
+            lossLimit: AutoplayLimit;
+            winLimit: AutoplayLimit;
+            simple: boolean;
+            stopOnFeature: boolean;
+        };
+        cashier: CashierConfig;
+        feature: {
+            allowTelemetry: boolean;
+            allowFullscreen: boolean;
+            allowQuickStop: boolean;
+            showCashier: boolean;
+            showClock: boolean;
+            showCloseGame: boolean;
+            showCurrency: boolean;
+            showFastPlay: boolean;
+            showFeatureBuy: boolean;
+            showFeatureIntro: boolean;
+            showFeatureOutro: boolean;
+            showFunModeBanner: boolean;
+            showHistory: boolean;
+            showLowWinCelebration: boolean;
+            showMaximumWin: boolean;
+            showNetPosition: boolean;
+            showPaylineLines: boolean;
+            showPaytable: boolean;
+            showRoundId: boolean;
+            showRtp: boolean;
+            showRules: boolean;
+            showSessionDuration: boolean;
+            showUi: boolean;
+        };
+        language: string;
+        maximumBet?: number;
+        minimumSpinDuration: number;
+        requestTimeoutMs: number;
+        realityCheck: RealityCheckConfig;
+        skipInsufficientFundsCheck: boolean;
+        skipSplash: boolean;
+    };
+}
+
+declare type SdkOnlyMessagePayloadMap = {
+    autoplay: {
+        action: 'start' | 'stop' | 'pause' | 'resume';
+    };
+    balance: {
+        balance: number;
+    };
+    bet: Bet;
+    cashier: Cashier;
+    choice: {
+        message: string;
+        options: {
+            id: string;
+            label: string;
+        }[];
+    };
+    close: never;
+    error: Error_2;
+    fullscreen: {
+        lock?: OrientationLockType;
+    };
+    history: History_2;
+    loadEnd: never;
+    loadProgress: {
+        progress: number;
+    };
+    loadStart: never;
+    openGame: OpenGameRequest;
+    play: PlayRequest;
+    playCycleEnd: PlayResponse;
+    playCycleStart: PlayRequest;
+    playEnd: PlayResponse;
+    playReady: {
+        ready: boolean;
+    };
+    playStart: PlayRequest;
+    translations: Record<string, Record<string, string>>;
+    settings: Settings;
+    'telemetry.click': {
+        location: string;
+        name: string;
+    };
+    'telemetry.orientationChange': never;
+};
+
+declare type Settings = {
+    fastPlay?: boolean;
+    fastPlaySpeed?: number;
+    sounds?: boolean;
+    music?: boolean;
+};
+
+declare type TelemetryOnlyMessagePayloadMap = {
+    [key: string]: unknown;
+};
+
+export declare abstract class TelemetryPlugin {
+    trackers: Tracker[];
+    config: SdkConfig;
+    constructor(trackers: Tracker[], config: SdkConfig);
+    protected on<M extends DomainMessage<'wrapper'> | ForwardToPluginsMessage<'telemetry'>>(message: M, listener: (payload: M extends DomainMessage<'wrapper'> ? DomainMessagePayload<'wrapper', M> : M extends ForwardToPluginsMessage<'telemetry'> ? ForwardToPluginsMessagePayload<'telemetry', M> : never) => void, options?: AddEventListenerOptions): void;
+    protected track(event: unknown, data: Record<string, unknown>): void;
+}
+
+declare type ToCasinoPluginsForwardedMessageMap = {
+    sdk: Pick<SdkOnlyMessagePayloadMap, 'autoplay' | 'balance' | 'bet' | 'cashier' | 'choice' | 'close' | 'error' | 'history' | 'loadEnd' | 'loadProgress' | 'loadStart' | 'openGame' | 'play' | 'playCycleEnd' | 'playCycleStart' | 'playEnd' | 'playReady' | 'playStart' | 'settings'>;
+    casino: undefined;
+    rgs: Pick<RgsOnlyMessagePayloadMap, 'playResponse' | 'playError' | 'openGameResponse'>;
+    telemetry: undefined;
+    wrapper: undefined;
+};
+
+declare type ToRgsPluginsForwardedMessageMap = {
+    sdk: Pick<SdkOnlyMessagePayloadMap, 'history' | 'openGame' | 'play'>;
+    casino: Pick<CasinoOnlyMessagePayloadMap, 'play' | 'cashier' | 'close' | 'history'>;
+    rgs: undefined;
+    telemetry: undefined;
+    wrapper: undefined;
+};
+
+declare type ToTelemetryPluginsForwardedMessageMap = {
+    sdk: Pick<SdkOnlyMessagePayloadMap, 'autoplay' | 'error' | 'loadStart' | 'loadProgress' | 'loadEnd' | 'playCycleStart' | 'playCycleEnd' | 'settings' | 'telemetry.click' | 'telemetry.orientationChange'>;
+    casino: undefined;
+    rgs: Pick<RgsOnlyMessagePayloadMap, 'openGameResponse' | 'openGameError' | 'playResponse' | 'playError'>;
+    telemetry: undefined;
+    wrapper: undefined;
+};
+
+export declare abstract class Tracker {
+    config: SdkConfig;
+    constructor(config: SdkConfig);
+    abstract track(event: unknown, data: Record<string, unknown>): void;
+}
+
+export declare class TukoPlugin extends CasinoPlugin {
+    PING_INTERVAL: number;
+    constructor(...args: ConstructorParameters<typeof CasinoPlugin>);
+    ping(url: string): void;
+    registerToSdkEvents(): void;
+    registerFromSdkEvents(): void;
+}
+
+declare class WebSocketClient {
+    socket: WebSocket | null;
+    webSocketUrl: string;
+    eventListeners: WebSocketClientEventListeners;
+    constructor(webSocketUrl: string);
+    connect: () => Promise<unknown>;
+    send: (payload: any) => void;
+    close: () => void;
+    addEventListener<K extends keyof WebSocketClientEventMap>(type: K, listener: WebSocketClientEventListener<K>): void;
+    removeEventListener<K extends keyof WebSocketClientEventMap>(type: K, listener: WebSocketClientEventListener<K>): void;
+    handleClose: (event: WebSocketEventMap['close']) => void;
+    handleError: (event: WebSocketEventMap['error']) => void;
+    handleMessage: (event: WebSocketEventMap['message']) => void;
+    handleOpen: (event: WebSocketEventMap['open']) => void;
+}
+
+declare type WebSocketClientEventListener<K extends keyof WebSocketClientEventMap> = (ev: WebSocketClientEventMap[K]) => any;
+
+declare type WebSocketClientEventListeners = {
+    [K in keyof WebSocketClientEventMap]: WebSocketClientEventListener<K>[];
+};
+
+declare type WebSocketClientEventMap = Pick<WebSocketEventMap, 'close' | 'error' | 'message'>;
+
+declare interface WebSocketResponse<Name extends ResponseMessageName, Header = Record<string, unknown>, Body = unknown> {
+    body: Body;
+    header: Header & {
+        cId: number;
+        mId: number;
+        name: Name;
+    };
+}
+
+declare type WrapperOnlyMessagePayloadMap = {
+    bet: Bet;
+    close: never;
+    configured: SdkConfig;
+    freeze: never;
+    history: History_2;
+    resume: never;
+    state: WrapperState;
+    suspend: never;
+    unfreeze: never;
+};
+
+declare type WrapperState = {
+    balance: number;
+    bet: Bet;
+    gameName: string;
+    version: string;
+};
+
+export { }