@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/PreferencesStarredItemsService.d.ts

@@ -0,0 +1,168 @@
+import type { AddStarredItemResponse } from '../models/AddStarredItemResponse';
+import type { BulkImportStarredResponse } from '../models/BulkImportStarredResponse';
+import type { CheckStarredResponse } from '../models/CheckStarredResponse';
+import type { RemoveStarredItemResponse } from '../models/RemoveStarredItemResponse';
+import type { StarredCountsResponse } from '../models/StarredCountsResponse';
+import type { StarredIdsResponse } from '../models/StarredIdsResponse';
+import type { StarredItemsListResponse } from '../models/StarredItemsListResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class PreferencesStarredItemsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get user's starred items
+     * Retrieve all starred leagues, teams, and countries for the authenticated user
+     * @param type
+     * @returns any Starred items retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarred(type?: 'league' | 'team' | 'country' | 'fixture' | 'player'): CancelablePromise<{
+        success: boolean;
+        data: StarredItemsListResponse;
+        message?: string;
+    }>;
+    /**
+     * Star an item
+     * Add a league, team, or country to the user's starred items
+     * @param requestBody
+     * @returns any Item starred successfully
+     * @throws ApiError
+     */
+    postApiV1PreferencesStarred(requestBody?: {
+        itemType: 'league' | 'team' | 'country' | 'fixture' | 'player';
+        itemId: number;
+        metadata?: {
+            name: string;
+            logo?: string | null;
+            flag?: string | null;
+            code?: string | null;
+            countryCode?: string | null;
+            countryName?: string | null;
+            photo?: string | null;
+            position?: string | null;
+            teamId?: number | null;
+            teamName?: string | null;
+            homeTeam?: {
+                id: number;
+                name: string;
+                logo?: string | null;
+            } | null;
+            awayTeam?: {
+                id: number;
+                name: string;
+                logo?: string | null;
+            } | null;
+            date?: string | null;
+            leagueId?: number | null;
+            leagueName?: string | null;
+        };
+    }): CancelablePromise<{
+        success: boolean;
+        data: AddStarredItemResponse;
+        message?: string;
+    }>;
+    /**
+     * Get starred items counts
+     * Get count of starred items by type
+     * @returns any Counts retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarredCounts(): CancelablePromise<{
+        success: boolean;
+        data: StarredCountsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get starred item IDs by type
+     * Returns just the IDs of starred items for a given type. Use this for efficiently checking starred status in lists.
+     * @param type
+     * @returns any Array of starred item IDs
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarredIds(type: 'league' | 'team' | 'country' | 'fixture' | 'player'): CancelablePromise<{
+        success: boolean;
+        data: StarredIdsResponse;
+        message?: string;
+    }>;
+    /**
+     * Check if an item is starred
+     * Check if a specific item is starred by the user
+     * @param itemType
+     * @param itemId
+     * @returns any Check completed
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarredCheck(itemType: 'league' | 'team' | 'country' | 'fixture' | 'player', itemId: number): CancelablePromise<{
+        success: boolean;
+        data: CheckStarredResponse;
+        message?: string;
+    }>;
+    /**
+     * Bulk import starred items
+     * Import multiple starred items at once (useful for migrating from localStorage)
+     * @param requestBody
+     * @returns any Bulk import completed
+     * @throws ApiError
+     */
+    postApiV1PreferencesStarredBulk(requestBody?: {
+        items: Array<{
+            itemType: 'league' | 'team' | 'country' | 'fixture' | 'player';
+            itemId: number;
+            metadata?: {
+                name: string;
+                logo?: string | null;
+                flag?: string | null;
+                code?: string | null;
+                countryCode?: string | null;
+                countryName?: string | null;
+                photo?: string | null;
+                position?: string | null;
+                teamId?: number | null;
+                teamName?: string | null;
+                homeTeam?: {
+                    id: number;
+                    name: string;
+                    logo?: string | null;
+                } | null;
+                awayTeam?: {
+                    id: number;
+                    name: string;
+                    logo?: string | null;
+                } | null;
+                date?: string | null;
+                leagueId?: number | null;
+                leagueName?: string | null;
+            };
+        }>;
+    }): CancelablePromise<{
+        success: boolean;
+        data: BulkImportStarredResponse;
+        message?: string;
+    }>;
+    /**
+     * Remove a starred item
+     * Remove a league, team, or country from the user's starred items
+     * @param itemType
+     * @param itemId
+     * @returns any Item unstarred successfully
+     * @throws ApiError
+     */
+    deleteApiV1PreferencesStarred(itemType: 'league' | 'team' | 'country' | 'fixture' | 'player', itemId: number): CancelablePromise<{
+        success: boolean;
+        data: RemoveStarredItemResponse;
+        message?: string;
+    }>;
+    /**
+     * Remove a starred item by ID
+     * Remove a starred item using its database ID
+     * @param id
+     * @returns any Item unstarred successfully
+     * @throws ApiError
+     */
+    deleteApiV1PreferencesStarred1(id: string): CancelablePromise<{
+        success: boolean;
+        data: RemoveStarredItemResponse;
+        message?: string;
+    }>;
+}

