@footballbingo/client 1.0.0 → 2.1.0

package/dist/services/PredictionsService.d.ts

@@ -1,6 +1,11 @@
-import type { CreatePredictionRequestDTO } from '../models/CreatePredictionRequestDTO';
-import type { PredictionDTO } from '../models/PredictionDTO';
-import type { PredictionWithLineupDTO } from '../models/PredictionWithLineupDTO';
+import type { CommunityPredictionsResponse } from '../models/CommunityPredictionsResponse';
+import type { CreatePredictionResponse } from '../models/CreatePredictionResponse';
+import type { DeletePredictionResponse } from '../models/DeletePredictionResponse';
+import type { GetLeaderboardResponse } from '../models/GetLeaderboardResponse';
+import type { GetPredictionByFixtureResponse } from '../models/GetPredictionByFixtureResponse';
+import type { GetPredictionsResponse } from '../models/GetPredictionsResponse';
+import type { PredictionStatsResponse } from '../models/PredictionStatsResponse';
+import type { SharedPredictionResponse } from '../models/SharedPredictionResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class PredictionsService {
@@ -8,216 +13,122 @@ export declare class PredictionsService {
     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
+     * @returns any Prediction saved
      * @throws ApiError
      */
-    postApiV1Predictions(requestBody: CreatePredictionRequestDTO): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            prediction?: PredictionDTO;
-            message?: string;
-        };
+    postApiV1Predictions(requestBody?: {
+        fixtureId: string;
+        homeScore?: number | null;
+        awayScore?: number | null;
+        result?: string | null;
+        firstScorerId?: number | null;
+        manOfTheMatchId?: number | null;
+        totalGoals?: number | null;
+        bothTeamsToScore?: boolean | null;
+        confidence: number;
+        notes?: string | null;
+        predictedLineup?: {
+            homePlayers: Array<{
+                photo?: string;
+                playerId: number;
+                position: string;
+                playerName: string;
+            }>;
+            awayPlayers: Array<{
+                photo?: string;
+                playerId: number;
+                position: string;
+                playerName: string;
+            }>;
+            homeFormation: string;
+            awayFormation: string;
+        } | null;
+    }): CancelablePromise<{
+        success: boolean;
+        data: CreatePredictionResponse;
+        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
+     * @param status
+     * @param fixtureId
+     * @param date
+     * @param page
+     * @param limit
+     * @returns any User predictions
      * @throws ApiError
      */
-    deleteApiV1Predictions(fixtureId: string): CancelablePromise<{
-        success?: boolean;
+    getApiV1Predictions(status?: 'upcoming' | 'resolved' | 'all', fixtureId?: string, date?: string, page?: number, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: GetPredictionsResponse;
         message?: string;
     }>;
     /**
-     * Get user statistics
-     * Retrieve authenticated user's prediction statistics and performance metrics
-     * @returns any User statistics retrieved successfully
+     * Get user prediction statistics
+     * @returns any User prediction stats
      * @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;
-        };
+        success: boolean;
+        data: PredictionStatsResponse;
+        message?: string;
     }>;
     /**
      * 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
+     * @param timeframe
+     * @param limit
+     * @param metric
+     * @returns any Prediction leaderboard
      * @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;
+        success: boolean;
+        data: GetLeaderboardResponse;
+        message?: string;
     }>;
     /**
      * 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
+     * @param fixtureId
+     * @returns any Community predictions aggregation
      * @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;
+        success: boolean;
+        data: CommunityPredictionsResponse;
+        message?: string;
     }>;
     /**
-     * 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
+     * Get shared prediction
+     * @param shareToken
+     * @returns any Shared prediction details
      * @throws ApiError
      */
-    postApiV1PredictionsShare(fixtureId: string): CancelablePromise<{
-        success?: boolean;
-        /**
-         * Unique token for sharing prediction
-         */
-        shareToken?: string;
-        /**
-         * Full URL for sharing
-         */
-        shareUrl?: string;
+    getApiV1PredictionsShared(shareToken: string): CancelablePromise<{
+        success: boolean;
+        data: SharedPredictionResponse;
+        message?: 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
+     * Get prediction by fixture
+     * @param fixtureId
+     * @returns any User prediction for fixture
      * @throws ApiError
      */
-    getApiV1PredictionsShared(shareToken: string): CancelablePromise<{
-        success?: boolean;
-        prediction?: PredictionDTO;
-        user?: {
-            username?: string;
-            avatar?: string;
-            level?: number;
-        };
+    getApiV1Predictions1(fixtureId: string): CancelablePromise<{
+        success: boolean;
+        data: GetPredictionByFixtureResponse;
+        message?: string;
+    }>;
+    /**
+     * Delete a prediction
+     * @param fixtureId
+     * @returns any Prediction deleted
+     * @throws ApiError
+     */
+    deleteApiV1Predictions(fixtureId: string): CancelablePromise<{
+        success: boolean;
+        data: DeletePredictionResponse;
+        message?: string;
     }>;
 }

package/dist/services/PredictionsService.js

@@ -7,9 +7,8 @@ class PredictionsService {
     }
     /**
      * Create or update prediction
-     * Submit a prediction for a fixture (score, first scorer, MOTM, lineup)
      * @param requestBody
-     * @returns any Prediction saved successfully
+     * @returns any Prediction saved
      * @throws ApiError
      */
     postApiV1Predictions(requestBody) {
@@ -19,25 +18,23 @@ class PredictionsService {
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Missing or invalid parameters`,
-                401: `Authentication required`,
-                403: `Predictions locked (90 minutes before kickoff) or cannot update resolved prediction`,
-                500: `Server error`,
+                400: `Validation error`,
+                401: `Unauthorized`,
+                403: `Predictions locked or cannot update resolved`,
             },
         });
     }
     /**
      * 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
+     * @param status
+     * @param fixtureId
+     * @param date
+     * @param page
+     * @param limit
+     * @returns any User predictions
      * @throws ApiError
      */
-    getApiV1Predictions(status = 'all', fixtureId, date, limit = 50, page = 1) {
+    getApiV1Predictions(status = 'all', fixtureId, date, page = 1, limit = 20) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/predictions',
@@ -45,63 +42,17 @@ class PredictionsService {
                 'status': status,
                 'fixtureId': fixtureId,
                 'date': date,
-                'limit': limit,
                 'page': page,
+                'limit': limit,
             },
             errors: {
-                401: `Authentication required`,
-                500: `Server error`,
-            },
-        });
-    }
-    /**
-     * 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) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/{fixtureId}',
-            path: {
-                'fixtureId': fixtureId,
-            },
-            errors: {
-                400: `Fixture ID is required`,
-                401: `Authentication required`,
-                500: `Server error`,
-            },
-        });
-    }
-    /**
-     * 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) {
-        return this.httpRequest.request({
-            method: 'DELETE',
-            url: '/api/v1/predictions/{fixtureId}',
-            path: {
-                'fixtureId': fixtureId,
-            },
-            errors: {
-                400: `Fixture ID is required`,
-                401: `Authentication required`,
-                403: `Cannot delete resolved prediction or locked fixture`,
-                404: `Prediction not found`,
-                500: `Server error`,
+                401: `Unauthorized`,
             },
         });
     }
     /**
-     * Get user statistics
-     * Retrieve authenticated user's prediction statistics and performance metrics
-     * @returns any User statistics retrieved successfully
+     * Get user prediction statistics
+     * @returns any User prediction stats
      * @throws ApiError
      */
     getApiV1PredictionsStats() {
@@ -109,18 +60,16 @@ class PredictionsService {
             method: 'GET',
             url: '/api/v1/predictions/stats',
             errors: {
-                401: `Authentication required`,
-                500: `Server error`,
+                401: `Unauthorized`,
             },
         });
     }
     /**
      * 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
+     * @param timeframe
+     * @param limit
+     * @param metric
+     * @returns any Prediction leaderboard
      * @throws ApiError
      */
     getApiV1PredictionsLeaderboard(timeframe = 'all', limit = 50, metric = 'points') {
@@ -132,16 +81,12 @@ class PredictionsService {
                 'limit': limit,
                 'metric': metric,
             },
-            errors: {
-                500: `Server error`,
-            },
         });
     }
     /**
      * 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
+     * @param fixtureId
+     * @returns any Community predictions aggregation
      * @throws ApiError
      */
     getApiV1PredictionsFixtureCommunity(fixtureId) {
@@ -152,51 +97,66 @@ class PredictionsService {
                 'fixtureId': fixtureId,
             },
             errors: {
-                400: `Fixture ID is required`,
-                500: `Server error`,
+                400: `Fixture ID required`,
             },
         });
     }
     /**
-     * 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
+     * Get shared prediction
+     * @param shareToken
+     * @returns any Shared prediction details
      * @throws ApiError
      */
-    postApiV1PredictionsShare(fixtureId) {
+    getApiV1PredictionsShared(shareToken) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/predictions/{fixtureId}/share',
+            method: 'GET',
+            url: '/api/v1/predictions/shared/{shareToken}',
             path: {
-                'fixtureId': fixtureId,
+                'shareToken': shareToken,
             },
             errors: {
-                400: `Fixture ID is required`,
-                401: `Authentication required`,
-                404: `Prediction not found`,
-                500: `Server error`,
+                400: `Share token required`,
+                404: `Prediction not found or not public`,
             },
         });
     }
     /**
-     * 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
+     * Get prediction by fixture
+     * @param fixtureId
+     * @returns any User prediction for fixture
      * @throws ApiError
      */
-    getApiV1PredictionsShared(shareToken) {
+    getApiV1Predictions1(fixtureId) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/predictions/shared/{shareToken}',
+            url: '/api/v1/predictions/{fixtureId}',
             path: {
-                'shareToken': shareToken,
+                'fixtureId': fixtureId,
             },
             errors: {
-                400: `Share token is required`,
-                404: `Prediction not found or not public`,
-                500: `Server error`,
+                400: `Fixture ID required`,
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Delete a prediction
+     * @param fixtureId
+     * @returns any Prediction deleted
+     * @throws ApiError
+     */
+    deleteApiV1Predictions(fixtureId) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/predictions/{fixtureId}',
+            path: {
+                'fixtureId': fixtureId,
+            },
+            errors: {
+                400: `Fixture ID required`,
+                401: `Unauthorized`,
+                403: `Cannot delete locked or resolved prediction`,
+                404: `Prediction not found`,
             },
         });
     }