@footballbingo/client 1.0.0

package/dist/services/AchievementsDeprecatedService.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AchievementsDeprecatedService = void 0;
+class AchievementsDeprecatedService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * @deprecated
+     * Create achievement
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements` endpoints instead.
+     *
+     * Creates a new achievement in the system.
+     *
+     * @param requestBody
+     * @returns any Achievement created successfully
+     * @throws ApiError
+     */
+    postApiAchievements(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/achievements',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * List all achievements
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements` endpoints instead.
+     *
+     * Retrieves a list of all achievements in the system.
+     *
+     * @returns any List of achievements retrieved successfully
+     * @throws ApiError
+     */
+    getApiAchievements() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/achievements',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Get achievement by ID
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements/{achievementId}` instead.
+     *
+     * Retrieves a specific achievement by its ID.
+     *
+     * @param id Achievement ID
+     * @returns any Achievement retrieved successfully
+     * @throws ApiError
+     */
+    getApiAchievements1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/achievements/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Update achievement
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements` endpoints instead.
+     *
+     * Updates an existing achievement.
+     *
+     * @param id Achievement ID
+     * @param requestBody
+     * @returns any Achievement updated successfully
+     * @throws ApiError
+     */
+    putApiAchievements(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/achievements/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Delete achievement
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements` endpoints instead.
+     *
+     * Deletes an achievement from the system.
+     *
+     * @param id Achievement ID
+     * @returns any Achievement deleted successfully
+     * @throws ApiError
+     */
+    deleteApiAchievements(id) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/achievements/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Search achievements
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements` with query parameters instead.
+     *
+     * Searches achievements with various filters including tags, unlocked status, premium status, and user-specific data.
+     *
+     * @param tags Comma-separated list of tags to filter by
+     * @param unlocked Filter by unlocked status
+     * @param premium Filter by premium achievements
+     * @param hidden Filter by hidden achievements
+     * @param userId User ID to filter achievements for
+     * @returns any Achievements found successfully
+     * @throws ApiError
+     */
+    getApiAchievementsSearch(tags, unlocked, premium, hidden, userId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/achievements/search',
+            query: {
+                'tags': tags,
+                'unlocked': unlocked,
+                'premium': premium,
+                'hidden': hidden,
+                'userId': userId,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Get locked achievements for current user
+     * **DEPRECATED**: This endpoint is deprecated and will be removed in a future version.
+     * Please use `/api/v1/achievements/me` with status filter instead.
+     *
+     * Retrieves all locked achievements for the authenticated user.
+     *
+     * @returns any Locked achievements retrieved successfully
+     * @throws ApiError
+     */
+    getApiAchievementsLockedMe() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/achievements/locked/me',
+            errors: {
+                401: `Not authenticated`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.AchievementsDeprecatedService = AchievementsDeprecatedService;

package/dist/services/AchievementsService.d.ts

@@ -0,0 +1,204 @@
+import type { Achievement } from '../models/Achievement';
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { LeaderboardEntry } from '../models/LeaderboardEntry';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class AchievementsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get all achievements
+     * Retrieve all available achievements with optional filters for category, rarity, and secret achievements
+     * @param category Filter by achievement category
+     * @param rarity Filter by rarity level
+     * @param includeSecret Include secret achievements
+     * @returns any List of achievements retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Achievements(category?: string, rarity?: 'common' | 'rare' | 'epic' | 'legendary', includeSecret?: boolean): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            achievements?: Array<Achievement>;
+        };
+    }>;
+    /**
+     * Get my achievements
+     * Retrieve achievements for the authenticated user with progress tracking and optional filters
+     * @param status Filter by achievement status
+     * @param category Filter by category
+     * @param sort Sort order
+     * @returns any User's achievements with progress retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1AchievementsMe(status?: 'locked' | 'in_progress' | 'unlocked', category?: string, sort?: 'recent' | 'progress' | 'rarity'): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            achievements?: Array<Achievement>;
+            stats?: {
+                totalUnlocked?: number;
+                totalAvailable?: number;
+                totalPoints?: number;
+            };
+        };
+    }>;
+    /**
+     * Update achievement progress (Internal)
+     * Internal endpoint to update achievement progress. Should only be called by backend services, not frontend.
+     * @param requestBody
+     * @returns any Progress updated successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsProgress(requestBody: {
+        /**
+         * User ID to update progress for
+         */
+        userId: string;
+        /**
+         * Achievement key identifier
+         */
+        achievementKey: string;
+        /**
+         * Amount to increment progress by
+         */
+        increment: number;
+        /**
+         * Source of the progress update
+         */
+        source?: string;
+        /**
+         * Source entity ID
+         */
+        sourceId?: string;
+        /**
+         * Additional metadata for the progress update
+         */
+        metadata?: Record<string, any>;
+        /**
+         * Whether to check if achievement should be unlocked
+         */
+        checkUnlock?: boolean;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            progress?: number;
+            unlocked?: boolean;
+        };
+    }>;
+    /**
+     * Check achievements (Internal)
+     * Internal endpoint to check and update achievements based on events. Should only be called by backend services, not frontend.
+     * @param requestBody
+     * @returns any Achievements checked successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsCheck(requestBody: {
+        /**
+         * User ID to check achievements for
+         */
+        userId: string;
+        /**
+         * Type of event that occurred
+         */
+        eventType: string;
+        /**
+         * Event data payload
+         */
+        eventData: Record<string, any>;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            unlockedAchievements?: Array<string>;
+        };
+    }>;
+    /**
+     * Run retrospective check (Internal)
+     * Internal endpoint to run retrospective achievement checks for a user. Should only be called by backend services, not frontend.
+     * @param requestBody
+     * @returns any Retrospective check completed successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsRetrospective(requestBody: {
+        /**
+         * User ID to run retrospective check for
+         */
+        userId: string;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            checkedAchievements?: number;
+            unlockedAchievements?: Array<string>;
+        };
+    }>;
+    /**
+     * Get achievement details
+     * Retrieves detailed information about a specific achievement
+     * @param achievementId Achievement ID
+     * @returns any Achievement details retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Achievements1(achievementId: string): CancelablePromise<(ApiResponseDTO & {
+        data?: Achievement;
+    })>;
+    /**
+     * Mark achievement as viewed
+     * Marks a specific achievement as viewed by the authenticated user
+     * @param achievementId Achievement ID to mark as viewed
+     * @returns any Achievement marked as viewed successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsViewed(achievementId: string): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            viewed?: boolean;
+        };
+    }>;
+    /**
+     * Grant achievement (Admin)
+     * Admin-only endpoint to manually grant an achievement to a user. Should only be called by admin users.
+     * @param requestBody
+     * @returns any Achievement granted successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsGrant(requestBody: {
+        /**
+         * User ID to grant achievement to
+         */
+        userId: string;
+        /**
+         * Achievement key identifier
+         */
+        achievementKey: string;
+        /**
+         * Reason for granting the achievement
+         */
+        reason?: string;
+        /**
+         * Whether to skip criteria validation
+         */
+        skipCriteriaCheck?: boolean;
+    }): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            granted?: boolean;
+            achievement?: Achievement;
+        };
+    }>;
+    /**
+     * Get achievements leaderboard
+     * Public endpoint that returns leaderboard with all users' achievement data
+     * @param period Leaderboard time period
+     * @param limit Number of top users to return
+     * @returns any Leaderboard retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1AchievementsLeaderboard(period?: 'day' | 'week' | 'month' | 'all-time', limit?: number): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            leaderboard?: Array<LeaderboardEntry>;
+            currentUser?: {
+                rank?: number;
+                score?: number;
+            };
+        };
+    }>;
+}

package/dist/services/AchievementsService.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AchievementsService = void 0;
+class AchievementsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get all achievements
+     * Retrieve all available achievements with optional filters for category, rarity, and secret achievements
+     * @param category Filter by achievement category
+     * @param rarity Filter by rarity level
+     * @param includeSecret Include secret achievements
+     * @returns any List of achievements retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Achievements(category, rarity, includeSecret = false) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/achievements',
+            query: {
+                'category': category,
+                'rarity': rarity,
+                'includeSecret': includeSecret,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get my achievements
+     * Retrieve achievements for the authenticated user with progress tracking and optional filters
+     * @param status Filter by achievement status
+     * @param category Filter by category
+     * @param sort Sort order
+     * @returns any User's achievements with progress retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1AchievementsMe(status, category, sort) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/achievements/me',
+            query: {
+                'status': status,
+                'category': category,
+                'sort': sort,
+            },
+            errors: {
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Update achievement progress (Internal)
+     * Internal endpoint to update achievement progress. Should only be called by backend services, not frontend.
+     * @param requestBody
+     * @returns any Progress updated successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsProgress(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/achievements/progress',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - missing required fields`,
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Check achievements (Internal)
+     * Internal endpoint to check and update achievements based on events. Should only be called by backend services, not frontend.
+     * @param requestBody
+     * @returns any Achievements checked successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsCheck(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/achievements/check',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - missing required fields`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Run retrospective check (Internal)
+     * Internal endpoint to run retrospective achievement checks for a user. Should only be called by backend services, not frontend.
+     * @param requestBody
+     * @returns any Retrospective check completed successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsRetrospective(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/achievements/retrospective',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - missing userId`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get achievement details
+     * Retrieves detailed information about a specific achievement
+     * @param achievementId Achievement ID
+     * @returns any Achievement details retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Achievements1(achievementId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/achievements/{achievementId}',
+            path: {
+                'achievementId': achievementId,
+            },
+            errors: {
+                400: `Bad request - missing achievement ID`,
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Mark achievement as viewed
+     * Marks a specific achievement as viewed by the authenticated user
+     * @param achievementId Achievement ID to mark as viewed
+     * @returns any Achievement marked as viewed successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsViewed(achievementId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/achievements/{achievementId}/viewed',
+            path: {
+                'achievementId': achievementId,
+            },
+            errors: {
+                400: `Bad request - missing achievement ID`,
+                401: `Unauthorized - authentication required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Grant achievement (Admin)
+     * Admin-only endpoint to manually grant an achievement to a user. Should only be called by admin users.
+     * @param requestBody
+     * @returns any Achievement granted successfully
+     * @throws ApiError
+     */
+    postApiV1AchievementsGrant(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/achievements/grant',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request - missing required fields`,
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get achievements leaderboard
+     * Public endpoint that returns leaderboard with all users' achievement data
+     * @param period Leaderboard time period
+     * @param limit Number of top users to return
+     * @returns any Leaderboard retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1AchievementsLeaderboard(period = 'all-time', limit = 100) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/achievements/leaderboard',
+            query: {
+                'period': period,
+                'limit': limit,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.AchievementsService = AchievementsService;

package/dist/services/ActivitiesService.d.ts

@@ -0,0 +1,27 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ActivitiesService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get live activity feed
+     * Retrieve recent bingo wins and achievements for the live activity feed. Shows real-time community activities including game completions, wins, and achievement unlocks.
+     * @param limit Maximum number of activity items to return
+     * @returns any Live activities retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ActivitiesLive(limit?: number): CancelablePromise<{
+        success?: boolean;
+        data?: {
+            activities?: Array<{
+                id?: string;
+                type?: 'bingo_win' | 'achievement_unlock' | 'milestone';
+                userId?: string;
+                username?: string;
+                description?: string;
+                metadata?: Record<string, any>;
+                createdAt?: string;
+            }>;
+        };
+    }>;
+}

package/dist/services/ActivitiesService.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivitiesService = void 0;
+class ActivitiesService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get live activity feed
+     * Retrieve recent bingo wins and achievements for the live activity feed. Shows real-time community activities including game completions, wins, and achievement unlocks.
+     * @param limit Maximum number of activity items to return
+     * @returns any Live activities retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ActivitiesLive(limit = 20) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/activities/live',
+            query: {
+                'limit': limit,
+            },
+            errors: {
+                400: `Invalid limit parameter`,
+                500: `Server error while fetching activities`,
+            },
+        });
+    }
+}
+exports.ActivitiesService = ActivitiesService;