package/dist/services/PreferencesStarredItemsService.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreferencesStarredItemsService = void 0;
+class PreferencesStarredItemsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get user's starred items
+     * Retrieve all starred leagues, teams, and countries for the authenticated user
+     * @param type
+     * @returns any Starred items retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarred(type) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/preferences/starred',
+            query: {
+                'type': type,
+            },
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Star an item
+     * Add a league, team, or country to the user's starred items
+     * @param requestBody
+     * @returns any Item starred successfully
+     * @throws ApiError
+     */
+    postApiV1PreferencesStarred(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/preferences/starred',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error`,
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get starred items counts
+     * Get count of starred items by type
+     * @returns any Counts retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarredCounts() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/preferences/starred/counts',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get starred item IDs by type
+     * Returns just the IDs of starred items for a given type. Use this for efficiently checking starred status in lists.
+     * @param type
+     * @returns any Array of starred item IDs
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarredIds(type) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/preferences/starred/ids/{type}',
+            path: {
+                'type': type,
+            },
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Check if an item is starred
+     * Check if a specific item is starred by the user
+     * @param itemType
+     * @param itemId
+     * @returns any Check completed
+     * @throws ApiError
+     */
+    getApiV1PreferencesStarredCheck(itemType, itemId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/preferences/starred/check',
+            query: {
+                'itemType': itemType,
+                'itemId': itemId,
+            },
+            errors: {
+                400: `Missing required parameters`,
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Bulk import starred items
+     * Import multiple starred items at once (useful for migrating from localStorage)
+     * @param requestBody
+     * @returns any Bulk import completed
+     * @throws ApiError
+     */
+    postApiV1PreferencesStarredBulk(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/preferences/starred/bulk',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Remove a starred item
+     * Remove a league, team, or country from the user's starred items
+     * @param itemType
+     * @param itemId
+     * @returns any Item unstarred successfully
+     * @throws ApiError
+     */
+    deleteApiV1PreferencesStarred(itemType, itemId) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/preferences/starred/{itemType}/{itemId}',
+            path: {
+                'itemType': itemType,
+                'itemId': itemId,
+            },
+            errors: {
+                401: `Authentication required`,
+                404: `Starred item not found`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Remove a starred item by ID
+     * Remove a starred item using its database ID
+     * @param id
+     * @returns any Item unstarred successfully
+     * @throws ApiError
+     */
+    deleteApiV1PreferencesStarred1(id) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/preferences/starred/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Authentication required`,
+                404: `Starred item not found`,
+                500: `Server error`,
+            },
+        });
+    }
+}
+exports.PreferencesStarredItemsService = PreferencesStarredItemsService;

package/dist/services/ProgressionService.d.ts

@@ -1,4 +1,8 @@
-import type { LeaderboardEntry } from '../models/LeaderboardEntry';
+import type { CanAccessFeatureResponse } from '../models/CanAccessFeatureResponse';
+import type { GetMyProgressionResponse } from '../models/GetMyProgressionResponse';
+import type { GetRanksResponse } from '../models/GetRanksResponse';
+import type { PrestigeResponse } from '../models/PrestigeResponse';
+import type { ProgressionLeaderboardResponse } from '../models/ProgressionLeaderboardResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ProgressionService {
@@ -6,158 +10,59 @@ export declare class ProgressionService {
     constructor(httpRequest: BaseHttpRequest);
     /**
      * Get my progression
-     * Retrieves progression data for the authenticated user including level, XP, rank, and unlocked features
      * @returns any Progression data retrieved successfully
      * @throws ApiError
      */
     getApiV1ProgressionMe(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            userId?: string;
-            level?: number;
-            currentXp?: number;
-            xpToNextLevel?: number;
-            totalXp?: number;
-            rank?: {
-                name?: string;
-                tier?: number;
-                displayName?: string;
-            };
-            prestigeLevel?: number;
-            xpBoostPercentage?: number;
-            coinBoostPercentage?: number;
-            unlockedFeatures?: Array<string>;
-            unlockedEventPools?: Array<string>;
-            progressToNextLevel?: number;
-        };
-    }>;
-    /**
-     * Award XP to user (Internal)
-     * Internal endpoint to award XP to a user. Should only be called by internal services or admin tools, not frontend.
-     * @param requestBody
-     * @returns any XP awarded successfully
-     * @throws ApiError
-     */
-    postApiV1ProgressionAwardXp(requestBody: {
-        /**
-         * User ID to award XP to
-         */
-        userId: string;
-        /**
-         * Amount of XP to award
-         */
-        amount: number;
-        /**
-         * Source of XP award (e.g., 'game_complete', 'achievement_unlock')
-         */
-        source: string;
-        /**
-         * Source entity ID
-         */
-        sourceId?: string;
-        /**
-         * Additional metadata for the XP award
-         */
-        metadata?: Record<string, any>;
-    }): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            newLevel?: number;
-            leveledUp?: boolean;
-            totalXp?: number;
-        };
-    }>;
-    /**
-     * Get XP history
-     * Retrieves XP gain history for the authenticated user with pagination and filters
-     * @param limit Number of results per page
-     * @param offset Number of results to skip
-     * @param source Filter by XP source
-     * @param startDate Filter by start date
-     * @param endDate Filter by end date
-     * @returns any XP history retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1ProgressionXpHistory(limit?: number, offset?: number, source?: string, startDate?: string, endDate?: string): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            history?: Array<{
-                amount?: number;
-                source?: string;
-                timestamp?: string;
-            }>;
-            total?: number;
-            limit?: number;
-            offset?: number;
-        };
+        success: boolean;
+        data: GetMyProgressionResponse;
+        message?: string;
     }>;
     /**
      * Get progression leaderboard
-     * Public endpoint that returns leaderboard with all users' progression data
-     * @param type Leaderboard ranking type
-     * @param period Leaderboard time period
-     * @param limit Number of top users to return
-     * @returns any Leaderboard retrieved successfully
+     * @param period
+     * @param limit
+     * @param type
+     * @returns any Progression leaderboard
      * @throws ApiError
      */
-    getApiV1ProgressionLeaderboard(type?: 'total_xp' | 'level' | 'prestige', period?: 'day' | 'week' | 'month' | 'all-time', limit?: number): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            leaderboard?: Array<LeaderboardEntry>;
-            currentUser?: {
-                rank?: number;
-                score?: number;
-            };
-        };
+    getApiV1ProgressionLeaderboard(period?: 'week' | 'month' | 'all-time', limit?: number, type?: 'level' | 'total_xp' | 'prestige'): CancelablePromise<{
+        success: boolean;
+        data: ProgressionLeaderboardResponse;
+        message?: string;
     }>;
     /**
      * Get all ranks
-     * Retrieves all available ranks in the progression system with their requirements
      * @returns any Ranks retrieved successfully
      * @throws ApiError
      */
     getApiV1ProgressionRanks(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            ranks?: Array<{
-                name?: string;
-                tier?: number;
-                levelRequired?: number;
-                displayName?: string;
-            }>;
-        };
+        success: boolean;
+        data: GetRanksResponse;
+        message?: string;
     }>;
     /**
      * Check feature access
-     * Checks if the authenticated user can access a specific feature based on their progression level
-     * @param feature Feature name to check access for
-     * @returns any Feature access check completed successfully
+     * @param feature
+     * @returns any Feature access check result
      * @throws ApiError
      */
     getApiV1ProgressionCanAccess(feature: string): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            canAccess?: boolean;
-            featureName?: string;
-            requiredLevel?: number;
-            currentLevel?: number;
-        };
+        success: boolean;
+        data: CanAccessFeatureResponse;
+        message?: string;
     }>;
     /**
      * Prestige user
-     * Resets user progression and increases prestige level. User must be at maximum level to prestige.
+     * @param requestBody
      * @returns any User prestiged successfully
      * @throws ApiError
      */
-    postApiV1ProgressionPrestige(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            prestigeLevel?: number;
-            newLevel?: number;
-            bonuses?: {
-                xpBoost?: number;
-                coinBoost?: number;
-            };
-        };
+    postApiV1ProgressionPrestige(requestBody?: {
+        confirm: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: PrestigeResponse;
+        message?: string;
     }>;
 }

package/dist/services/ProgressionService.js

@@ -7,7 +7,6 @@ class ProgressionService {
     }
     /**
      * Get my progression
-     * Retrieves progression data for the authenticated user including level, XP, rank, and unlocked features
      * @returns any Progression data retrieved successfully
      * @throws ApiError
      */
@@ -16,76 +15,28 @@ class ProgressionService {
             method: 'GET',
             url: '/api/v1/progression/me',
             errors: {
-                401: `Unauthorized - authentication required`,
+                401: `Unauthorized`,
                 404: `User not found`,
                 500: `Internal server error`,
             },
         });
     }
-    /**
-     * Award XP to user (Internal)
-     * Internal endpoint to award XP to a user. Should only be called by internal services or admin tools, not frontend.
-     * @param requestBody
-     * @returns any XP awarded successfully
-     * @throws ApiError
-     */
-    postApiV1ProgressionAwardXp(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/progression/award-xp',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Bad request - missing required fields`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Get XP history
-     * Retrieves XP gain history for the authenticated user with pagination and filters
-     * @param limit Number of results per page
-     * @param offset Number of results to skip
-     * @param source Filter by XP source
-     * @param startDate Filter by start date
-     * @param endDate Filter by end date
-     * @returns any XP history retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1ProgressionXpHistory(limit = 20, offset, source, startDate, endDate) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/progression/xp-history',
-            query: {
-                'limit': limit,
-                'offset': offset,
-                'source': source,
-                'startDate': startDate,
-                'endDate': endDate,
-            },
-            errors: {
-                401: `Unauthorized - authentication required`,
-                500: `Internal server error`,
-            },
-        });
-    }
     /**
      * Get progression leaderboard
-     * Public endpoint that returns leaderboard with all users' progression data
-     * @param type Leaderboard ranking type
-     * @param period Leaderboard time period
-     * @param limit Number of top users to return
-     * @returns any Leaderboard retrieved successfully
+     * @param period
+     * @param limit
+     * @param type
+     * @returns any Progression leaderboard
      * @throws ApiError
      */
-    getApiV1ProgressionLeaderboard(type = 'total_xp', period = 'all-time', limit = 100) {
+    getApiV1ProgressionLeaderboard(period, limit = 20, type) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/progression/leaderboard',
             query: {
-                'type': type,
                 'period': period,
                 'limit': limit,
+                'type': type,
             },
             errors: {
                 500: `Internal server error`,
@@ -94,7 +45,6 @@ class ProgressionService {
     }
     /**
      * Get all ranks
-     * Retrieves all available ranks in the progression system with their requirements
      * @returns any Ranks retrieved successfully
      * @throws ApiError
      */
@@ -109,9 +59,8 @@ class ProgressionService {
     }
     /**
      * Check feature access
-     * Checks if the authenticated user can access a specific feature based on their progression level
-     * @param feature Feature name to check access for
-     * @returns any Feature access check completed successfully
+     * @param feature
+     * @returns any Feature access check result
      * @throws ApiError
      */
     getApiV1ProgressionCanAccess(feature) {
@@ -122,25 +71,27 @@ class ProgressionService {
                 'feature': feature,
             },
             errors: {
-                400: `Bad request - missing feature parameter`,
-                401: `Unauthorized - authentication required`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
      * Prestige user
-     * Resets user progression and increases prestige level. User must be at maximum level to prestige.
+     * @param requestBody
      * @returns any User prestiged successfully
      * @throws ApiError
      */
-    postApiV1ProgressionPrestige() {
+    postApiV1ProgressionPrestige(requestBody) {
         return this.httpRequest.request({
             method: 'POST',
             url: '/api/v1/progression/prestige',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                400: `Bad request - user does not meet prestige requirements`,
-                401: `Unauthorized - authentication required`,
+                400: `User does not meet prestige requirements`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });