@footballbingo/client 4.5.0 → 4.6.0

package/dist/services/LeaderboardService.d.ts

@@ -1,22 +0,0 @@
-import type { LeaderboardResponse } from '../models/LeaderboardResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import type { BaseHttpRequest } from '../core/BaseHttpRequest';
-export declare class LeaderboardService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Get leaderboard rankings
-     * Retrieve leaderboard rankings for various categories and time periods. Supports bingo wins, predictions, content creators, XP levels, speed runs, high scores, and streaks.
-     * @param category
-     * @param period
-     * @param limit
-     * @param streakType
-     * @returns any Leaderboard data retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1Leaderboard(category: 'bingo' | 'predictions' | 'creators' | 'xp' | 'popular' | 'bingo-speed' | 'bingo-high-scores' | 'bingo-streaks', period?: 'week' | 'month' | 'all-time', limit?: number, streakType?: 'current' | 'longest'): CancelablePromise<{
-        success: boolean;
-        data: LeaderboardResponse;
-        message?: string;
-    }>;
-}

package/dist/services/LeaderboardService.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LeaderboardService = void 0;
-class LeaderboardService {
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * Get leaderboard rankings
-     * Retrieve leaderboard rankings for various categories and time periods. Supports bingo wins, predictions, content creators, XP levels, speed runs, high scores, and streaks.
-     * @param category
-     * @param period
-     * @param limit
-     * @param streakType
-     * @returns any Leaderboard data retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1Leaderboard(category, period = 'week', limit = 10, streakType = 'current') {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/leaderboard',
-            query: {
-                'category': category,
-                'period': period,
-                'limit': limit,
-                'streakType': streakType,
-            },
-            errors: {
-                400: `Invalid parameters`,
-                500: `Server error`,
-            },
-        });
-    }
-}
-exports.LeaderboardService = LeaderboardService;

package/dist/services/MiniGamesService.d.ts

@@ -1,110 +0,0 @@
-import type { ListMiniGamesResponse } from '../models/ListMiniGamesResponse';
-import type { MiniGameInstanceResponse } from '../models/MiniGameInstanceResponse';
-import type { MiniGameLeaderboardResponse } from '../models/MiniGameLeaderboardResponse';
-import type { RevealClueResponse } from '../models/RevealClueResponse';
-import type { SpinAvailabilityResponse } from '../models/SpinAvailabilityResponse';
-import type { SpinResultResponse } from '../models/SpinResultResponse';
-import type { SubmitAttemptResponse } from '../models/SubmitAttemptResponse';
-import type { UnlockRetryResponse } from '../models/UnlockRetryResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import type { BaseHttpRequest } from '../core/BaseHttpRequest';
-export declare class MiniGamesService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * List all active mini games
-     * @returns any List of mini games with optional user status
-     * @throws ApiError
-     */
-    getApiV1MiniGames(): CancelablePromise<{
-        success: boolean;
-        data: ListMiniGamesResponse;
-        message?: string;
-    }>;
-    /**
-     * Check spin availability
-     * @returns any Spin availability with free/bonus spin status and segments
-     * @throws ApiError
-     */
-    getApiV1MiniGamesSpinAvailable(): CancelablePromise<{
-        success: boolean;
-        data: SpinAvailabilityResponse;
-        message?: string;
-    }>;
-    /**
-     * Execute a spin
-     * @returns any Spin result with segment and reward details
-     * @throws ApiError
-     */
-    postApiV1MiniGamesSpin(): CancelablePromise<{
-        success: boolean;
-        data: SpinResultResponse;
-        message?: string;
-    }>;
-    /**
-     * Get today's mini game instance
-     * @param gameType
-     * @returns any Today's mini game instance with payload and user status
-     * @throws ApiError
-     */
-    getApiV1MiniGamesToday(gameType: 'daily_quiz' | 'guess_the_player'): CancelablePromise<{
-        success: boolean;
-        data: MiniGameInstanceResponse;
-        message?: string;
-    }>;
-    /**
-     * Submit a mini game attempt
-     * @param gameType
-     * @param requestBody
-     * @returns any Attempt result with score, rewards, and retry info
-     * @throws ApiError
-     */
-    postApiV1MiniGamesSubmit(gameType: 'daily_quiz' | 'guess_the_player', requestBody?: {
-        submission: ({
-            answers: Array<number>;
-        } | {
-            guess: string;
-        });
-    }): CancelablePromise<{
-        success: boolean;
-        data: SubmitAttemptResponse;
-        message?: string;
-    }>;
-    /**
-     * Unlock a retry attempt
-     * @param gameType
-     * @param requestBody
-     * @returns any Retry unlocked with method and expiry
-     * @throws ApiError
-     */
-    postApiV1MiniGamesRetry(gameType: 'daily_quiz' | 'guess_the_player', requestBody?: {
-        method: 'ad' | 'coins';
-    }): CancelablePromise<{
-        success: boolean;
-        data: UnlockRetryResponse;
-        message?: string;
-    }>;
-    /**
-     * Get leaderboard for a game type
-     * @param gameType
-     * @param period
-     * @param limit
-     * @returns any Mini game leaderboard with entries and current user position
-     * @throws ApiError
-     */
-    getApiV1MiniGamesLeaderboard(gameType: 'daily_quiz' | 'guess_the_player', period?: 'week' | 'month' | 'all-time', limit?: number): CancelablePromise<{
-        success: boolean;
-        data: MiniGameLeaderboardResponse;
-        message?: string;
-    }>;
-    /**
-     * Reveal the next clue for Guess the Player
-     * @returns any Revealed clue with type and text
-     * @throws ApiError
-     */
-    postApiV1MiniGamesGuessThePlayerRevealClue(): CancelablePromise<{
-        success: boolean;
-        data: RevealClueResponse;
-        message?: string;
-    }>;
-}

