@footballbingo/client 1.0.0

package/dist/services/LeaderboardService.js

@@ -0,0 +1,35 @@
+"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 multiple leaderboard types including bingo wins, predictions, content creators, XP levels, speed runs, high scores, and streaks.
+     * @param category Leaderboard category to retrieve
+     * @param period Time period for rankings
+     * @param limit Number of top entries to return
+     * @param streakType Streak type (only applicable for bingo-streaks category)
+     * @returns GetLeaderboardResponseDTO 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 (category, period, limit, or streakType)`,
+                500: `Server error while fetching leaderboard`,
+            },
+        });
+    }
+}
+exports.LeaderboardService = LeaderboardService;

package/dist/services/NotificationsService.d.ts

@@ -0,0 +1,143 @@
+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
+     * Register a device token for push notifications. Supports iOS, Android, and web platforms.
+     * @param requestBody
+     * @returns any Device token registered successfully
+     * @throws ApiError
+     */
+    postApiV1NotificationsRegister(requestBody: {
+        /**
+         * Device push notification token
+         */
+        token: string;
+        /**
+         * Device platform
+         */
+        platform: 'ios' | 'android' | 'web';
+        /**
+         * Optional device information
+         */
+        deviceInfo?: {
+            model?: string;
+            osVersion?: string;
+        };
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            message?: string;
+        };
+    }>;
+    /**
+     * Update notification preferences
+     * Update user's notification preferences for different types of notifications
+     * @param requestBody
+     * @returns any Preferences updated successfully
+     * @throws ApiError
+     */
+    putApiV1NotificationsPreferences(requestBody: {
+        gameStartReminders?: boolean;
+        gameResults?: boolean;
+        predictionResults?: boolean;
+        dailyChallenges?: boolean;
+        newsUpdates?: boolean;
+        achievements?: boolean;
+        leaderboardUpdates?: boolean;
+        multiplayerInvites?: boolean;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            message?: string;
+            preferences?: Record<string, any>;
+        };
+    }>;
+    /**
+     * Get notification preferences
+     * Retrieve the user's current notification preferences
+     * @returns any Preferences retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1NotificationsPreferences(): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            preferences?: Record<string, any>;
+        };
+    }>;
+    /**
+     * Unsubscribe from push notifications
+     * Unsubscribe a specific device or all devices from push notifications
+     * @param requestBody
+     * @returns any Unsubscribed successfully
+     * @throws ApiError
+     */
+    postApiV1NotificationsUnsubscribe(requestBody?: {
+        /**
+         * Specific device token to unsubscribe (omit to unsubscribe all devices)
+         */
+        token?: string;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            message?: string;
+        };
+    }>;
+    /**
+     * Get notification history
+     * Retrieve the user's notification history with pagination
+     * @param limit Number of notifications to return
+     * @param offset Pagination offset
+     * @returns any Notification history retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1NotificationsHistory(limit?: number, offset?: number): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            notifications?: Array<Record<string, any>>;
+            unreadCount?: number;
+            pagination?: Record<string, any>;
+        };
+    }>;
+    /**
+     * Mark notification as read
+     * Mark a specific notification as read for the authenticated user
+     * @param id Notification ID
+     * @returns any Notification marked as read
+     * @throws ApiError
+     */
+    putApiV1NotificationsRead(id: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            message?: string;
+        };
+    }>;
+    /**
+     * Get unread notification count
+     * Get the count of unread notifications for the authenticated user
+     * @returns any Unread count retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1NotificationsUnreadCount(): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            unreadCount?: number;
+        };
+    }>;
+    /**
+     * Send test notification
+     * Send a test notification to the authenticated user (for development/testing)
+     * @returns any Test notification sent
+     * @throws ApiError
+     */
+    postApiV1NotificationsTest(): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            sent?: number;
+            failed?: number;
+            message?: string;
+        };
+    }>;
+}

package/dist/services/NotificationsService.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsService = void 0;
+class NotificationsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Register device for push notifications
+     * Register a device token for push notifications. Supports iOS, Android, and web platforms.
+     * @param requestBody
+     * @returns any Device token registered successfully
+     * @throws ApiError
+     */
+    postApiV1NotificationsRegister(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/notifications/register',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid request - missing token or invalid platform`,
+                401: `User not authenticated`,
+                500: `Server error while registering token`,
+            },
+        });
+    }
+    /**
+     * Update notification preferences
+     * Update user's notification preferences for different types of notifications
+     * @param requestBody
+     * @returns any Preferences updated successfully
+     * @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: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get notification preferences
+     * Retrieve the user's current notification preferences
+     * @returns any Preferences retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1NotificationsPreferences() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/notifications/preferences',
+            errors: {
+                401: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Unsubscribe from push notifications
+     * Unsubscribe a specific device or all devices 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: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get notification history
+     * Retrieve the user's notification history with pagination
+     * @param limit Number of notifications to return
+     * @param offset Pagination offset
+     * @returns any Notification history retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1NotificationsHistory(limit = 50, offset) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/notifications/history',
+            query: {
+                'limit': limit,
+                'offset': offset,
+            },
+            errors: {
+                401: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Mark notification as read
+     * Mark a specific notification as read for the authenticated user
+     * @param id Notification 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 is required`,
+                401: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get unread notification count
+     * Get the count of unread notifications for the authenticated user
+     * @returns any Unread count retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1NotificationsUnreadCount() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/notifications/unread-count',
+            errors: {
+                401: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Send test notification
+     * Send a test notification to the authenticated user (for development/testing)
+     * @returns any Test notification sent
+     * @throws ApiError
+     */
+    postApiV1NotificationsTest() {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/notifications/test',
+            errors: {
+                401: `User not authenticated`,
+                500: `Server error`,
+            },
+        });
+    }
+}
+exports.NotificationsService = NotificationsService;

