@footballbingo/client 1.0.0

package/dist/services/PredictionsService.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictionsService = void 0;
+class PredictionsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * 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) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/predictions',
+            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`,
+            },
+        });
+    }
+    /**
+     * 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 = 'all', fixtureId, date, limit = 50, page = 1) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/predictions',
+            query: {
+                'status': status,
+                'fixtureId': fixtureId,
+                'date': date,
+                'limit': limit,
+                'page': page,
+            },
+            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`,
+            },
+        });
+    }
+    /**
+     * Get user statistics
+     * Retrieve authenticated user's prediction statistics and performance metrics
+     * @returns any User statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PredictionsStats() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/predictions/stats',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * 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', limit = 50, metric = 'points') {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/predictions/leaderboard',
+            query: {
+                'timeframe': timeframe,
+                '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
+     * @throws ApiError
+     */
+    getApiV1PredictionsFixtureCommunity(fixtureId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/predictions/fixture/{fixtureId}/community',
+            path: {
+                'fixtureId': fixtureId,
+            },
+            errors: {
+                400: `Fixture ID is required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * 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) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/predictions/{fixtureId}/share',
+            path: {
+                'fixtureId': fixtureId,
+            },
+            errors: {
+                400: `Fixture ID is required`,
+                401: `Authentication required`,
+                404: `Prediction not found`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * 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) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/predictions/shared/{shareToken}',
+            path: {
+                'shareToken': shareToken,
+            },
+            errors: {
+                400: `Share token is required`,
+                404: `Prediction not found or not public`,
+                500: `Server error`,
+            },
+        });
+    }
+}
+exports.PredictionsService = PredictionsService;

package/dist/services/ProgressionService.d.ts

@@ -0,0 +1,163 @@
+import type { LeaderboardEntry } from '../models/LeaderboardEntry';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ProgressionService {
+    readonly httpRequest: BaseHttpRequest;
+    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;
+        };
+    }>;
+    /**
+     * 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
+     * @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;
+            };
+        };
+    }>;
+    /**
+     * 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;
+            }>;
+        };
+    }>;
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ProgressionCanAccess(feature: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            canAccess?: boolean;
+            featureName?: string;
+            requiredLevel?: number;
+            currentLevel?: number;
+        };
+    }>;
+    /**
+     * Prestige user
+     * Resets user progression and increases prestige level. User must be at maximum level to prestige.
+     * @returns any User prestiged successfully
+     * @throws ApiError
+     */
+    postApiV1ProgressionPrestige(): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            prestigeLevel?: number;
+            newLevel?: number;
+            bonuses?: {
+                xpBoost?: number;
+                coinBoost?: number;
+            };
+        };
+    }>;
+}

package/dist/services/ProgressionService.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressionService = void 0;
+class ProgressionService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * 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() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/progression/me',
+            errors: {
+                401: `Unauthorized - authentication required`,
+                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
+     * @throws ApiError
+     */
+    getApiV1ProgressionLeaderboard(type = 'total_xp', period = 'all-time', limit = 100) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/progression/leaderboard',
+            query: {
+                'type': type,
+                'period': period,
+                'limit': limit,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get all ranks
+     * Retrieves all available ranks in the progression system with their requirements
+     * @returns any Ranks retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ProgressionRanks() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/progression/ranks',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ProgressionCanAccess(feature) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/progression/can-access/{feature}',
+            path: {
+                'feature': feature,
+            },
+            errors: {
+                400: `Bad request - missing feature parameter`,
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Prestige user
+     * Resets user progression and increases prestige level. User must be at maximum level to prestige.
+     * @returns any User prestiged successfully
+     * @throws ApiError
+     */
+    postApiV1ProgressionPrestige() {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/progression/prestige',
+            errors: {
+                400: `Bad request - user does not meet prestige requirements`,
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ProgressionService = ProgressionService;

package/dist/services/SponsorsService.d.ts

@@ -0,0 +1,105 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class SponsorsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get all sponsors
+     * Retrieve list of sponsors with optional filters
+     * @param isActive Filter by active/inactive sponsors
+     * @param limit Maximum number of sponsors to return
+     * @returns any Sponsors retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Sponsors(isActive?: boolean, limit?: number): CancelablePromise<{
+        success?: boolean;
+        sponsors?: Array<{
+            id?: string;
+            name?: string;
+            logo?: string;
+            website?: string;
+            description?: string;
+            isActive?: boolean;
+        }>;
+    }>;
+    /**
+     * Create a new sponsor
+     * Create a new sponsor entry (admin only)
+     * @param requestBody
+     * @returns any Sponsor created successfully
+     * @throws ApiError
+     */
+    postApiV1Sponsors(requestBody: {
+        /**
+         * Sponsor name
+         */
+        name: string;
+        /**
+         * Sponsor logo URL
+         */
+        logo: string;
+        /**
+         * Sponsor website URL
+         */
+        website?: string;
+        /**
+         * Sponsor description
+         */
+        description?: string;
+        /**
+         * Whether sponsor is active
+         */
+        isActive?: boolean;
+    }): CancelablePromise<{
+        success?: boolean;
+        sponsor?: Record<string, any>;
+    }>;
+    /**
+     * Get sponsor by ID
+     * Retrieve detailed information about a specific sponsor
+     * @param id The sponsor ID
+     * @returns any Sponsor retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Sponsors1(id: string): CancelablePromise<{
+        success?: boolean;
+        sponsor?: {
+            id?: string;
+            name?: string;
+            logo?: string;
+            website?: string;
+            description?: string;
+            isActive?: boolean;
+            createdAt?: string;
+        };
+    }>;
+    /**
+     * Update sponsor
+     * Update an existing sponsor (admin only)
+     * @param id The sponsor ID
+     * @param requestBody
+     * @returns any Sponsor updated successfully
+     * @throws ApiError
+     */
+    patchApiV1Sponsors(id: string, requestBody: {
+        name?: string;
+        logo?: string;
+        website?: string;
+        description?: string;
+        isActive?: boolean;
+    }): CancelablePromise<{
+        success?: boolean;
+        sponsor?: Record<string, any>;
+    }>;
+    /**
+     * Delete sponsor
+     * Soft delete a sponsor (admin only)
+     * @param id The sponsor ID
+     * @returns any Sponsor deleted successfully
+     * @throws ApiError
+     */
+    deleteApiV1Sponsors(id: string): CancelablePromise<{
+        success?: boolean;
+        message?: string;
+    }>;
+}