@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/AchievementsService.js

@@ -7,14 +7,13 @@ class AchievementsService {
     }
     /**
      * 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
+     * @param category
+     * @param rarity
+     * @param includeSecret
      * @returns any List of achievements retrieved successfully
      * @throws ApiError
      */
-    getApiV1Achievements(category, rarity, includeSecret = false) {
+    getApiV1Achievements(category, rarity, includeSecret) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/achievements',
@@ -30,11 +29,10 @@ class AchievementsService {
     }
     /**
      * 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
+     * @param status
+     * @param category
+     * @param sort
+     * @returns any User achievements with progress
      * @throws ApiError
      */
     getApiV1AchievementsMe(status, category, sort) {
@@ -47,55 +45,55 @@ class AchievementsService {
                 'sort': sort,
             },
             errors: {
-                401: `Unauthorized - authentication required`,
+                401: `Unauthorized`,
                 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
+     * Get recent community achievement unlocks
+     * @param limit
+     * @param offset
+     * @returns any Recent community unlocks
      * @throws ApiError
      */
-    postApiV1AchievementsProgress(requestBody) {
+    getApiV1AchievementsRecentUnlocks(limit = 20, offset) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/achievements/progress',
-            body: requestBody,
-            mediaType: 'application/json',
+            method: 'GET',
+            url: '/api/v1/achievements/recent-unlocks',
+            query: {
+                'limit': limit,
+                'offset': offset,
+            },
             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
+     * Get achievements leaderboard
+     * @param period
+     * @param limit
+     * @returns any Achievement leaderboard
      * @throws ApiError
      */
-    postApiV1AchievementsCheck(requestBody) {
+    getApiV1AchievementsLeaderboard(period, limit) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/achievements/check',
-            body: requestBody,
-            mediaType: 'application/json',
+            method: 'GET',
+            url: '/api/v1/achievements/leaderboard',
+            query: {
+                'period': period,
+                'limit': limit,
+            },
             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.
+     * Run retrospective achievement check (Admin)
      * @param requestBody
-     * @returns any Retrospective check completed successfully
+     * @returns any Retrospective check completed
      * @throws ApiError
      */
     postApiV1AchievementsRetrospective(requestBody) {
@@ -105,56 +103,53 @@ class AchievementsService {
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Bad request - missing userId`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get achievement details
-     * Retrieves detailed information about a specific achievement
-     * @param achievementId Achievement ID
-     * @returns any Achievement details retrieved successfully
+     * Update achievement progress (Internal)
+     * @param requestBody
+     * @returns any Progress updated successfully
      * @throws ApiError
      */
-    getApiV1Achievements1(achievementId) {
+    postApiV1AchievementsProgress(requestBody) {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/achievements/{achievementId}',
-            path: {
-                'achievementId': achievementId,
-            },
+            method: 'POST',
+            url: '/api/v1/achievements/progress',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                400: `Bad request - missing achievement ID`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 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
+     * Check achievements based on event (Internal)
+     * @param requestBody
+     * @returns any Achievements checked successfully
      * @throws ApiError
      */
-    postApiV1AchievementsViewed(achievementId) {
+    postApiV1AchievementsCheck(requestBody) {
         return this.httpRequest.request({
             method: 'POST',
-            url: '/api/v1/achievements/{achievementId}/viewed',
-            path: {
-                'achievementId': achievementId,
-            },
+            url: '/api/v1/achievements/check',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                400: `Bad request - missing achievement ID`,
-                401: `Unauthorized - authentication required`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 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
@@ -166,29 +161,49 @@ class AchievementsService {
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Bad request - missing required fields`,
+                400: `Bad request`,
+                401: `Unauthorized`,
                 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
+     * Get achievement details
+     * @param achievementId
+     * @returns any Achievement details retrieved successfully
      * @throws ApiError
      */
-    getApiV1AchievementsLeaderboard(period = 'all-time', limit = 100) {
+    getApiV1Achievements1(achievementId) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/achievements/leaderboard',
-            query: {
-                'period': period,
-                'limit': limit,
+            url: '/api/v1/achievements/{achievementId}',
+            path: {
+                'achievementId': achievementId,
+            },
+            errors: {
+                400: `Bad request`,
+                404: `Achievement not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Mark achievement as viewed
+     * @param achievementId
+     * @returns any Achievement marked as viewed
+     * @throws ApiError
+     */
+    postApiV1AchievementsViewed(achievementId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/achievements/{achievementId}/viewed',
+            path: {
+                'achievementId': achievementId,
             },
             errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
                 500: `Internal server error`,
             },
         });

package/dist/services/ActivitiesService.d.ts

@@ -1,3 +1,4 @@
+import type { LiveActivitiesResponse } from '../models/LiveActivitiesResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ActivitiesService {
@@ -6,22 +7,13 @@ export declare class ActivitiesService {
     /**
      * 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
+     * @param limit
      * @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;
-            }>;
-        };
+        success: boolean;
+        data: LiveActivitiesResponse;
+        message?: string;
     }>;
 }

package/dist/services/ActivitiesService.js

@@ -8,7 +8,7 @@ class ActivitiesService {
     /**
      * 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
+     * @param limit
      * @returns any Live activities retrieved successfully
      * @throws ApiError
      */
@@ -20,8 +20,8 @@ class ActivitiesService {
                 'limit': limit,
             },
             errors: {
-                400: `Invalid limit parameter`,
-                500: `Server error while fetching activities`,
+                400: `Invalid parameters`,
+                500: `Server error`,
             },
         });
     }

package/dist/services/AdminModerationService.d.ts

@@ -0,0 +1,61 @@
+import type { ModerationQueueResponse } from '../models/ModerationQueueResponse';
+import type { ModerationReportDetailResponse } from '../models/ModerationReportDetailResponse';
+import type { ModerationReportStatsResponse } from '../models/ModerationReportStatsResponse';
+import type { ModerationReviewReportResponse } from '../models/ModerationReviewReportResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class AdminModerationService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get moderation queue
+     * @param status
+     * @param contentType
+     * @param limit
+     * @param offset
+     * @returns any Moderation queue with reports
+     * @throws ApiError
+     */
+    getApiV1AdminModeration(status?: 'pending' | 'actioned' | 'dismissed', contentType?: 'match_comment' | 'game_chat' | 'community_post' | 'user', limit?: number, offset?: number | null): CancelablePromise<{
+        success: boolean;
+        data: ModerationQueueResponse;
+        message?: string;
+    }>;
+    /**
+     * Get report statistics
+     * @returns any Report statistics
+     * @throws ApiError
+     */
+    getApiV1AdminModerationStats(): CancelablePromise<{
+        success: boolean;
+        data: ModerationReportStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get report detail
+     * @param reportId
+     * @returns any Report detail with content context
+     * @throws ApiError
+     */
+    getApiV1AdminModeration1(reportId: string): CancelablePromise<{
+        success: boolean;
+        data: ModerationReportDetailResponse;
+        message?: string;
+    }>;
+    /**
+     * Review and action a report
+     * @param reportId
+     * @param requestBody
+     * @returns any Report reviewed successfully
+     * @throws ApiError
+     */
+    postApiV1AdminModerationReview(reportId: string, requestBody?: {
+        status: 'actioned' | 'dismissed';
+        actionTaken?: 'content_removed' | 'user_warned' | 'user_banned';
+        reviewNotes?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: ModerationReviewReportResponse;
+        message?: string;
+    }>;
+}

package/dist/services/AdminModerationService.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminModerationService = void 0;
+class AdminModerationService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get moderation queue
+     * @param status
+     * @param contentType
+     * @param limit
+     * @param offset
+     * @returns any Moderation queue with reports
+     * @throws ApiError
+     */
+    getApiV1AdminModeration(status, contentType, limit = 20, offset) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/moderation',
+            query: {
+                'status': status,
+                'contentType': contentType,
+                'limit': limit,
+                'offset': offset,
+            },
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+            },
+        });
+    }
+    /**
+     * Get report statistics
+     * @returns any Report statistics
+     * @throws ApiError
+     */
+    getApiV1AdminModerationStats() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/moderation/stats',
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+            },
+        });
+    }
+    /**
+     * Get report detail
+     * @param reportId
+     * @returns any Report detail with content context
+     * @throws ApiError
+     */
+    getApiV1AdminModeration1(reportId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/moderation/{reportId}',
+            path: {
+                'reportId': reportId,
+            },
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Report not found`,
+            },
+        });
+    }
+    /**
+     * Review and action a report
+     * @param reportId
+     * @param requestBody
+     * @returns any Report reviewed successfully
+     * @throws ApiError
+     */
+    postApiV1AdminModerationReview(reportId, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/moderation/{reportId}/review',
+            path: {
+                'reportId': reportId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Report not found`,
+            },
+        });
+    }
+}
+exports.AdminModerationService = AdminModerationService;