@smartico/public-api 0.0.378 → 0.0.380

package/dist/WSAPI/WSAPIGamePick.d.ts

@@ -0,0 +1,308 @@
+import { GamesApiResponse, GamePickRound, GamePickRoundBoard, GamePickUserInfo, GamePickGameInfo, GamePickRequestParams, GamePickRoundRequestParams } from './WSAPITypes';
+import { WSAPIAvatars } from './WSAPIAvatars';
+/** @group GamePick */
+export declare class WSAPIGamePick extends WSAPIAvatars {
+    /**
+     * Returns the active rounds for the specified MatchX or Quiz game.
+     * Each round includes its events (matches/questions) along with the current user's selections and scores.
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     *
+     * **Response** `GamesApiResponse<GamePickRound[]>`:
+     * - `errCode` - 0 on success
+     * - `data` - Array of rounds, each containing:
+     *   - `round_id`, `round_name` - Round identifier and display name
+     *   - `open_date`, `last_bet_date` - Timestamps (ms) for round open and betting deadline
+     *   - `is_active_now`, `is_resolved` - Round state flags
+     *   - `round_status_id` - Round status: -1 (active), 2 (no more bets), 3 (all events resolved), 4 (round resolved)
+     *   - `score_full_win`, `score_part_win`, `score_lost` - Scoring rules per prediction outcome
+     *   - `user_score` - Current user's total score in this round
+     *   - `user_placed_bet` - Whether the user has submitted predictions
+     *   - `has_open_for_bet_events` - Whether there are events still open for betting
+     *   - `events[]` - Array of events with `gp_event_id`, `market_type_id`, `event_meta` (team names, images, sport), `match_date`, `is_open_for_bets`, `odds_details`, and user selection fields
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetActiveRounds({
+     *      saw_template_id: 1083,
+     * }).then((result) => {
+     *      console.log(result.data); // GamePickRound[]
+     *      result.data.forEach(round => {
+     *          console.log(round.round_name, round.events.length);
+     *      });
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetActiveRounds(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickRound[]>>;
+    /**
+     * Returns a single active round for the specified MatchX or Quiz game.
+     * The round includes full event details with the current user's selections.
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     * @param props.round_id - The specific round to retrieve
+     *
+     * **Response** `GamesApiResponse<GamePickRound>`:
+     * - `errCode` - 0 on success
+     * - `data` - Single round object with the same structure as in `gamePickGetActiveRounds`,
+     *   including `events[]` with full event details, user selections, and resolution info
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetActiveRound({
+     *      saw_template_id: 1083,
+     *      round_id: 31652,
+     * }).then((result) => {
+     *      console.log(result.data.round_name, result.data.events.length);
+     *      console.log(result.data.user_score, result.data.user_placed_bet);
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetActiveRound(props: GamePickRoundRequestParams): Promise<GamesApiResponse<GamePickRound>>;
+    /**
+     * Returns the history of all rounds (including resolved ones) for the specified MatchX or Quiz game.
+     * Each round contains full event details with results and the current user's predictions.
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     *
+     * **Response** `GamesApiResponse<GamePickRound[]>`:
+     * - `errCode` - 0 on success
+     * - `data` - Array of rounds ordered by `round_row_id` descending (newest first).
+     *   Each round has the same structure as in `gamePickGetActiveRounds`, including resolved events
+     *   with `resolution_type_id` (0=None, 2=Lost, 3=PartialWin, 4=FullWin) and `resolution_score`
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetHistory({
+     *      saw_template_id: 1083,
+     * }).then((result) => {
+     *      result.data.forEach(round => {
+     *          console.log(round.round_name, 'Score:', round.user_score, 'Resolved:', round.is_resolved);
+     *      });
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetHistory(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickRound[]>>;
+    /**
+     * Returns the leaderboard for a specific round within a MatchX or Quiz game.
+     * Use `round_id = -1` (AllRoundsGameBoardID) to get the season/overall leaderboard across all rounds.
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     * @param props.round_id - The round to get the leaderboard for. Use -1 for overall/seasonal leaderboard
+     *
+     * **Response** `GamesApiResponse<GamePickRoundBoard>`:
+     * - `errCode` - 0 on success
+     * - `data` - Leaderboard object containing:
+     *   - Round base fields (`round_id`, `round_name`, `open_date`, `last_bet_date`, etc.)
+     *   - `users[]` - Ranked list of players, each with:
+     *     - `ext_user_id`, `int_user_id` - User identifiers
+     *     - `public_username`, `avatar_url` - Display info (usernames may be masked based on label settings)
+     *     - `gp_position` - Leaderboard rank (null if not yet ranked)
+     *     - `resolution_score` - Total score in this round
+     *     - `full_wins_count`, `part_wins_count`, `lost_count` - Prediction outcome counts
+     *   - `my_user` - Current user's entry (same fields as above), or null if user hasn't participated
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetBoard({
+     *      saw_template_id: 1083,
+     *      round_id: 31652,
+     * }).then((result) => {
+     *      console.log('Top players:', result.data.users);
+     *      console.log('My position:', result.data.my_user?.gp_position);
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetBoard(props: GamePickRoundRequestParams): Promise<GamesApiResponse<GamePickRoundBoard>>;
+    /**
+     * Submits score predictions for a round in a MatchX game.
+     * Sends the round object with user selections for all events at once.
+     * Each event must include `team1_user_selection` and `team2_user_selection` representing predicted scores.
+     * If the user hasn't placed bets before, one game attempt (spin) will be consumed.
+     * Predictions can be edited until each match starts (if `allow_edit_answers` is enabled on the round).
+     *
+     * @param props.saw_template_id - The ID of the MatchX game template
+     * @param props.round - Round object containing `round_id` and `events[]`. Typically obtained from `gamePickGetActiveRound`
+     *   and modified with user predictions. Each event needs: `gp_event_id`, `team1_user_selection`, `team2_user_selection`
+     *
+     * **Response** `GamesApiResponse<GamePickRound>`:
+     * - `errCode` - 0 on success. Non-zero codes indicate errors (e.g. not enough points/attempts)
+     * - `data` - Updated round with all events reflecting the submitted selections.
+     *   `user_placed_bet` will be `true`, `has_not_submitted_changes` will be `false`
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetActiveRound({
+     *      saw_template_id: 1190,
+     *      round_id: 38665,
+     * }).then((roundData) => {
+     *      const round = roundData.data;
+     *      round.events = round.events.map(e => ({
+     *          gp_event_id: e.gp_event_id,
+     *          team1_user_selection: 1,
+     *          team2_user_selection: 0,
+     *      }));
+     *      _smartico.api.gamePickSubmitSelection({
+     *          saw_template_id: 1190,
+     *          round: round,
+     *      }).then((result) => {
+     *          console.log(result.data.user_placed_bet); // true
+     *      });
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickSubmitSelection(props: GamePickRequestParams & {
+        round: Partial<GamePickRound>;
+    }): Promise<GamesApiResponse<GamePickRound>>;
+    /**
+     * Submits answers for a round in a Quiz game.
+     * Sends the round object with user answers for all events at once.
+     * Each event must include `user_selection` with the answer value (e.g. '1', '2', 'x', 'yes', 'no' — depending on the market type).
+     * If the user hasn't placed bets before, one game attempt (spin) will be consumed.
+     * Answers can be edited until each match starts (if `allow_edit_answers` is enabled on the round).
+     *
+     * @param props.saw_template_id - The ID of the Quiz game template
+     * @param props.round - Round object containing `round_id` and `events[]`. Typically obtained from `gamePickGetActiveRound`
+     *   and modified with user answers. Each event needs: `gp_event_id`, `user_selection`
+     *
+     * **Response** `GamesApiResponse<GamePickRound>`:
+     * - `errCode` - 0 on success. Non-zero codes indicate errors (e.g. not enough points/attempts)
+     * - `data` - Updated round with all events reflecting the submitted answers.
+     *   `user_placed_bet` will be `true`, `has_not_submitted_changes` will be `false`
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetActiveRound({
+     *      saw_template_id: 1183,
+     *      round_id: 37974,
+     * }).then((roundData) => {
+     *      const round = roundData.data;
+     *      round.events = round.events.map(e => ({
+     *          gp_event_id: e.gp_event_id,
+     *          user_selection: 'x',
+     *      }));
+     *      _smartico.api.gamePickSubmitSelectionQuiz({
+     *          saw_template_id: 1183,
+     *          round: round,
+     *      }).then((result) => {
+     *          console.log(result.data.user_placed_bet); // true
+     *      });
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickSubmitSelectionQuiz(props: GamePickRequestParams & {
+        round: Partial<GamePickRound>;
+    }): Promise<GamesApiResponse<GamePickRound>>;
+    /**
+     * Returns the current user's profile information within the specified MatchX or Quiz game.
+     * The user record is synced from the Smartico platform into the games DB (synced every 1 minute).
+     * If the user doesn't exist in the games DB yet, it will be created automatically on first call.
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     *
+     * **Response** `GamesApiResponse<GamePickUserInfo>`:
+     * - `errCode` - 0 on success
+     * - `data`:
+     *   - `ext_user_id` - External user ID (Smartico internal numeric ID)
+     *   - `int_user_id` - Internal user ID within the games system
+     *   - `public_username` - Display name
+     *   - `avatar_url` - User's avatar image URL
+     *   - `last_wallet_sync_time` - Last time the user's balance was synced from Smartico
+     *   - `ach_points_balance` - User's current points balance
+     *   - `ach_gems_balance` - User's current gems balance
+     *   - `ach_diamonds_balance` - User's current diamonds balance
+     *   - `pubic_username_set` - Whether the user has set a custom username
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetUserInfo({
+     *      saw_template_id: 1083,
+     * }).then((result) => {
+     *      console.log(result.data.public_username, result.data.ach_points_balance);
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetUserInfo(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickUserInfo>>;
+    /**
+     * Returns the game configuration and the list of all rounds for the specified MatchX or Quiz game.
+     * Includes the SAW template definition, label settings, and round metadata (without events).
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     *
+     * **Response** `GamesApiResponse<GamePickGameInfo>`:
+     * - `errCode` - 0 on success
+     * - `data`:
+     *   - `sawTemplate` - Game template configuration including:
+     *     - `saw_template_id`, `saw_game_type_id` (6 = MatchX/Quiz)
+     *     - `saw_template_ui_definition` - UI settings (name, ranking options, ask_for_username, etc.)
+     *     - `saw_buyin_type_id` - Cost type (1=Free, 2=Points, 3=Gems, 4=Diamonds, 5=Spins)
+     *     - `buyin_cost_points` - Cost per attempt
+     *     - `spin_count` - Available attempts for the current user
+     *   - `allRounds[]` - List of all rounds (metadata only, no events), each with:
+     *     - `round_id`, `round_name`, `round_description`
+     *     - `open_date`, `last_bet_date` - Timestamps (ms)
+     *     - `is_active_now`, `is_resolved`, `round_status_id`
+     *   - `labelInfo` - Label/brand configuration and settings
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetGameInfo({
+     *      saw_template_id: 1189,
+     * }).then((result) => {
+     *      console.log(result.data.sawTemplate.saw_template_ui_definition.name);
+     *      console.log('Rounds:', result.data.allRounds.length);
+     *      console.log('Buy-in type:', result.data.sawTemplate.saw_buyin_type_id);
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetGameInfo(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickGameInfo>>;
+    /**
+     * Returns round data with events and picks for a specific user (identified by their internal user ID).
+     * Useful for viewing another user's predictions from the leaderboard.
+     * The `int_user_id` can be obtained from the `gamePickGetBoard` response (`users[].int_user_id`).
+     *
+     * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+     * @param props.round_id - The round to get info for
+     * @param props.int_user_id - Internal user ID of the player whose predictions to view (from leaderboard data)
+     *
+     * **Response** `GamesApiResponse<GamePickRound>`:
+     * - `errCode` - 0 on success
+     * - `data` - Round object with the target user's selections.
+     *   Same structure as `gamePickGetActiveRound`, but `user_selection`/`team1_user_selection`/`team2_user_selection`
+     *   fields on events reflect the specified user's picks instead of the current user's.
+     *   Events also include `resolution_type_id` (0=None, 2=Lost, 3=PartialWin, 4=FullWin) showing how each prediction was scored
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.gamePickGetRoundInfoForUser({
+     *      saw_template_id: 1083,
+     *      round_id: 31652,
+     *      int_user_id: 65653810,
+     * }).then((result) => {
+     *      result.data.events.forEach(e => {
+     *          console.log(e.event_meta.team1_name, 'vs', e.event_meta.team2_name, '→', e.user_selection);
+     *      });
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     */
+    gamePickGetRoundInfoForUser(props: GamePickRoundRequestParams & {
+        int_user_id: number;
+    }): Promise<GamesApiResponse<GamePickRound>>;
+}

