@kalamba/sdk 0.30.0 → 0.37.0

package/dist/i18n-CM87VHyx.d.ts

@@ -0,0 +1,525 @@
+/**
+ * BSD 3-Clause License
+ * Copyright (c) 2026, Kalamba Games Limited
+ */
+//#region ../../libs/common/src/utils/format/currency.d.ts
+declare enum CurrencyFormat {
+  Currency = "Currency",
+  Number = "Number"
+}
+declare enum CurrencyNumber {
+  Coins = "Coins",
+  Money = "Money"
+}
+interface FormatCurrencyOptions {
+  as?: CurrencyFormat;
+  from?: CurrencyNumber;
+}
+//#endregion
+//#region src/common/errors.d.ts
+declare const RgsErrorCode: {
+  readonly CONNECTION_ERROR: "CONNECTION_ERROR";
+  readonly INVALID_BET_CURRENCY: "INVALID_BET_CURRENCY";
+  readonly INVALID_BET: "INVALID_BET";
+  readonly INVALID_CAGE_CODE: "INVALID_CAGE_CODE";
+  readonly INVALID_CLIENT_TYPE: "INVALID_CLIENT_TYPE";
+  readonly INVALID_MESSAGE_FORMAT: "INVALID_MESSAGE_FORMAT";
+  readonly INVALID_SESSION: "INVALID_SESSION";
+  readonly TOO_HIGH_BET_FREQUENCY: "TOO_HIGH_BET_FREQUENCY";
+  readonly TOO_HIGH_ACTION_FREQUENCY: "TOO_HIGH_ACTION_FREQUENCY";
+  readonly USER_LOCK_INVALID_PARAMS: "USER_LOCK_INVALID_PARAMS";
+  readonly USER_ALREADY_LOCKED: "USER_ALREADY_LOCKED";
+  readonly GAME_SERVER_ERROR: "GAME_SERVER_ERROR";
+  readonly SESSION_MANAGEMENT_ERROR: "SESSION_MANAGEMENT_ERROR";
+  readonly MESSAGE_SENDER_ERROR: "MESSAGE_SENDER_ERROR";
+  readonly FREE_ROUNDS_PROCESSING_ERROR: "FREE_ROUNDS_PROCESSING_ERROR";
+  readonly WEB_SESSION_NOT_OPEN: "WEB_SESSION_NOT_OPEN";
+  readonly GAMING_LIMITS_REACHED: "GAMING_LIMITS_REACHED";
+  readonly OUT_OF_MONEY: "OUT_OF_MONEY";
+  readonly UNFINISHED_ROUND_IN_PROGRESS: "UNFINISHED_ROUND_IN_PROGRESS";
+  readonly ACCESS_DENIED: "ACCESS_DENIED";
+  readonly CREDENTIALS_NOT_FOUND: "CREDENTIALS_NOT_FOUND";
+  readonly ALREADY_LOGGED_IN: "ALREADY_LOGGED_IN";
+  readonly GAME_UNAVAILABLE: "GAME_UNAVAILABLE";
+  readonly BONUS_RESTRICTION: "BONUS_RESTRICTION";
+  readonly TOO_MANY_OPEN_GAMES: "TOO_MANY_OPEN_GAMES";
+  readonly GAME_FROZEN: "GAME_FROZEN";
+  readonly WALLET_PROCESSING_ERROR: "WALLET_PROCESSING_ERROR";
+  readonly FORCED_OUTCOMES_NOT_ALLOWED: "FORCED_OUTCOMES_NOT_ALLOWED";
+  readonly MISSING_GAME_STATE: "MISSING_GAME_STATE";
+  readonly DATA_ACCESS_ERROR: "DATA_ACCESS_ERROR";
+  readonly UNKNOWN: "UNKNOWN";
+};
+declare class RgsError extends Error {
+  data: RgsErrorData;
+  constructor(data: RgsErrorData);
+}
+declare class TimeoutError extends Error {
+  constructor();
+}
+//#endregion
+//#region src/utils.d.ts
+type PrefixKeys<Base, Prefix extends string> = { [Key in keyof Base as `${Prefix}:${string & Key}`]: Base[Key] };
+type PrefixTypes<Types, Prefix extends string> = `${Prefix}:${Types}`;
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+type NestedRecord<K extends string | number | symbol, V> = { [k in K]: V | NestedRecord<K, V> };
+//#endregion
+//#region src/types.d.ts
+type WrapperConfig = {
+  gameName: string;
+  gameVersion: string;
+  gameHistoryUrl?: string;
+  showFreeRounds: boolean;
+  showPromoPanel: boolean;
+  showRealityCheck: boolean;
+  showErrors: boolean;
+  showBars: boolean;
+  skipErrors: ((typeof RgsErrorCode)[keyof typeof RgsErrorCode] | 'TIMEOUT')[];
+};
+type WrapperState = {
+  isSdkConfigured: boolean;
+  balance: number;
+  bet: Bet;
+  openGameResponse?: OpenGameResponse['contract'];
+  lastPlayResponse?: PlayResponse['contract'];
+  freeRoundId?: string;
+};
+type AutoplayLimit = {
+  enabled: boolean;
+  showNoLimit: boolean;
+  showCustomLimit: boolean;
+  options: number[];
+};
+type RealityCheckConfig = {
+  sessionDurationPeriodFormat: 'seconds' | 'minutes' | 'hours';
+  showCloseGame: boolean;
+  showHistory: boolean;
+  showNetPosition: boolean;
+  showSessionDuration: boolean;
+  showSumBets: boolean;
+  showSumWins: boolean;
+};
+type CashierConfig = {
+  enabled: boolean;
+  balanceThreshold: number[];
+};
+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 | null;
+    playMode: 'FUN' | 'REAL';
+    user: string;
+    sessionId: string;
+    backendSessionId?: string;
+  };
+  ui: {
+    autoplay: {
+      enabled: boolean;
+      rounds: AutoplayLimit;
+      lossLimit: AutoplayLimit;
+      winLimit: AutoplayLimit;
+      simple: boolean;
+      stopOnFeature: boolean;
+    };
+    cashier: CashierConfig;
+    feature: {
+      allowTelemetry: boolean;
+      allowFullscreen: boolean;
+      allowGamble: 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;
+    minimumSpinDuration: number;
+    requestTimeoutMs: number;
+    incompleteGameResolution: {
+      type: 'NONE' | 'MANUAL';
+    } | {
+      daysToAutoResolution: number;
+      type: 'AUTOMATIC';
+    };
+    realityCheck: RealityCheckConfig;
+    skipInsufficientFundsCheck: boolean;
+    skipSplash: boolean;
+    cheatPanel: boolean;
+  };
+}
+type Bet = {
+  base: number;
+  multiplier: number;
+};
+type Settings = {
+  fastPlay?: boolean;
+  sounds?: boolean;
+  music?: boolean;
+};
+type History = {
+  source: 'realityCheck' | 'settings' | 'casino';
+};
+type Cashier = {
+  type: 'ON_DEMAND' | 'BALANCE_LOW' | 'BALANCE_INSUFFICIENT';
+};
+type FreeRound = {
+  conf: {
+    base: number;
+    multiplier: number;
+    numAwarded: number;
+  };
+  data: {
+    numPlayed: number;
+    win: number;
+    numLeft: number;
+  };
+  id: string;
+  rejectable: boolean;
+  skippable: boolean;
+  status: 'PENDING' | 'ACTIVE' | 'FINISHED';
+  type: string;
+};
+type FreeRoundsAction = {
+  action: 'ACCEPT' | 'DECLINE' | 'SKIP';
+  id: string;
+};
+type SdkError = {
+  messageCode: string;
+  type: 'CLOSE' | 'RELOAD' | 'CONTINUE';
+} & ({
+  message: string;
+} | {
+  messageKey: string;
+});
+type OpenGameResponse = {
+  contract: {
+    bet: {
+      available: Record<number, number[]>;
+      default: Bet;
+      max: number | null;
+      last: Bet | null;
+      lastPaid: Bet | null;
+    };
+    balance: {
+      coins: number;
+      version: number;
+    };
+    freeRounds: FreeRound[];
+    gameModel: string;
+    metaData: {
+      rtpValues: {
+        key: string;
+        rtpValue: string;
+      }[];
+      maxWin: {
+        key: string;
+        maxWinValueXBet: number;
+        maxWinOdds: number;
+      }[];
+      version: string;
+    };
+    roundId?: string;
+    serverTime: number;
+    sessionId: string;
+    stateType: {
+      thisRound: string;
+      nextRound: string;
+    };
+    uiMessages: unknown[];
+    win: {
+      max: number | null;
+      round: number;
+      total: number;
+    };
+  };
+  data: unknown;
+};
+type PlayRequest = {
+  contract: ContractPlayPayload;
+  extra?: unknown;
+};
+type PlayRequestEnhanced = PlayRequest & {
+  payloadToInject?: Record<string, unknown>;
+};
+type ContractPlayPayload = {
+  [key: string]: any;
+  bet: Bet | null;
+  forcedOutcomes?: unknown;
+};
+type PlayResponse = {
+  contract: {
+    bet: {
+      last: Bet | null;
+      lastPaid: Bet;
+    };
+    balance: {
+      coins: number;
+      version: number;
+    };
+    freeRounds: FreeRound[];
+    roundId: string;
+    serverTime: number;
+    stateType: {
+      thisRound: string;
+      nextRound: string;
+    };
+    uiMessages: unknown[];
+    win: {
+      round: number;
+      total: number;
+    };
+  };
+  data: unknown;
+};
+type FreeRoundsRequest = {
+  id: string;
+  action: 'ACCEPT' | 'DECLINE' | 'SKIP';
+};
+type FreeRoundsResponse = {
+  action: 'ACCEPT' | 'DECLINE' | 'SKIP';
+  id: string;
+};
+type GetBalanceResponse = {
+  balance: number;
+};
+type RgsErrorData = {
+  code: keyof typeof RgsErrorCode;
+  details?: unknown;
+};
+type RgsErrorWithType = {
+  type: 'timeout';
+} | {
+  type: 'error';
+  data: RgsErrorData;
+};
+type SdkOnlyMessagePayloadMap = {
+  configure: Partial<WrapperConfig>;
+  autoplay: {
+    action: 'start' | 'stop' | 'pause' | 'resume';
+  };
+  bet: Bet;
+  cashier: Cashier;
+  choice: {
+    message: string;
+    options: {
+      id: string;
+      label: string;
+    }[];
+  };
+  close: never;
+  error: SdkError;
+  fullscreen: {
+    lock?: OrientationLockType;
+  };
+  history: History;
+  loadEnd: never;
+  loadProgress: {
+    progress: number;
+  };
+  loadStart: never;
+  openGame: never;
+  play: PlayRequest;
+  playCycleEnd: PlayResponse;
+  playCycleStart: ContractPlayPayload;
+  playEnd: PlayResponse;
+  playReady: never;
+  playStart: ContractPlayPayload;
+  /**
+   * ```typescript
+   * {
+   *    my_custom_error: 'Something went wrong',
+   *    RgsError: {
+   *       OUT_OF_MONEY: 'You are out of credits',
+   *    }
+   * }
+   * ```
+   */
+  translations: NestedRecord<string, string>;
+  settings: Settings;
+  'telemetry.click': {
+    location: string;
+    name: string;
+  };
+  'telemetry.orientationChange': never;
+  freeRounds: FreeRoundsAction;
+  freeRoundsPopup: never;
+};
+type WrapperOnlyMessagePayloadMap = {
+  bet: Bet;
+  cashier: Cashier;
+  close: never;
+  configured: SdkConfig;
+  error: SdkError;
+  freeze: never;
+  history: History;
+  resume: never;
+  state: WrapperState;
+  suspend: never;
+  unfreeze: never;
+  legalBets: Record<number, number[]>;
+  play: PlayRequestEnhanced;
+  freeRounds: FreeRoundsAction;
+  freeRoundsOffer: FreeRound;
+  freeRoundsInfo: FreeRound;
+  freeRoundsComplete: FreeRound;
+  freeRoundsPopup: never;
+};
+type CasinoOnlyMessagePayloadMap = {
+  balance: {
+    balance: number;
+  };
+  bet: Bet;
+  cashier: Cashier;
+  choice: {
+    id: string;
+  };
+  close: never;
+  freeze: never;
+  getBalance: never;
+  help?: {
+    show: boolean;
+  };
+  history: History;
+  paytable?: {
+    show: boolean;
+  };
+  play: PlayRequest;
+  resume: never;
+  settings: Settings;
+  suspend: never;
+  unfreeze: never;
+  translations: NestedRecord<string, string>;
+};
+type RgsOnlyMessagePayloadMap = {
+  error: SdkError;
+  openGameError: RgsErrorWithType;
+  openGameResponse: OpenGameResponse;
+  playError: RgsErrorWithType;
+  playResponse: PlayResponse;
+  freeRoundsResponse: FreeRoundsResponse;
+  freeRoundsError: RgsErrorWithType;
+  realityCheck: {
+    duration: number;
+    sumBetAmount: number;
+    sumWinAmount: number;
+  };
+  balance: {
+    balance: number;
+  };
+};
+type TelemetryOnlyMessagePayloadMap = {
+  [key: string]: unknown;
+};
+type ToSdkForwardedMessageMap = Pick<CasinoOnlyMessagePayloadMap, 'balance' | 'bet' | 'choice' | 'freeze' | 'help' | 'paytable' | 'resume' | 'settings' | 'suspend' | 'unfreeze'> & Pick<RgsOnlyMessagePayloadMap, 'balance' | 'realityCheck' | 'openGameError' | 'openGameResponse' | 'playError' | 'playResponse'>;
+type ToCasinoPluginsForwardedMessageMap = {
+  sdk: Pick<SdkOnlyMessagePayloadMap, 'autoplay' | 'bet' | 'cashier' | 'choice' | 'close' | 'configure' | 'error' | 'history' | 'loadEnd' | 'loadProgress' | 'loadStart' | 'openGame' | 'play' | 'playCycleEnd' | 'playCycleStart' | 'playEnd' | 'playReady' | 'playStart' | 'settings' | 'fullscreen'>;
+  casino: undefined;
+  rgs: Pick<RgsOnlyMessagePayloadMap, 'balance' | 'playResponse' | 'playError' | 'openGameResponse'>;
+  telemetry: undefined;
+  wrapper: undefined;
+};
+type ToRgsPluginsForwardedMessageMap = {
+  sdk: Pick<SdkOnlyMessagePayloadMap, 'history' | 'openGame' | 'play'>;
+  casino: Pick<CasinoOnlyMessagePayloadMap, 'play' | 'cashier' | 'close' | 'history' | 'getBalance'>;
+  rgs: undefined;
+  telemetry: undefined;
+  wrapper: undefined;
+};
+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;
+};
+interface ForwardToPluginsMessageMap<SourceDomain extends DomainPrefix> {
+  casino: ToCasinoPluginsForwardedMessageMap[SourceDomain];
+  rgs: ToRgsPluginsForwardedMessageMap[SourceDomain];
+  telemetry: ToTelemetryPluginsForwardedMessageMap[SourceDomain];
+}
+type PluginDomain = keyof ForwardToPluginsMessageMap<any>;
+type ForwardToPluginsMessage<P extends PluginDomain> = keyof ForwardToPluginsMessageMap<'sdk'>[P] | keyof ForwardToPluginsMessageMap<'rgs'>[P] | keyof ForwardToPluginsMessageMap<'casino'>[P] | keyof ForwardToPluginsMessageMap<'telemetry'>[P] | keyof ForwardToPluginsMessageMap<'wrapper'>[P];
+type PrefixedForwardToPluginsMessage<P extends PluginDomain> = PrefixTypes<keyof ForwardToPluginsMessageMap<'sdk'>[P], 'sdk'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'rgs'>[P], 'rgs'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'casino'>[P], 'casino'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'telemetry'>[P], 'telemetry'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'wrapper'>[P], 'wrapper'>;
+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] & ForwardToPluginsMessageMap<'wrapper'>[P][M];
+type ForwardToSdkMessage = keyof ToSdkForwardedMessageMap;
+type ForwardToSdkMessagePayload<M extends ForwardToSdkMessage> = ToSdkForwardedMessageMap[M];
+type DomainToMessagePayloadMap = {
+  sdk: SdkOnlyMessagePayloadMap;
+  wrapper: WrapperOnlyMessagePayloadMap;
+  casino: CasinoOnlyMessagePayloadMap;
+  rgs: RgsOnlyMessagePayloadMap;
+  telemetry: TelemetryOnlyMessagePayloadMap;
+};
+type DomainPrefix = keyof DomainToMessagePayloadMap & string;
+type DomainAllowedPayloadMap<P extends DomainPrefix> = DomainToMessagePayloadMap[P];
+type DomainMessage<P extends DomainPrefix> = keyof DomainAllowedPayloadMap<P>;
+type DomainMessagePayload<P extends DomainPrefix, M extends DomainMessage<P>> = DomainAllowedPayloadMap<P>[M];
+type DomainMessageMessageEvent<P extends DomainPrefix, M extends DomainMessage<P>> = MessageEvent<{
+  message: M;
+  payload: DomainMessagePayload<P, M>;
+}>;
+type PrefixedMessagePayloadMap<P extends DomainPrefix> = PrefixKeys<DomainToMessagePayloadMap[P], P>;
+type PrefixedMessageMap = PrefixedMessagePayloadMap<'sdk'> & PrefixedMessagePayloadMap<'wrapper'> & PrefixedMessagePayloadMap<'casino'> & PrefixedMessagePayloadMap<'rgs'> & PrefixedMessagePayloadMap<'telemetry'>;
+type PrefixedMessage = keyof PrefixedMessageMap;
+type PrefixedMessagePayload<M extends PrefixedMessage> = PrefixedMessageMap[M];
+type PrefixedMessageMessageEvent<M extends PrefixedMessage> = MessageEvent<{
+  message: M;
+  payload: PrefixedMessagePayload<M>;
+}>;
+type MessageMap = DomainAllowedPayloadMap<'sdk'> & DomainAllowedPayloadMap<'wrapper'> & DomainAllowedPayloadMap<'casino'> & DomainAllowedPayloadMap<'rgs'> & DomainAllowedPayloadMap<'telemetry'> & PrefixedMessageMap;
+type Message = keyof MessageMap;
+type MessagePayload<M extends Message> = MessageMap[M];
+type MessageMessageEvent<M extends Message> = MessageEvent<{
+  message: M;
+  payload: MessagePayload<M>;
+}>;
+type RgsResponse<M extends DomainMessage<'sdk'>> = {
+  type: 'response';
+  response: `${M}Response` extends DomainMessage<'rgs'> ? DomainMessagePayload<'rgs', `${M}Response`> : never;
+} | {
+  type: 'error';
+  error: `${M}Error` extends DomainMessage<'rgs'> ? DomainMessagePayload<'rgs', `${M}Error`> : never;
+};
+//#endregion
+//#region src/common/i18n.d.ts
+declare class I18n {
+  #private;
+  constructor({
+    config
+  }: {
+    config: SdkConfig;
+  });
+  formatNumber(number: string | number, formatOptions?: Intl.NumberFormatOptions): string;
+  formatCurrency(number: string | number, options?: FormatCurrencyOptions, formatOptions?: Intl.NumberFormatOptions): string;
+  formatCoins(amount: number | string, formatOptions?: Intl.NumberFormatOptions): string;
+  formatCoinsWithCurrency(amount: number | string, formatOptions?: Intl.NumberFormatOptions): string;
+  formatMoney(amount: number | string, formatOptions?: Intl.NumberFormatOptions): string;
+  formatMoneyWithCurrency(amount: number | string, formatOptions?: Intl.NumberFormatOptions): string;
+}
+//#endregion
+export { ToTelemetryPluginsForwardedMessageMap as $, PlayRequest as A, RealityCheckConfig as B, GetBalanceResponse as C, MessageMessageEvent as D, MessageMap as E, PrefixedMessage as F, SdkConfig as G, RgsErrorWithType as H, PrefixedMessageMap as I, Settings as J, SdkError as K, PrefixedMessageMessageEvent as L, PlayResponse as M, PluginDomain as N, MessagePayload as O, PrefixedForwardToPluginsMessage as P, ToSdkForwardedMessageMap as Q, PrefixedMessagePayload as R, FreeRoundsResponse as S, Message as T, RgsOnlyMessagePayloadMap as U, RgsErrorData as V, RgsResponse as W, ToCasinoPluginsForwardedMessageMap as X, TelemetryOnlyMessagePayloadMap as Y, ToRgsPluginsForwardedMessageMap as Z, ForwardToSdkMessage as _, CashierConfig as a, RgsErrorCode as at, FreeRoundsAction as b, DomainAllowedPayloadMap as c, CurrencyNumber as ct, DomainMessagePayload as d, WrapperConfig as et, DomainPrefix as f, ForwardToPluginsMessagePayload as g, ForwardToPluginsMessageMap as h, Cashier as i, RgsError as it, PlayRequestEnhanced as j, OpenGameResponse as k, DomainMessage as l, FormatCurrencyOptions as lt, ForwardToPluginsMessage as m, AutoplayLimit as n, WrapperState as nt, CasinoOnlyMessagePayloadMap as o, TimeoutError as ot, DomainToMessagePayloadMap as p, SdkOnlyMessagePayloadMap as q, Bet as r, DeepPartial as rt, ContractPlayPayload as s, CurrencyFormat as st, I18n as t, WrapperOnlyMessagePayloadMap as tt, DomainMessageMessageEvent as u, ForwardToSdkMessagePayload as v, History as w, FreeRoundsRequest as x, FreeRound as y, PrefixedMessagePayloadMap as z };