package/dist/services/MiniGamesService.js

@@ -1,149 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiniGamesService = void 0;
-class MiniGamesService {
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * List all active mini games
-     * @returns any List of mini games with optional user status
-     * @throws ApiError
-     */
-    getApiV1MiniGames() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/mini-games',
-        });
-    }
-    /**
-     * Check spin availability
-     * @returns any Spin availability with free/bonus spin status and segments
-     * @throws ApiError
-     */
-    getApiV1MiniGamesSpinAvailable() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/mini-games/spin/available',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Execute a spin
-     * @returns any Spin result with segment and reward details
-     * @throws ApiError
-     */
-    postApiV1MiniGamesSpin() {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/mini-games/spin',
-            errors: {
-                400: `No spins available`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get today's mini game instance
-     * @param gameType
-     * @returns any Today's mini game instance with payload and user status
-     * @throws ApiError
-     */
-    getApiV1MiniGamesToday(gameType) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/mini-games/{gameType}/today',
-            path: {
-                'gameType': gameType,
-            },
-            errors: {
-                404: `Mini game instance not found`,
-            },
-        });
-    }
-    /**
-     * Submit a mini game attempt
-     * @param gameType
-     * @param requestBody
-     * @returns any Attempt result with score, rewards, and retry info
-     * @throws ApiError
-     */
-    postApiV1MiniGamesSubmit(gameType, requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/mini-games/{gameType}/submit',
-            path: {
-                'gameType': gameType,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Maximum attempts reached or retry not unlocked`,
-                401: `Unauthorized`,
-                404: `Mini game not found`,
-            },
-        });
-    }
-    /**
-     * Unlock a retry attempt
-     * @param gameType
-     * @param requestBody
-     * @returns any Retry unlocked with method and expiry
-     * @throws ApiError
-     */
-    postApiV1MiniGamesRetry(gameType, requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/mini-games/{gameType}/retry',
-            path: {
-                'gameType': gameType,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Insufficient balance or maximum retries reached`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get leaderboard for a game type
-     * @param gameType
-     * @param period
-     * @param limit
-     * @returns any Mini game leaderboard with entries and current user position
-     * @throws ApiError
-     */
-    getApiV1MiniGamesLeaderboard(gameType, period = 'week', limit = 50) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/mini-games/{gameType}/leaderboard',
-            path: {
-                'gameType': gameType,
-            },
-            query: {
-                'period': period,
-                'limit': limit,
-            },
-        });
-    }
-    /**
-     * Reveal the next clue for Guess the Player
-     * @returns any Revealed clue with type and text
-     * @throws ApiError
-     */
-    postApiV1MiniGamesGuessThePlayerRevealClue() {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/mini-games/guess_the_player/reveal-clue',
-            errors: {
-                400: `All clues already revealed or cannot reveal`,
-                401: `Unauthorized`,
-                404: `No active game found`,
-            },
-        });
-    }
-}
-exports.MiniGamesService = MiniGamesService;

package/dist/services/NotificationsService.d.ts

