@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/ChallengesService.d.ts

@@ -1,6 +1,14 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
-import type { Challenge } from '../models/Challenge';
-import type { LeaderboardEntry } from '../models/LeaderboardEntry';
+import type { ChallengeDetailResponse } from '../models/ChallengeDetailResponse';
+import type { ChallengeHistoryResponse } from '../models/ChallengeHistoryResponse';
+import type { ChallengeLeaderboardResponse } from '../models/ChallengeLeaderboardResponse';
+import type { ChallengeStreakResponse } from '../models/ChallengeStreakResponse';
+import type { ClaimAllChallengesResponse } from '../models/ClaimAllChallengesResponse';
+import type { ClaimRewardResponse } from '../models/ClaimRewardResponse';
+import type { GenerateDailyResponse } from '../models/GenerateDailyResponse';
+import type { GenerateEventResponse } from '../models/GenerateEventResponse';
+import type { GenerateWeeklyResponse } from '../models/GenerateWeeklyResponse';
+import type { GetActiveChallengesResponse } from '../models/GetActiveChallengesResponse';
+import type { UpdateChallengeProgressResponse } from '../models/UpdateChallengeProgressResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ChallengesService {
@@ -8,208 +16,156 @@ export declare class ChallengesService {
     constructor(httpRequest: BaseHttpRequest);
     /**
      * Get active challenges for current user
-     * Retrieves all active challenges for the authenticated user with optional filters
-     * @param type Filter by challenge type
-     * @param difficulty Filter by difficulty level
-     * @param status Filter by completion status
-     * @returns any List of active challenges
+     * @param type
+     * @param difficulty
+     * @param status
+     * @returns any List of active challenges grouped by type
      * @throws ApiError
      */
-    getApiV1Challenges(type?: 'daily' | 'weekly' | 'seasonal' | 'special', difficulty?: 'easy' | 'medium' | 'hard' | 'expert', status?: 'active' | 'completed' | 'claimed'): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            challenges?: Array<Challenge>;
-        };
+    getApiV1Challenges(type?: 'daily' | 'weekly' | 'seasonal' | 'event' | 'all', difficulty?: 'easy' | 'medium' | 'hard' | 'all', status?: 'available' | 'in_progress' | 'completed' | 'all'): CancelablePromise<{
+        success: boolean;
+        data: GetActiveChallengesResponse;
+        message?: string;
     }>;
     /**
-     * Get specific challenge details
-     * Retrieves detailed information about a specific challenge
-     * @param challengeId Challenge ID
-     * @returns any Challenge details
+     * Get challenge completion history
+     * @param limit
+     * @param offset
+     * @param type
+     * @param startDate
+     * @param endDate
+     * @returns any Challenge history retrieved
      * @throws ApiError
      */
-    getApiV1Challenges1(challengeId: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Challenge;
-    })>;
+    getApiV1ChallengesHistory(limit?: number, offset?: number | null, type?: 'daily' | 'weekly' | 'seasonal' | 'all', startDate?: string, endDate?: string): CancelablePromise<{
+        success: boolean;
+        data: ChallengeHistoryResponse;
+        message?: string;
+    }>;
     /**
-     * Update challenge progress (Internal)
-     * Internal endpoint to update challenge progress. Should only be called by backend services, not frontend.
-     * @param requestBody
-     * @returns any Progress updated successfully
+     * Get challenges leaderboard
+     * @param period
+     * @param type
+     * @param limit
+     * @returns any Challenge leaderboard
      * @throws ApiError
      */
-    postApiV1ChallengesProgress(requestBody: {
-        /**
-         * User ID to update progress for
-         */
-        userId: string;
-        /**
-         * Type of event that occurred
-         */
-        eventType: string;
-        /**
-         * Event data payload
-         */
-        eventData: Record<string, any>;
-    }): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            updatedChallenges?: Array<string>;
-        };
+    getApiV1ChallengesLeaderboard(period?: 'day' | 'week' | 'month' | 'all-time', type?: 'daily' | 'weekly' | 'seasonal' | 'all', limit?: number): CancelablePromise<{
+        success: boolean;
+        data: ChallengeLeaderboardResponse;
+        message?: string;
     }>;
     /**
-     * Claim reward for completed challenge
-     * Claims the reward for a specific completed challenge
-     * @param challengeId Challenge ID to claim reward for
-     * @returns any Reward claimed successfully
+     * Get user's challenge streak
+     * @returns any Streak information
      * @throws ApiError
      */