package/dist/WSAPI/WSAPIGeneral.d.ts

@@ -0,0 +1,30 @@
+import { TGetTranslations, TUICustomSection } from './WSAPITypes';
+import { GetRelatedAchTourResponse } from '../Missions/GetRelatedAchTourResponse';
+import { WSAPIUser } from './WSAPIUser';
+/** @group General */
+export declare class WSAPIGeneral extends WSAPIUser {
+    getCustomSections(): Promise<TUICustomSection[]>;
+    /**
+     * Requests translations for the given language. Returns the object including translation key/translation value pairs. All possible translation keys defined in the back office.
+     */
+    getTranslations(lang_code: string): Promise<TGetTranslations>;
+    /**
+     * Returns all the related tournaments and missions for the provided game id for the current user
+     * The provided Game ID should correspond to the ID from the Games Catalog - https://help.smartico.ai/welcome/technical-guides/games-catalog-api
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.getRelatedItemsForGame('gold-slot2').then((result) => {
+     *      console.log(result);
+     * });
+     * ```
+     *
+     * **Example in the Visitor mode**:
+     * ```
+     * _smartico.vapi('EN').getRelatedItemsForGame('gold-slot2').then((result) => {
+     *      console.log(result);
+     * });
+     * ```
+     */
+    getRelatedItemsForGame(related_game_id: string): Promise<GetRelatedAchTourResponse>;
+}

package/dist/WSAPI/WSAPIInbox.d.ts

@@ -0,0 +1,126 @@
+import { ActivityTypeLimited } from '../Core';
+import { InboxMarkMessageAction, TInboxMessage, TInboxMessageBody } from './WSAPITypes';
+import { InboxCategories } from '../Inbox/InboxCategories';
+import { InboxReadStatus } from '../Inbox/InboxReadStatus';
+import { WSAPILeaderBoard } from './WSAPILeaderBoard';
+/** @group Inbox */
+export declare class WSAPIInbox extends WSAPILeaderBoard {
+    /**
+     * Reports an impression event for an engagement (when engagement content is displayed to the user).
+     * Use this method to track when users view engagement content such as inbox messages, popups.
+     * When using for Inbox cases, you need to use message guid as engagement_uid, and pass 31 as activityType.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.reportImpressionEvent({
+     *      engagement_uid: 'abc123-def456',
+     *      activityType: 31 // Inbox
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     *
+     * @param params - Event parameters
+     * @param params.engagement_uid - Unique identifier for the engagement
+     * @param params.activityType - Type of engagement activity (Popup=30, Inbox=31)
+     */
+    reportImpressionEvent({ engagement_uid, activityType, }: {
+        engagement_uid: string;
+        activityType: ActivityTypeLimited | number;
+    }): void;
+    /**
+     * Reports a click/action event for an engagement (when user interacts with engagement content).
+     * Use this method to track when users click on or interact with engagement content such as inbox messages, popups.
+     * When using for Inbox cases, you need to use message guid as engagement_uid, and pass 31 as activityType, and pass the action/deeplink that was triggered by the user interaction as action.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.reportClickEvent({
+     *      engagement_uid: 'abc123-def456',
+     *      activityType: 31 // Inbox
+     *      action: 'dp:gf_missions'
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     *
+     * @param params - Event parameters
+     * @param params.engagement_uid - Unique identifier for the engagement
+     * @param params.activityType - Type of engagement activity (Popup=30, Inbox=31)
+     * @param params.action - Optional action/deeplink that was triggered by the user interaction
+     */
+    reportClickEvent({ engagement_uid, activityType, action, }: {
+        engagement_uid: string;
+        activityType: ActivityTypeLimited | number;
+        action?: string;
+    }): void;
+    /** Returns inbox messages based on the provided parameters. "From" and "to" indicate the range of messages to be fetched.
+     * The maximum number of messages per request is limited to 20.
+     * An indicator "onlyFavorite" can be passed to get only messages marked as favorites.
+     * An indicator "read_status" can be passed to get only messages marked as read or unread.
+     * You can leave this params empty and by default it will return list of messages ranging from 0 to 20.
+     * This function returns a list of messages without the body of each message.
+     * To get the body of the message you need to call getInboxMessageBody function and pass the message guid contained in each message of this request.
+     * All other action like mark as read, favorite, delete, etc. can be done using this message GUID.
+     * The "onUpdate" callback will be triggered when the user receives a new message. It will provide an updated list of messages, ranging from 0 to 20, to the onUpdate callback function.
+     *
+     * **Visitor mode: not supported**
+     *
+     * @param params
+     */
+    getInboxMessages({ from, to, onlyFavorite, categoryId, read_status, onUpdate, }?: {
+        from?: number;
+        to?: number;
+        onlyFavorite?: boolean;
+        categoryId?: InboxCategories;
+        read_status?: InboxReadStatus;
+        onUpdate?: (data: TInboxMessage[]) => void;
+    }): Promise<TInboxMessage[]>;
+    /**
+     * Returns inbox unread count.
+     *
+     * **Visitor mode: not supported**
+     * @param params
+     */
+    getInboxUnreadCount({ onUpdate }?: {
+        onUpdate?: (unread_count: number) => void;
+    }): Promise<number>;
+    /**
+     * Returns the message body of the specified message guid.
+     *
+     * **Visitor mode: not supported**
+     */
+    getInboxMessageBody(messageGuid: string): Promise<TInboxMessageBody>;
+    /**
+     * Requests to mark inbox message with specified guid as read
+     *
+     * **Visitor mode: not supported**
+     */
+    markInboxMessageAsRead(messageGuid: string): Promise<InboxMarkMessageAction>;
+    /**
+     * Requests to mark all inbox messages as read
+     *
+     * **Visitor mode: not supported**
+     */
+    markAllInboxMessagesAsRead(): Promise<InboxMarkMessageAction>;
+    /**
+     * Requests to mark inbox message with specified guid as favorite. Pass mark true to add message to favorite and false to remove.
+     *
+     * **Visitor mode: not supported**
+     */
+    markUnmarkInboxMessageAsFavorite(messageGuid: string, mark: boolean): Promise<InboxMarkMessageAction>;
+    /**
+     * Requests to delete inbox message
+     *
+     * **Visitor mode: not supported**
+     */
+    deleteInboxMessage(messageGuid: string): Promise<InboxMarkMessageAction>;
+    /**
+     * Requests to delete all inbox messages
+     *
+     * **Visitor mode: not supported**
+     */
+    deleteAllInboxMessages(): Promise<InboxMarkMessageAction>;
+    protected updateInboxUnreadCount(count: number): Promise<void>;
+    protected updateInboxMessages(): Promise<void>;
+}

package/dist/WSAPI/WSAPIJackpots.d.ts

@@ -0,0 +1,109 @@
+import { JackpotDetails, JackpotWinnerHistory, JackpotsOptinResponse, JackpotsOptoutResponse } from '../Jackpots';
+import { TGetJackpotEligibleGamesResponse } from '../Jackpots/GetJackpotEligibleGamesResponse';
+import { WSAPIClans } from './WSAPIClans';
+/** @group Jackpots */
+export declare class WSAPIJackpots extends WSAPIClans {
+    /** @hidden */
+    protected jackpotGetSignature: string;
+    protected jackpotClearCache(): Promise<void>;
+    /** Returns list of Jackpots that are active in the system and matching to the filter definition.
+     * If filter is not provided, all active jackpots will be returned.
+     * Filter can be used to get jackpots related to specific game or specific jackpot template.
+     * You can call this method every second in order to get up to date information about current value of the jackpot(s) and present them to the end-users
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.jackpotGet({ related_game_id: 'wooko-slot' }).then((result) => {
+     *      console.log(result);
+     * });
+     * ```
+     *
+     * **Example in the Visitor mode**:
+     * ```
+     * _smartico.vapi('EN').jackpotGet({ related_game_id: 'wooko-slot' }).then((result) => {
+     *      console.log(result);
+     * });
+     * ```
+     */
+    jackpotGet(filter?: {
+        related_game_id?: string;
+        jp_template_id?: number;
+    }): Promise<JackpotDetails[]>;
+    /**
+     * Opt-in currently logged in user to the jackpot with the specified jp_template_id.
+     * You may call jackpotGet method after doing optin to see that user is opted in to the jackpot.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.jackpotOptIn({ jp_template_id: 123 }).then((result) => {
+     *      console.log('Opted in to the jackpot');
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     *
+     */
+    jackpotOptIn(filter: {
+        jp_template_id: number;
+    }): Promise<JackpotsOptinResponse>;
+    /**
+     * Opt-out currently logged in user from the jackpot with the specified jp_template_id.
+     * You may call jackpotGet method after doing optout to see that user is not opted in to the jackpot.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.jackpotOptOut({ jp_template_id: 123 }).then((result) => {
+     *      console.log('Opted out from the jackpot');
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     *
+     */
+    jackpotOptOut(filter: {
+        jp_template_id: number;
+    }): Promise<JackpotsOptoutResponse>;
+    /**
+     * Returns jackpot winners for the given `jp_template_id` (paginated on the server).
+     * Default page size on the wire is 20; use `limit`, `offset`, and repeated calls to load more.
+     * The full protocol response also includes `has_more`; this method returns only the `winners` array.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.getJackpotWinners({
+     *      jp_template_id: 123,
+     * }).then((result) => {
+     *      console.log(result);
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     *
+     * @param params - Jackpot winners parameters
+     * @param params.jp_template_id - Jackpot template id (required; throws if missing)
+     * @param params.limit - Page size (server default 20 when omitted)
+     * @param params.offset - Offset into the winner list
+     */
+    getJackpotWinners({ limit, offset, jp_template_id, }: {
+        limit?: number;
+        offset?: number;
+        jp_template_id?: number;
+    }): Promise<JackpotWinnerHistory[]>;
+    /**
+     * Returns the eligible games for the jackpot with the specified jp_template_id.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.getJackpotEligibleGames({ jp_template_id: 123 }).then((result) => {
+     *      console.log(result);
+     * });
+     * ```
+     *
+     * **Visitor mode: not supported**
+     *
+     */
+    getJackpotEligibleGames({ jp_template_id, onUpdate }: {
+        jp_template_id: number;
+        onUpdate?: () => void;
+    }): Promise<TGetJackpotEligibleGamesResponse>;
+}

package/dist/WSAPI/WSAPILeaderBoard.d.ts

@@ -0,0 +1,25 @@
+import { LeaderBoardDetailsT } from './WSAPITypes';
+import { LeaderBoardPeriodType } from '../Leaderboard';
+import { WSAPIGamePick } from './WSAPIGamePick';
+/** @group LeaderBoard */
+export declare class WSAPILeaderBoard extends WSAPIGamePick {
+    /**
+     * Returns the leaderboard for the current type (default is Daily). If getPreviousPeriod is passed as true, a leaderboard for the previous period for the current type will be returned.
+     * For example, if the type is Weekly and getPreviousPeriod is true, a leaderboard for the previous week will be returned.
+     *
+     * **Example**:
+     * ```
+     * _smartico.api.getLeaderBoard(1).then((result) => {
+     *     console.log(result);
+     * });
+     * ```
+     *
+     * **Example in the Visitor mode**:
+     * ```
+     * _smartico.vapi('EN').getLeaderBoard(1).then((result) => {
+     *    console.log(result);
+     * });
+     * ```
+     */
+    getLeaderBoard(periodType: LeaderBoardPeriodType, getPreviousPeriod?: boolean): Promise<LeaderBoardDetailsT>;
+}