@footballbingo/client 1.0.0

package/dist/services/ChallengesService.d.ts

@@ -0,0 +1,215 @@
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { Challenge } from '../models/Challenge';
+import type { LeaderboardEntry } from '../models/LeaderboardEntry';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ChallengesService {
+    readonly httpRequest: BaseHttpRequest;
+    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
+     * @throws ApiError
+     */
+    getApiV1Challenges(type?: 'daily' | 'weekly' | 'seasonal' | 'special', difficulty?: 'easy' | 'medium' | 'hard' | 'expert', status?: 'active' | 'completed' | 'claimed'): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            challenges?: Array<Challenge>;
+        };
+    }>;
+    /**
+     * Get specific challenge details
+     * Retrieves detailed information about a specific challenge
+     * @param challengeId Challenge ID
+     * @returns any Challenge details
+     * @throws ApiError
+     */
+    getApiV1Challenges1(challengeId: string): CancelablePromise<(ApiResponseDTO & {
+        data?: Challenge;
+    })>;
+    /**
+     * 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
+     * @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>;
+        };
+    }>;
+    /**
+     * 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
+     * @throws ApiError
+     */
+    postApiV1ChallengesClaim(challengeId: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            reward?: {
+                coins?: number;
+                xp?: number;
+                items?: Array<string>;
+            };
+        };
+    }>;
+    /**
+     * Claim all completed challenges
+     * Claims rewards for all completed but unclaimed challenges
+     * @returns any All rewards claimed successfully
+     * @throws ApiError
+     */
+    postApiV1ChallengesClaimAll(): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            /**
+             * Number of challenges claimed
+             */
+            claimed?: number;
+            totalRewards?: {
+                coins?: number;
+                xp?: number;
+            };
+        };
+    }>;
+    /**
+     * 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
+     * @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;
+        };
+    }>;
+    /**
+     * 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
+     * @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;
+            };
+        };
+    }>;
+    /**
+     * Get user's challenge streak
+     * Retrieves current challenge completion streak information for the user
+     * @returns any Streak information retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ChallengesStreak(): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            /**
+             * Current consecutive days
+             */
+            currentStreak?: number;
+            /**
+             * All-time longest streak
+             */
+            longestStreak?: number;
+            lastCompletionDate?: string;
+        };
+    }>;
+    /**
+     * Generate daily challenges (Admin)
+     * Admin endpoint to generate daily challenges for all users
+     * @param requestBody
+     * @returns any Daily challenges generated successfully
+     * @throws ApiError
+     */
+    postApiV1ChallengesGenerateDaily(requestBody: {
+        /**
+         * Date to generate challenges for
+         */
+        date: 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;
+        };
+    }>;
+    /**
+     * Generate weekly challenges (Admin)
+     * Admin endpoint to generate weekly challenges for all users
+     * @param requestBody
+     * @returns any Weekly challenges generated successfully
+     * @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;
+        };
+    }>;
+}

package/dist/services/ChallengesService.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengesService = void 0;
+class ChallengesService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1Challenges(type, difficulty, status) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/challenges',
+            query: {
+                'type': type,
+                'difficulty': difficulty,
+                'status': status,
+            },
+            errors: {
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get specific challenge details
+     * Retrieves detailed information about a specific challenge
+     * @param challengeId Challenge ID
+     * @returns any Challenge details
+     * @throws ApiError
+     */
+    getApiV1Challenges1(challengeId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/challenges/{challengeId}',
+            path: {
+                'challengeId': challengeId,
+            },
+            errors: {
+                400: `Bad request - missing challenge ID`,
+                404: `Challenge not found`,
+                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
+     * @throws ApiError
+     */
+    postApiV1ChallengesProgress(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/challenges/progress',
+            body: requestBody,
+            mediaType: 'application/json',
+            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
+     * @throws ApiError
+     */
+    postApiV1ChallengesClaim(challengeId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/challenges/{challengeId}/claim',
+            path: {
+                'challengeId': challengeId,
+            },
+            errors: {
+                400: `Bad request - challenge not completed or already claimed`,
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Claim all completed challenges
+     * Claims rewards for all completed but unclaimed challenges
+     * @returns any All rewards claimed successfully
+     * @throws ApiError
+     */
+    postApiV1ChallengesClaimAll() {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/challenges/claim-all',
+            errors: {
+                401: `Unauthorized - authentication required`,
+                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
+     * @throws ApiError
+     */
+    getApiV1ChallengesHistory(limit = 20, offset, type, startDate, endDate) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/challenges/history',
+            query: {
+                'limit': limit,
+                'offset': offset,
+                'type': type,
+                'startDate': startDate,
+                'endDate': endDate,
+            },
+            errors: {
+                401: `Unauthorized - authentication required`,
+                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
+     * @throws ApiError
+     */
+    getApiV1ChallengesLeaderboard(period = 'week', type = 'all', limit = 100) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/challenges/leaderboard',
+            query: {
+                'period': period,
+                'type': type,
+                'limit': limit,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get user's challenge streak
+     * Retrieves current challenge completion streak information for the user
+     * @returns any Streak information retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ChallengesStreak() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/challenges/streak',
+            errors: {
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Generate daily challenges (Admin)
+     * Admin endpoint to generate daily challenges for all users
+     * @param requestBody
+     * @returns any Daily challenges generated successfully
+     * @throws ApiError
+     */
+    postApiV1ChallengesGenerateDaily(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/challenges/generate/daily',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - missing date`,
+                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
+     * @throws ApiError
+     */
+    postApiV1ChallengesGenerateWeekly(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/challenges/generate/weekly',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - missing weekStart`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ChallengesService = ChallengesService;

package/dist/services/CommunityChallengesService.d.ts

@@ -0,0 +1,111 @@
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { CommunityChallengeDTO } from '../models/CommunityChallengeDTO';
+import type { CreateChallengeRequestDTO } from '../models/CreateChallengeRequestDTO';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class CommunityChallengesService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Create a new challenge
+     * Creates a new community challenge
+     * @param requestBody
+     * @returns any Challenge created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityChallenges(requestBody: CreateChallengeRequestDTO): CancelablePromise<(ApiResponseDTO & {
+        data?: CommunityChallengeDTO;
+    })>;
+    /**
+     * List all challenges
+     * Retrieves a list of all community challenges
+     * @returns any Challenges retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallenges(): CancelablePromise<(ApiResponseDTO & {
+        data?: Array<CommunityChallengeDTO>;
+    })>;
+    /**
+     * Get challenge by ID
+     * Retrieves a specific challenge by its ID
+     * @param id Challenge ID
+     * @returns any Challenge retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallenges1(id: string): CancelablePromise<(ApiResponseDTO & {
+        data?: CommunityChallengeDTO;
+    })>;
+    /**
+     * Update a challenge
+     * Updates an existing challenge
+     * @param id Challenge ID
+     * @param requestBody
+     * @returns any Challenge updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunityChallenges(id: string, requestBody: CreateChallengeRequestDTO): CancelablePromise<(ApiResponseDTO & {
+        data?: CommunityChallengeDTO;
+    })>;
+    /**
+     * Create challenge from shared game
+     * Creates a new challenge game from a shared game to compete against another user
+     * @param publicId Public ID of the shared game
+     * @returns any Challenge game created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityChallengesShared(publicId: string): CancelablePromise<(ApiResponseDTO & {
+        data?: {
+            message?: string;
+            /**
+             * ID of the newly created challenge game
+             */
+            gameId?: string;
+            /**
+             * ID of the challenge record
+             */
+            challengeId?: string;
+        };
+    })>;
+    /**
+     * Get user's challenges
+     * Retrieves all challenges for the authenticated user
+     * @returns any User challenges retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallengesMy(): CancelablePromise<(ApiResponseDTO & {
+        data?: Array<{
+            id?: string;
+            createdAt?: string;
+            status?: 'pending' | 'active' | 'completed';
+            outcome?: 'pending' | 'won' | 'lost' | 'draw';
+            opponent?: {
+                id?: string;
+                username?: string;
+            };
+        }>;
+    })>;
+    /**
+     * Get challenge details by ID
+     * Retrieves detailed information about a specific challenge including games and opponent info
+     * @param id Challenge ID
+     * @returns any Challenge details retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallengesDetails(id: string): CancelablePromise<(ApiResponseDTO & {
+        data?: {
+            id?: string;
+            createdAt?: string;
+            status?: 'pending' | 'active' | 'completed';
+            outcome?: 'pending' | 'won' | 'lost' | 'draw';
+            fixtureId?: string;
+            boardSize?: number;
+            role?: 'challenger' | 'owner';
+            challengerGameId?: string;
+            ownerGameId?: string;
+            opponent?: {
+                id?: string;
+                username?: string;
+            };
+        };
+    })>;
+}

package/dist/services/CommunityChallengesService.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityChallengesService = void 0;
+class CommunityChallengesService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Create a new challenge
+     * Creates a new community challenge
+     * @param requestBody
+     * @returns any Challenge created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityChallenges(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/challenges',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - invalid input`,
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all challenges
+     * Retrieves a list of all community challenges
+     * @returns any Challenges retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallenges() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/challenges',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get challenge by ID
+     * Retrieves a specific challenge by its ID
+     * @param id Challenge ID
+     * @returns any Challenge retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallenges1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/challenges/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Challenge not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Update a challenge
+     * Updates an existing challenge
+     * @param id Challenge ID
+     * @param requestBody
+     * @returns any Challenge updated successfully
+     * @throws ApiError
+     */
+    putApiV1CommunityChallenges(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/community/challenges/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - invalid input`,
+                401: `Unauthorized - authentication required`,
+                404: `Challenge not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Create challenge from shared game
+     * Creates a new challenge game from a shared game to compete against another user
+     * @param publicId Public ID of the shared game
+     * @returns any Challenge game created successfully
+     * @throws ApiError
+     */
+    postApiV1CommunityChallengesShared(publicId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/community/challenges/shared/{publicId}',
+            path: {
+                'publicId': publicId,
+            },
+            errors: {
+                400: `Bad request - invalid input or user cannot challenge themselves`,
+                401: `Unauthorized - authentication required`,
+                404: `Shared game not found or no longer available`,
+                409: `Conflict - user already challenged this game`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get user's challenges
+     * Retrieves all challenges for the authenticated user
+     * @returns any User challenges retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallengesMy() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/challenges/my',
+            errors: {
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get challenge details by ID
+     * Retrieves detailed information about a specific challenge including games and opponent info
+     * @param id Challenge ID
+     * @returns any Challenge details retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1CommunityChallengesDetails(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/community/challenges/details/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized - authentication required`,
+                403: `Forbidden - user is not involved in this challenge`,
+                404: `Challenge not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.CommunityChallengesService = CommunityChallengesService;