-    postApiV1ChallengesClaim(challengeId: string): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            reward?: {
-                coins?: number;
-                xp?: number;
-                items?: Array<string>;
-            };
-        };
+    getApiV1ChallengesStreak(): CancelablePromise<{
+        success: boolean;
+        data: ChallengeStreakResponse;
+        message?: string;
     }>;
     /**
      * Claim all completed challenges
-     * Claims rewards for all completed but unclaimed challenges
-     * @returns any All rewards claimed successfully
+     * @returns any All rewards claimed
      * @throws ApiError
      */
     postApiV1ChallengesClaimAll(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of challenges claimed
-             */
-            claimed?: number;
-            totalRewards?: {
-                coins?: number;
-                xp?: number;
-            };
-        };
+        success: boolean;
+        data: ClaimAllChallengesResponse;
+        message?: string;
     }>;
     /**
-     * Get challenge completion history
-     * Retrieves user's challenge completion history with pagination and filters
-     * @param limit Number of results per page
-     * @param offset Number of results to skip
-     * @param type Filter by challenge type
-     * @param startDate Filter by start date
-     * @param endDate Filter by end date
-     * @returns any Challenge history retrieved successfully
+     * Update challenge progress (Internal)
+     * @param requestBody
+     * @returns any Progress updated
      * @throws ApiError
      */
-    getApiV1ChallengesHistory(limit?: number, offset?: number, type?: string, startDate?: string, endDate?: string): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            history?: Array<Challenge>;
-            total?: number;
-            limit?: number;
-            offset?: number;
-        };
+    postApiV1ChallengesProgress(requestBody?: {
+        userId: string;
+        eventType: 'game_complete' | 'game_win' | 'prediction_made' | 'prediction_correct';
+        eventData?: Record<string, (string | number | boolean)>;
+    }): CancelablePromise<{
+        success: boolean;
+        data: UpdateChallengeProgressResponse;
+        message?: string;
     }>;
     /**
-     * Get challenges leaderboard
-     * Public endpoint that returns leaderboard with all users' challenge completion data
-     * @param period Leaderboard time period
-     * @param type Filter by challenge type
-     * @param limit Number of top users to return
-     * @returns any Leaderboard retrieved successfully
+     * Generate daily challenges (Admin)
+     * @param requestBody
+     * @returns any Daily challenges generated
      * @throws ApiError
      */
-    getApiV1ChallengesLeaderboard(period?: 'day' | 'week' | 'month' | 'all', type?: 'all' | 'daily' | 'weekly' | 'seasonal', limit?: number): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            leaderboard?: Array<LeaderboardEntry>;
-            currentUser?: {
-                rank?: number;
-                score?: number;
-            };
+    postApiV1ChallengesGenerateDaily(requestBody?: {
+        date: (string | null | string);
+        difficultyDistribution?: {
+            easy: number;
+            medium: number;
+            hard: number;
         };
+    }): CancelablePromise<{
+        success: boolean;
+        data: GenerateDailyResponse;
+        message?: string;
     }>;
     /**
-     * Get user's challenge streak
-     * Retrieves current challenge completion streak information for the user
-     * @returns any Streak information retrieved successfully
+     * Generate weekly challenges (Admin)
+     * @param requestBody
+     * @returns any Weekly challenges generated
      * @throws ApiError
      */
-    getApiV1ChallengesStreak(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Current consecutive days
-             */
-            currentStreak?: number;
-            /**
-             * All-time longest streak
-             */
-            longestStreak?: number;
-            lastCompletionDate?: string;
+    postApiV1ChallengesGenerateWeekly(requestBody?: {
+        weekStart: (string | null | string);
+        difficultyDistribution?: {
+            easy: number;
+            medium: number;
+            hard: number;
         };
+    }): CancelablePromise<{
+        success: boolean;
+        data: GenerateWeeklyResponse;
+        message?: string;
     }>;
     /**
-     * Generate daily challenges (Admin)
-     * Admin endpoint to generate daily challenges for all users
+     * Generate event challenges (Admin)
      * @param requestBody
-     * @returns any Daily challenges generated successfully
+     * @returns any Event challenges generated
      * @throws ApiError
      */
-    postApiV1ChallengesGenerateDaily(requestBody: {
-        /**
-         * Date to generate challenges for
-         */
-        date: string;
-        /**
-         * Pool of challenge IDs to select from
-         */
-        challengePool?: Array<string>;
+    postApiV1ChallengesGenerateEvent(requestBody?: {
+        eventType: 'afcon' | 'transfer_window';
+        startsAt?: (string | null | string);
+        endsAt?: (string | null | string);
         difficultyDistribution?: {
-            easy?: number;
-            medium?: number;
-            hard?: number;
+            easy: number;
+            medium: number;
+            hard: number;
         };
     }): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of challenges generated
-             */
-            generated?: number;
-        };
+        success: boolean;
+        data: GenerateEventResponse;
+        message?: string;
     }>;
     /**
-     * Generate weekly challenges (Admin)
-     * Admin endpoint to generate weekly challenges for all users
-     * @param requestBody
-     * @returns any Weekly challenges generated successfully
+     * Get specific challenge details
+     * @param challengeId
+     * @returns any Challenge details
      * @throws ApiError
      */
-    postApiV1ChallengesGenerateWeekly(requestBody: {
-        /**
-         * Week start date to generate challenges for
-         */
-        weekStart: string;
-        /**
-         * Pool of challenge IDs to select from
-         */
-        challengePool?: Array<string>;
-        difficultyDistribution?: {
-            easy?: number;
-            medium?: number;
-            hard?: number;
-        };
-    }): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of challenges generated
-             */
-            generated?: number;
-        };
+    getApiV1Challenges1(challengeId: string): CancelablePromise<{
+        success: boolean;
+        data: ChallengeDetailResponse;
+        message?: string;
+    }>;
+    /**
+     * Claim reward for completed challenge
+     * @param challengeId
+     * @returns any Reward claimed successfully
+     * @throws ApiError
+     */
+    postApiV1ChallengesClaim(challengeId: string): CancelablePromise<{
+        success: boolean;
+        data: ClaimRewardResponse;
+        message?: string;
     }>;
 }

package/dist/services/ChallengesService.js