@@ -1,134 +0,0 @@
-import type { GetHistoryResponse } from '../models/GetHistoryResponse';
-import type { GetPreferencesResponse } from '../models/GetPreferencesResponse';
-import type { MarkAsReadResponse } from '../models/MarkAsReadResponse';
-import type { RegisterTokenResponse } from '../models/RegisterTokenResponse';
-import type { TestNotificationResponse } from '../models/TestNotificationResponse';
-import type { UnreadCountResponse } from '../models/UnreadCountResponse';
-import type { UnsubscribeResponse } from '../models/UnsubscribeResponse';
-import type { UpdatePreferencesResponse } from '../models/UpdatePreferencesResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import type { BaseHttpRequest } from '../core/BaseHttpRequest';
-export declare class NotificationsService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Register device for push notifications
-     * @param requestBody
-     * @returns any Device token registered
-     * @throws ApiError
-     */
-    postApiV1NotificationsRegister(requestBody?: {
-        token: string;
-        platform: 'ios' | 'android' | 'web';
-        deviceInfo?: {
-            userAgent?: string;
-            language?: string;
-            timezone?: string;
-        };
-    }): CancelablePromise<{
-        success: boolean;
-        data: RegisterTokenResponse;
-        message?: string;
-    }>;
-    /**
-     * Get notification preferences
-     * @returns any User notification preferences
-     * @throws ApiError
-     */
-    getApiV1NotificationsPreferences(): CancelablePromise<{
-        success: boolean;
-        data: GetPreferencesResponse;
-        message?: string;
-    }>;
-    /**
-     * Update notification preferences
-     * @param requestBody
-     * @returns any Preferences updated
-     * @throws ApiError
-     */
-    putApiV1NotificationsPreferences(requestBody?: {
-        gameStartReminders?: boolean;
-        gameResults?: boolean;
-        matchEvents?: boolean;
-        predictionResults?: boolean;
-        dailyChallenges?: boolean;
-        newsUpdates?: boolean;
-        achievements?: boolean;
-        leaderboardUpdates?: boolean;
-        multiplayerInvites?: boolean;
-        starredTeamKickoff?: boolean;
-        starredTeamHalftime?: boolean;
-        starredTeamFulltime?: boolean;
-        starredTeamGoals?: boolean;
-        starredTeamCards?: boolean;
-        starredTeamSubs?: boolean;
-        starredPlayerGoals?: boolean;
-        starredPlayerCards?: boolean;
-        starredPlayerSubs?: boolean;
-        starredFixtureEvents?: boolean;
-        starredLeagueMatchday?: boolean;
-        starredMatchReminder?: boolean;
-        starredNewsUpdates?: boolean;
-        socialActivity?: boolean;
-    }): CancelablePromise<{
-        success: boolean;
-        data: UpdatePreferencesResponse;
-        message?: string;
-    }>;
-    /**
-     * Unsubscribe from push notifications
-     * @param requestBody
-     * @returns any Unsubscribed successfully
-     * @throws ApiError
-     */
-    postApiV1NotificationsUnsubscribe(requestBody?: {
-        token?: string;
-    }): CancelablePromise<{
-        success: boolean;
-        data: UnsubscribeResponse;
-        message?: string;
-    }>;
-    /**
-     * Get notification history
-     * @param limit
-     * @param offset
-     * @returns any Notification history with unread count
-     * @throws ApiError
-     */
-    getApiV1NotificationsHistory(limit?: number, offset?: number | null): CancelablePromise<{
-        success: boolean;
-        data: GetHistoryResponse;
-        message?: string;
-    }>;
-    /**
-     * Get unread notification count
-     * @returns any Unread count
-     * @throws ApiError
-     */
-    getApiV1NotificationsUnreadCount(): CancelablePromise<{
-        success: boolean;
-        data: UnreadCountResponse;
-        message?: string;
-    }>;
-    /**
-     * Mark notification as read
-     * @param id
-     * @returns any Notification marked as read
-     * @throws ApiError
-     */
-    putApiV1NotificationsRead(id: string): CancelablePromise<{
-        success: boolean;
-        data: MarkAsReadResponse;
-        message?: string;
-    }>;
-    /**
-     * Send test notification
-     * @returns any Test notification sent
-     * @throws ApiError
-     */
-    postApiV1NotificationsTest(): CancelablePromise<{
-        success: boolean;
-        data: TestNotificationResponse;
-        message?: string;
-    }>;
-}

package/dist/services/NotificationsService.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationsService = void 0;
-class NotificationsService {
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * Register device for push notifications
-     * @param requestBody
-     * @returns any Device token registered
-     * @throws ApiError
-     */
-    postApiV1NotificationsRegister(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/notifications/register',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Invalid input`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get notification preferences
-     * @returns any User notification preferences
-     * @throws ApiError
-     */
-    getApiV1NotificationsPreferences() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/notifications/preferences',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Update notification preferences
-     * @param requestBody
-     * @returns any Preferences updated
-     * @throws ApiError
-     */
-    putApiV1NotificationsPreferences(requestBody) {
-        return this.httpRequest.request({
-            method: 'PUT',
-            url: '/api/v1/notifications/preferences',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Invalid preference keys`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Unsubscribe from push notifications
-     * @param requestBody
-     * @returns any Unsubscribed successfully
-     * @throws ApiError
-     */
-    postApiV1NotificationsUnsubscribe(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/notifications/unsubscribe',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get notification history
-     * @param limit
-     * @param offset
-     * @returns any Notification history with unread count
-     * @throws ApiError
-     */
-    getApiV1NotificationsHistory(limit = 20, offset) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/notifications/history',
-            query: {
-                'limit': limit,
-                'offset': offset,
-            },
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get unread notification count
-     * @returns any Unread count
-     * @throws ApiError
-     */
-    getApiV1NotificationsUnreadCount() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/notifications/unread-count',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Mark notification as read
-     * @param id
-     * @returns any Notification marked as read
-     * @throws ApiError
-     */
-    putApiV1NotificationsRead(id) {
-        return this.httpRequest.request({
-            method: 'PUT',
-            url: '/api/v1/notifications/{id}/read',
-            path: {
-                'id': id,
-            },
-            errors: {
-                400: `Notification ID required`,
-                401: `Unauthorized`,
-                404: `Notification not found`,
-            },
-        });
-    }
-    /**
-     * Send test notification
-     * @returns any Test notification sent
-     * @throws ApiError
-     */
-    postApiV1NotificationsTest() {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/notifications/test',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-}
-exports.NotificationsService = NotificationsService;