package/dist/services/PredictionsService.d.ts

@@ -0,0 +1,223 @@
+import type { CreatePredictionRequestDTO } from '../models/CreatePredictionRequestDTO';
+import type { PredictionDTO } from '../models/PredictionDTO';
+import type { PredictionWithLineupDTO } from '../models/PredictionWithLineupDTO';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class PredictionsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Create or update prediction
+     * Submit a prediction for a fixture (score, first scorer, MOTM, lineup)
+     * @param requestBody
+     * @returns any Prediction saved successfully
+     * @throws ApiError
+     */
+    postApiV1Predictions(requestBody: CreatePredictionRequestDTO): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            prediction?: PredictionDTO;
+            message?: string;
+        };
+    }>;
+    /**
+     * Get user's predictions
+     * Retrieve authenticated user's predictions with optional filters and pagination
+     * @param status Filter predictions by status
+     * @param fixtureId Filter by specific fixture ID
+     * @param date Filter by date (YYYY-MM-DD)
+     * @param limit Number of predictions to return
+     * @param page Page number for pagination
+     * @returns any Predictions retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Predictions(status?: 'upcoming' | 'resolved' | 'all', fixtureId?: string, date?: string, limit?: number, page?: number): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            predictions?: Array<PredictionWithLineupDTO>;
+            pagination?: {
+                page?: number;
+                limit?: number;
+                total?: number;
+                hasMore?: boolean;
+            };
+        };
+    }>;
+    /**
+     * Get prediction by fixture
+     * Retrieve authenticated user's prediction for a specific fixture
+     * @param fixtureId The fixture ID
+     * @returns any Prediction retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Predictions1(fixtureId: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            prediction?: PredictionWithLineupDTO;
+        };
+    }>;
+    /**
+     * Delete a prediction
+     * Delete user's prediction for a specific fixture (only allowed before fixture locks)
+     * @param fixtureId The fixture ID
+     * @returns any Prediction deleted successfully
+     * @throws ApiError
+     */
+    deleteApiV1Predictions(fixtureId: string): CancelablePromise<{
+        success?: boolean;
+        message?: string;
+    }>;
+    /**
+     * Get user statistics
+     * Retrieve authenticated user's prediction statistics and performance metrics
+     * @returns any User statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PredictionsStats(): CancelablePromise<{
+        success?: boolean;
+        stats?: {
+            /**
+             * Total number of predictions made
+             */
+            totalPredictions?: number;
+            /**
+             * Number of resolved predictions
+             */
+            resolvedPredictions?: number;
+            /**
+             * Number of exact score predictions
+             */
+            correctScores?: number;
+            /**
+             * Number of correct result predictions
+             */
+            correctResults?: number;
+            /**
+             * Number of correct first scorer predictions
+             */
+            correctFirstScorer?: number;
+            /**
+             * Number of correct MOTM predictions
+             */
+            correctMOTM?: number;
+            totalLineupPredictions?: number;
+            perfectLineups?: number;
+            avgLineupAccuracy?: number;
+            /**
+             * Overall prediction accuracy percentage
+             */
+            accuracy?: number;
+            /**
+             * Exact score accuracy percentage
+             */
+            scoreAccuracy?: number;
+            avgPointsPerPrediction?: number;
+            /**
+             * Total points earned
+             */
+            totalPoints?: number;
+            /**
+             * Current correct prediction streak
+             */
+            currentStreak?: number;
+            /**
+             * Longest correct prediction streak
+             */
+            longestStreak?: number;
+            lastCorrectAt?: string | null;
+            /**
+             * User's global ranking
+             */
+            globalRank?: number | null;
+        };
+    }>;
+    /**
+     * Get prediction leaderboard
+     * Retrieve global prediction leaderboard with optional filters (public endpoint, personalized if authenticated)
+     * @param timeframe Leaderboard timeframe
+     * @param limit Number of entries to return
+     * @param metric Leaderboard ranking metric
+     * @returns any Leaderboard retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PredictionsLeaderboard(timeframe?: 'all' | 'month' | 'week', limit?: number, metric?: 'points' | 'accuracy' | 'streak'): CancelablePromise<{
+        success?: boolean;
+        leaderboard?: Array<{
+            rank?: number;
+            userId?: string;
+            username?: string;
+            avatar?: string;
+            score?: number;
+            accuracy?: number;
+            totalPredictions?: number;
+        }>;
+        /**
+         * Current user's ranking (if authenticated)
+         */
+        userRank?: Record<string, any> | null;
+    }>;
+    /**
+     * Get community predictions for fixture
+     * Retrieve aggregated community predictions for a specific fixture (public endpoint, personalized if authenticated)
+     * @param fixtureId The fixture ID
+     * @returns any Community predictions retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PredictionsFixtureCommunity(fixtureId: string): CancelablePromise<{
+        success?: boolean;
+        fixtureId?: string;
+        totalPredictions?: number;
+        resultDistribution?: {
+            home?: number;
+            away?: number;
+            draw?: number;
+        };
+        averageScorePrediction?: {
+            home?: number;
+            away?: number;
+        };
+        topPredictedScorers?: Array<{
+            playerId?: string;
+            playerName?: string;
+            count?: number;
+        }>;
+        /**
+         * Current user's prediction (if authenticated)
+         */
+        userPrediction?: PredictionDTO;
+    }>;
+    /**
+     * Generate share token
+     * Generate a shareable token for user's prediction to share with others
+     * @param fixtureId The fixture ID
+     * @returns any Share token generated successfully
+     * @throws ApiError
+     */
+    postApiV1PredictionsShare(fixtureId: string): CancelablePromise<{
+        success?: boolean;
+        /**
+         * Unique token for sharing prediction
+         */
+        shareToken?: string;
+        /**
+         * Full URL for sharing
+         */
+        shareUrl?: string;
+    }>;
+    /**
+     * Get shared prediction
+     * Retrieve a publicly shared prediction using its share token (public endpoint)
+     * @param shareToken The share token
+     * @returns any Shared prediction retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PredictionsShared(shareToken: string): CancelablePromise<{
+        success?: boolean;
+        prediction?: PredictionDTO;
+        user?: {
+            username?: string;
+            avatar?: string;
+            level?: number;
+        };
+    }>;
+}