@@ -7,11 +7,10 @@ class ChallengesService {
     }
     /**
      * Get active challenges for current user
-     * Retrieves all active challenges for the authenticated user with optional filters
-     * @param type Filter by challenge type
-     * @param difficulty Filter by difficulty level
-     * @param status Filter by completion status
-     * @returns any List of active challenges
+     * @param type
+     * @param difficulty
+     * @param status
+     * @returns any List of active challenges grouped by type
      * @throws ApiError
      */
     getApiV1Challenges(type, difficulty, status) {
@@ -24,76 +23,78 @@ class ChallengesService {
                 'status': status,
             },
             errors: {
-                401: `Unauthorized - authentication required`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get specific challenge details
-     * Retrieves detailed information about a specific challenge
-     * @param challengeId Challenge ID
-     * @returns any Challenge details
+     * Get challenge completion history
+     * @param limit
+     * @param offset
+     * @param type
+     * @param startDate
+     * @param endDate
+     * @returns any Challenge history retrieved
      * @throws ApiError
      */
-    getApiV1Challenges1(challengeId) {
+    getApiV1ChallengesHistory(limit, offset, type, startDate, endDate) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/challenges/{challengeId}',
-            path: {
-                'challengeId': challengeId,
+            url: '/api/v1/challenges/history',
+            query: {
+                'limit': limit,
+                'offset': offset,
+                'type': type,
+                'startDate': startDate,
+                'endDate': endDate,
             },
             errors: {
-                400: `Bad request - missing challenge ID`,
-                404: `Challenge not found`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Update challenge progress (Internal)
-     * Internal endpoint to update challenge progress. Should only be called by backend services, not frontend.
-     * @param requestBody
-     * @returns any Progress updated successfully
+     * Get challenges leaderboard
+     * @param period
+     * @param type
+     * @param limit
+     * @returns any Challenge leaderboard
      * @throws ApiError
      */
-    postApiV1ChallengesProgress(requestBody) {
+    getApiV1ChallengesLeaderboard(period, type, limit) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/challenges/progress',
-            body: requestBody,
-            mediaType: 'application/json',
+            method: 'GET',
+            url: '/api/v1/challenges/leaderboard',
+            query: {
+                'period': period,
+                'type': type,
+                'limit': limit,
+            },
             errors: {
-                400: `Bad request - missing required fields`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Claim reward for completed challenge
-     * Claims the reward for a specific completed challenge
-     * @param challengeId Challenge ID to claim reward for
-     * @returns any Reward claimed successfully
+     * Get user's challenge streak
+     * @returns any Streak information
      * @throws ApiError
      */
-    postApiV1ChallengesClaim(challengeId) {
+    getApiV1ChallengesStreak() {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/challenges/{challengeId}/claim',
-            path: {
-                'challengeId': challengeId,
-            },
+            method: 'GET',
+            url: '/api/v1/challenges/streak',
             errors: {
-                400: `Bad request - challenge not completed or already claimed`,
-                401: `Unauthorized - authentication required`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
      * Claim all completed challenges
-     * Claims rewards for all completed but unclaimed challenges
-     * @returns any All rewards claimed successfully
+     * @returns any All rewards claimed
      * @throws ApiError
      */
     postApiV1ChallengesClaimAll() {
@@ -101,112 +102,123 @@ class ChallengesService {
             method: 'POST',
             url: '/api/v1/challenges/claim-all',
             errors: {
-                401: `Unauthorized - authentication required`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get challenge completion history
-     * Retrieves user's challenge completion history with pagination and filters
-     * @param limit Number of results per page
-     * @param offset Number of results to skip
-     * @param type Filter by challenge type
-     * @param startDate Filter by start date
-     * @param endDate Filter by end date
-     * @returns any Challenge history retrieved successfully
+     * Update challenge progress (Internal)
+     * @param requestBody
+     * @returns any Progress updated
      * @throws ApiError
      */
-    getApiV1ChallengesHistory(limit = 20, offset, type, startDate, endDate) {
+    postApiV1ChallengesProgress(requestBody) {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/challenges/history',
-            query: {
-                'limit': limit,
-                'offset': offset,
-                'type': type,
-                'startDate': startDate,
-                'endDate': endDate,
-            },
+            method: 'POST',
+            url: '/api/v1/challenges/progress',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                401: `Unauthorized - authentication required`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get challenges leaderboard
-     * Public endpoint that returns leaderboard with all users' challenge completion data
-     * @param period Leaderboard time period
-     * @param type Filter by challenge type
-     * @param limit Number of top users to return
-     * @returns any Leaderboard retrieved successfully
+     * Generate daily challenges (Admin)
+     * @param requestBody
+     * @returns any Daily challenges generated
      * @throws ApiError
      */
-    getApiV1ChallengesLeaderboard(period = 'week', type = 'all', limit = 100) {
+    postApiV1ChallengesGenerateDaily(requestBody) {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/challenges/leaderboard',
-            query: {
-                'period': period,
-                'type': type,
-                'limit': limit,
-            },
+            method: 'POST',
+            url: '/api/v1/challenges/generate/daily',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get user's challenge streak
-     * Retrieves current challenge completion streak information for the user
-     * @returns any Streak information retrieved successfully
+     * Generate weekly challenges (Admin)
+     * @param requestBody
+     * @returns any Weekly challenges generated
      * @throws ApiError
      */
-    getApiV1ChallengesStreak() {
+    postApiV1ChallengesGenerateWeekly(requestBody) {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/challenges/streak',
+            method: 'POST',
+            url: '/api/v1/challenges/generate/weekly',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                401: `Unauthorized - authentication required`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Generate daily challenges (Admin)
-     * Admin endpoint to generate daily challenges for all users
+     * Generate event challenges (Admin)
      * @param requestBody
-     * @returns any Daily challenges generated successfully
+     * @returns any Event challenges generated
      * @throws ApiError
      */
-    postApiV1ChallengesGenerateDaily(requestBody) {
+    postApiV1ChallengesGenerateEvent(requestBody) {
         return this.httpRequest.request({
             method: 'POST',
-            url: '/api/v1/challenges/generate/daily',
+            url: '/api/v1/challenges/generate/event',
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Bad request - missing date`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Generate weekly challenges (Admin)
-     * Admin endpoint to generate weekly challenges for all users
-     * @param requestBody
-     * @returns any Weekly challenges generated successfully
+     * Get specific challenge details
+     * @param challengeId
+     * @returns any Challenge details
      * @throws ApiError
      */
-    postApiV1ChallengesGenerateWeekly(requestBody) {
+    getApiV1Challenges1(challengeId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/challenges/{challengeId}',
+            path: {
+                'challengeId': challengeId,
+            },
+            errors: {
+                400: `Bad request`,
+                404: `Challenge not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Claim reward for completed challenge
+     * @param challengeId
+     * @returns any Reward claimed successfully
+     * @throws ApiError
+     */
+    postApiV1ChallengesClaim(challengeId) {
         return this.httpRequest.request({
             method: 'POST',
-            url: '/api/v1/challenges/generate/weekly',
-            body: requestBody,
-            mediaType: 'application/json',
+            url: '/api/v1/challenges/{challengeId}/claim',
+            path: {
+                'challengeId': challengeId,
+            },
             errors: {
-                400: `Bad request - missing weekStart`,
+                400: `Challenge not completed or already claimed`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });