@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/AdminService.js

@@ -6,57 +6,989 @@ class AdminService {
         this.httpRequest = httpRequest;
     }
     /**
-     * Cleanup anonymous lineups
-     * Soft deletes anonymous lineups older than 7 days and hard deletes soft-deleted lineups older than 30 days. Requires secret token authentication for automated cleanup jobs.
-     * @returns any Cleanup completed successfully
+     * Admin - Adjust user balance
+     * Allows admins to adjust a user's XP or coin balance with full audit trail
+     * @param requestBody
+     * @returns any Balance adjusted successfully
+     * @throws ApiError
+     */
+    postApiV1WalletAdminAdjust(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/wallet/admin/adjust',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid request data`,
+                401: `Not authenticated`,
+                403: `Not authorized (admin only)`,
+                404: `Target user not found`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Admin - Get user wallet details
+     * Allows admins to view any user's wallet balance and transaction history
+     * @param userId
+     * @param limit
+     * @param offset
+     * @returns any User wallet details retrieved
+     * @throws ApiError
+     */
+    getApiV1WalletAdminUser(userId, limit = 20, offset) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/wallet/admin/user/{userId}',
+            path: {
+                'userId': userId,
+            },
+            query: {
+                'limit': limit,
+                'offset': offset,
+            },
+            errors: {
+                401: `Not authenticated`,
+                403: `Not authorized (admin only)`,
+                404: `User not found`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get dashboard stats overview
+     * @returns any Dashboard statistics
+     * @throws ApiError
+     */
+    getApiV1AdminDashboard() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/dashboard',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get user growth data for charts
+     * @param days
+     * @returns any User growth data
+     * @throws ApiError
+     */
+    getApiV1AdminDashboardUserGrowth(days = 30) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/dashboard/user-growth',
+            query: {
+                'days': days,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get top users leaderboard
+     * @param limit
+     * @param sortBy
+     * @returns any Top users
+     * @throws ApiError
+     */
+    getApiV1AdminDashboardTopUsers(limit = 10, sortBy = 'xp') {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/dashboard/top-users',
+            query: {
+                'limit': limit,
+                'sortBy': sortBy,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Search users with filters
+     * @param q
+     * @param offset
+     * @param limit
+     * @param sortBy
+     * @param sortOrder
+     * @param filter
+     * @returns any User search results
+     * @throws ApiError
+     */
+    getApiV1AdminUsers(q, offset, limit = 20, sortBy, sortOrder, filter) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/users',
+            query: {
+                'q': q,
+                'offset': offset,
+                'limit': limit,
+                'sortBy': sortBy,
+                'sortOrder': sortOrder,
+                'filter': filter,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get detailed user info
+     * @param userId
+     * @returns any User details
+     * @throws ApiError
+     */
+    getApiV1AdminUsers1(userId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/users/{userId}',
+            path: {
+                'userId': userId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `User not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Ban a user
+     * @param userId
+     * @param requestBody
+     * @returns any User banned
+     * @throws ApiError
+     */
+    postApiV1AdminUsersBan(userId, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/users/{userId}/ban',
+            path: {
+                'userId': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `User not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Unban a user
+     * @param userId
+     * @returns any User unbanned
+     * @throws ApiError
+     */
+    postApiV1AdminUsersUnban(userId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/users/{userId}/unban',
+            path: {
+                'userId': userId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `User not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Set admin status
+     * @param userId
+     * @param requestBody
+     * @returns any Admin status updated
+     * @throws ApiError
+     */
+    postApiV1AdminUsersAdminStatus(userId, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/users/{userId}/admin-status',
+            path: {
+                'userId': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `User not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Adjust user balance (coins/xp)
+     * @param userId
+     * @param requestBody
+     * @returns any Balance adjusted
+     * @throws ApiError
+     */
+    postApiV1AdminUsersBalance(userId, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/users/{userId}/balance',
+            path: {
+                'userId': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `User not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Impersonate a user (for debugging)
+     * @param userId
+     * @returns any Impersonation token generated
+     * @throws ApiError
+     */
+    postApiV1AdminUsersImpersonate(userId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/users/{userId}/impersonate',
+            path: {
+                'userId': userId,
+            },
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List active impersonation sessions
+     * @returns any Active impersonation sessions
+     * @throws ApiError
+     */
+    getApiV1AdminImpersonations() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/impersonations',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Revoke an impersonation token
+     * @param requestBody
+     * @returns any Impersonation token revoked
+     * @throws ApiError
+     */
+    postApiV1AdminImpersonationsRevoke(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/impersonations/revoke',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all game templates
+     * @param includeArchived
+     * @param offset
+     * @param limit
+     * @returns any List of game templates
+     * @throws ApiError
+     */
+    getApiV1AdminGames(includeArchived = false, offset, limit = 20) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/games',
+            query: {
+                'includeArchived': includeArchived,
+                'offset': offset,
+                'limit': limit,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Create game template
+     * @param requestBody
+     * @returns any Game template created
+     * @throws ApiError
+     */
+    postApiV1AdminGames(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/games',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get single game template
+     * @param id
+     * @returns any Game template details
+     * @throws ApiError
+     */
+    getApiV1AdminGames1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/games/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Game template not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Update game template
+     * @param id
+     * @param requestBody
+     * @returns any Game template updated
+     * @throws ApiError
+     */
+    putApiV1AdminGames(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/admin/games/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Game template not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Archive game template
+     * @param id
+     * @param requestBody
+     * @returns any Game template archived
+     * @throws ApiError
+     */
+    postApiV1AdminGamesArchive(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/games/{id}/archive',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Game template not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all live/active sessions
+     * @returns any Live sessions
+     * @throws ApiError
+     */
+    getApiV1AdminSessionsLive() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/sessions/live',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get session details
+     * @param sessionCode
+     * @returns any Session details
+     * @throws ApiError
+     */
+    getApiV1AdminSessions(sessionCode) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/sessions/{sessionCode}',
+            path: {
+                'sessionCode': sessionCode,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Session not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Force end a session
+     * @param sessionCode
+     * @returns any Session ended
+     * @throws ApiError
+     */
+    postApiV1AdminSessionsEnd(sessionCode) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/sessions/{sessionCode}/end',
+            path: {
+                'sessionCode': sessionCode,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Session not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all achievements
+     * @param category
+     * @param includeInactive
+     * @returns any Achievements list
+     * @throws ApiError
+     */
+    getApiV1AdminAchievements(category, includeInactive = false) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/achievements',
+            query: {
+                'category': category,
+                'includeInactive': includeInactive,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get achievement stats (unlock rate, etc.)
+     * @param id
+     * @returns any Achievement statistics
+     * @throws ApiError
+     */
+    getApiV1AdminAchievementsStats(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/achievements/{id}/stats',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all challenges
+     * @param type
+     * @param isActive
+     * @param offset
+     * @param limit
+     * @returns any Challenges list
+     * @throws ApiError
+     */
+    getApiV1AdminChallenges(type, isActive, offset, limit = 20) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/challenges',
+            query: {
+                'type': type,
+                'isActive': isActive,
+                'offset': offset,
+                'limit': limit,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get challenge stats
+     * @param id
+     * @returns any Challenge statistics
+     * @throws ApiError
+     */
+    getApiV1AdminChallengesStats(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/challenges/{id}/stats',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List predictions with filters
+     * @param fixtureId
+     * @param userId
+     * @param isResolved
+     * @param offset
+     * @param limit
+     * @returns any Predictions list
+     * @throws ApiError
+     */
+    getApiV1AdminPredictions(fixtureId, userId, isResolved, offset, limit = 20) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/predictions',
+            query: {
+                'fixtureId': fixtureId,
+                'userId': userId,
+                'isResolved': isResolved,
+                'offset': offset,
+                'limit': limit,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get prediction stats for a fixture
+     * @param fixtureId
+     * @returns any Prediction statistics for fixture
+     * @throws ApiError
+     */
+    getApiV1AdminPredictionsFixtureStats(fixtureId) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/predictions/fixture/{fixtureId}/stats',
+            path: {
+                'fixtureId': fixtureId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Manually resolve predictions for a fixture
+     * @param fixtureId
+     * @returns any Predictions resolved
+     * @throws ApiError
+     */
+    postApiV1AdminPredictionsFixtureResolve(fixtureId) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/predictions/fixture/{fixtureId}/resolve',
+            path: {
+                'fixtureId': fixtureId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get notification stats
+     * @returns any Notification statistics
+     * @throws ApiError
+     */
+    getApiV1AdminNotificationsStats() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/notifications/stats',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get notification log
+     * @param type
+     * @param offset
+     * @param limit
+     * @returns any Notification log entries
+     * @throws ApiError
+     */
+    getApiV1AdminNotificationsLog(type, offset, limit = 50) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/notifications/log',
+            query: {
+                'type': type,
+                'offset': offset,
+                'limit': limit,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Broadcast notification to users
+     * @param requestBody
+     * @returns any Broadcast sent
+     * @throws ApiError
+     */
+    postApiV1AdminNotificationsBroadcast(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/notifications/broadcast',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get moderation queue (pending reports, flagged content)
+     * @returns any Moderation queue
+     * @throws ApiError
+     */
+    getApiV1AdminModerationQueue() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/moderation/queue',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Review an event report
+     * @param id
+     * @param requestBody
+     * @returns any Report reviewed
+     * @throws ApiError
+     */
+    postApiV1AdminModerationReportsReview(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/moderation/reports/{id}/review',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Report not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Delete a comment
+     * @param id
+     * @returns any Comment deleted
      * @throws ApiError
      */
-    postApiV1AdminCleanupLineups() {
+    deleteApiV1AdminModerationComments(id) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/admin/cleanup/lineups',
+            method: 'DELETE',
+            url: '/api/v1/admin/moderation/comments/{id}',
+            path: {
+                'id': id,
+            },
             errors: {
-                401: `Invalid or missing secret token`,
-                500: `Server error during cleanup`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Comment not found`,
+                500: `Internal server error`,
             },
         });
     }
     /**
-     * Cleanup anonymous tactics boards
-     * Soft deletes anonymous tactics boards older than 7 days and hard deletes soft-deleted tactics boards older than 30 days. Requires secret token authentication for automated cleanup jobs.
-     * @returns any Cleanup completed successfully
+     * Get event log (analytics events)
+     * @param eventType
+     * @param userId
+     * @param startDate
+     * @param endDate
+     * @param offset
+     * @param limit
+     * @returns any Event log entries
+     * @throws ApiError
+     */
+    getApiV1AdminAnalyticsEvents(eventType, userId, startDate, endDate, offset, limit = 50) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/analytics/events',
+            query: {
+                'eventType': eventType,
+                'userId': userId,
+                'startDate': startDate,
+                'endDate': endDate,
+                'offset': offset,
+                'limit': limit,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get all event types with counts
+     * @returns any Event types with counts
+     * @throws ApiError
+     */
+    getApiV1AdminAnalyticsEventsTypes() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/analytics/events/types',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get event stats aggregated by type and day
+     * @param days
+     * @returns any Aggregated event statistics
+     * @throws ApiError
+     */
+    getApiV1AdminAnalyticsEventsStats(days = 7) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/analytics/events/stats',
+            query: {
+                'days': days,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List event reports with filters
+     * @param status
+     * @param reportType
+     * @param fixtureId
+     * @param userId
+     * @param offset
+     * @param limit
+     * @returns any Event reports
+     * @throws ApiError
+     */
+    getApiV1AdminEventReports(status, reportType, fixtureId, userId, offset, limit = 20) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/event-reports',
+            query: {
+                'status': status,
+                'reportType': reportType,
+                'fixtureId': fixtureId,
+                'userId': userId,
+                'offset': offset,
+                'limit': limit,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get event report stats
+     * @returns any Event report statistics
+     * @throws ApiError
+     */
+    getApiV1AdminEventReportsStats() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/event-reports/stats',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get single event report by ID
+     * @param id
+     * @returns any Event report details
+     * @throws ApiError
+     */
+    getApiV1AdminEventReports1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/event-reports/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Event report not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get job status (last run times)
+     * @returns any Job status information
+     * @throws ApiError
+     */
+    getApiV1AdminSystemJobs() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/system/jobs',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Clear cache by type
+     * @param type
+     * @returns any Cache cleared
      * @throws ApiError
      */
-    postApiV1AdminCleanupTacticsBoards() {
+    postApiV1AdminSystemCacheClear(type) {
         return this.httpRequest.request({
             method: 'POST',
-            url: '/api/v1/admin/cleanup/tactics-boards',
+            url: '/api/v1/admin/system/cache/{type}/clear',
+            path: {
+                'type': type,
+            },
             errors: {
-                401: `Invalid or missing secret token`,
-                500: `Server error during cleanup`,
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
-     * Cleanup anonymous transfer plans
-     * Soft deletes anonymous transfer plans older than 7 days and hard deletes soft-deleted transfer plans older than 30 days. Requires secret token authentication for automated cleanup jobs.
-     * @returns any Cleanup completed successfully
+     * Get feature flags
+     * @returns any Feature flags
+     * @throws ApiError
+     */
+    getApiV1AdminSystemFeatureFlags() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/system/feature-flags',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Set feature flag
+     * @param requestBody
+     * @returns any Feature flag set
      * @throws ApiError
      */
-    postApiV1AdminCleanupTransferPlans() {
+    postApiV1AdminSystemFeatureFlags(requestBody) {
         return this.httpRequest.request({
             method: 'POST',
-            url: '/api/v1/admin/cleanup/transfer-plans',
+            url: '/api/v1/admin/system/feature-flags',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Delete feature flag
+     * @param flag
+     * @returns any Feature flag deleted
+     * @throws ApiError
+     */
+    deleteApiV1AdminSystemFeatureFlags(flag) {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/admin/system/feature-flags/{flag}',
+            path: {
+                'flag': flag,
+            },
             errors: {
-                401: `Invalid or missing secret token`,
-                500: `Server error during cleanup`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
      * Clear fixture cache
-     * Clears all cached fixture data from Redis. Requires admin authentication.
-     * @returns any Cache cleared successfully
+     * @returns any Fixture cache cleared
      * @throws ApiError
      */
     deleteApiV1AdminCacheFixtures() {
@@ -64,16 +996,15 @@ class AdminService {
             method: 'DELETE',
             url: '/api/v1/admin/cache/fixtures',
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
      * Clear news cache
-     * Clears all cached news data from Redis. Requires admin authentication.
-     * @returns any Cache cleared successfully
+     * @returns any News cache cleared
      * @throws ApiError
      */
     deleteApiV1AdminCacheNews() {
@@ -81,16 +1012,15 @@ class AdminService {
             method: 'DELETE',
             url: '/api/v1/admin/cache/news',
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
      * Get cache statistics
-     * Retrieves statistics about the Redis cache including memory usage and key counts. Requires admin authentication.
-     * @returns any Cache statistics retrieved successfully
+     * @returns any Cache statistics
      * @throws ApiError
      */
     getApiV1AdminCacheStats() {
@@ -98,133 +1028,352 @@ class AdminService {
             method: 'GET',
             url: '/api/v1/admin/cache/stats',
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
-     * Check prediction details
-     * Retrieves detailed information about a prediction for debugging purposes, including comparison with actual fixture results. Requires admin authentication.
-     * @param id Prediction ID
-     * @returns any Prediction details retrieved successfully
+     * Manually trigger prediction resolution
+     * @returns any Prediction resolution job completed
      * @throws ApiError
      */
-    getApiV1AdminDiagnosticsPrediction(id) {
+    postApiV1AdminJobsResolvePredictions() {
         return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/diagnostics/prediction/{id}',
-            path: {
-                'id': id,
-            },
+            method: 'POST',
+            url: '/api/v1/admin/jobs/resolve-predictions',
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                404: `Prediction not found`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
-     * Trigger prediction resolution job
-     * Manually triggers the prediction resolution job to process and resolve pending predictions. Requires admin authentication.
-     * @returns any Prediction resolution job completed
+     * Check environment variables configuration
+     * @param includeDetails
+     * @returns any Environment check results
      * @throws ApiError
      */
-    postApiV1AdminJobsResolvePredictions() {
+    getApiV1AdminDiagnosticsEnv(includeDetails = false) {
         return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/admin/jobs/resolve-predictions',
+            method: 'GET',
+            url: '/api/v1/admin/diagnostics/env',
+            query: {
+                'includeDetails': includeDetails,
+            },
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
-     * Check environment configuration
-     * Validates environment variables and configuration. Returns status of required and optional environment variables. Requires admin authentication.
-     * @returns any Environment check completed
+     * Test API-Sports connection
+     * @param includeDetails
+     * @returns any API-Sports connection test result
      * @throws ApiError
      */
-    getApiV1AdminDiagnosticsEnv() {
+    getApiV1AdminDiagnosticsApiSports(includeDetails = false) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/admin/diagnostics/env',
+            url: '/api/v1/admin/diagnostics/api-sports',
+            query: {
+                'includeDetails': includeDetails,
+            },
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
-     * Test API-Sports connection
-     * Tests the connection to the API-Sports service and validates the API key. Requires admin authentication.
-     * @returns any API-Sports connection test successful
+     * Check prediction details (debugging)
+     * @param id
+     * @returns any Prediction diagnostic details
      * @throws ApiError
      */
-    getApiV1AdminDiagnosticsApiSports() {
+    getApiV1AdminDiagnosticsPrediction(id) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/admin/diagnostics/api-sports',
+            url: '/api/v1/admin/diagnostics/prediction/{id}',
+            path: {
+                'id': id,
+            },
             errors: {
-                401: `Unauthorized - authentication required or API key invalid`,
-                403: `Forbidden - admin access required`,
-                500: `Server error or API-Sports connection failed`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Prediction not found`,
+                500: `Internal server error`,
             },
         });
     }
     /**
      * Check API-Sports quota usage
-     * Retrieves current API quota usage statistics for the API-Sports service. Requires admin authentication.
-     * @returns any Quota information retrieved successfully
+     * @param includeDetails
+     * @returns any API quota usage
      * @throws ApiError
      */
-    getApiV1AdminDiagnosticsQuota() {
+    getApiV1AdminDiagnosticsQuota(includeDetails = false) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/admin/diagnostics/quota',
+            query: {
+                'includeDetails': includeDetails,
+            },
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
      * Check memory usage
-     * Retrieves current Node.js process memory usage statistics. Requires admin authentication.
-     * @returns any Memory usage statistics retrieved successfully
+     * @param includeDetails
+     * @returns any Memory usage statistics
      * @throws ApiError
      */
-    getApiV1AdminDiagnosticsMemory() {
+    getApiV1AdminDiagnosticsMemory(includeDetails = false) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/admin/diagnostics/memory',
+            query: {
+                'includeDetails': includeDetails,
+            },
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Server error`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
             },
         });
     }
     /**
      * Check database health
-     * Tests database connectivity, query performance, and connection pool status. Requires admin authentication.
-     * @returns any Database health check completed successfully
+     * @param includeDetails
+     * @returns any Database health check result
      * @throws ApiError
      */
-    getApiV1AdminDiagnosticsDatabase() {
+    getApiV1AdminDiagnosticsDatabase(includeDetails = false) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/admin/diagnostics/database',
+            query: {
+                'includeDetails': includeDetails,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * List all seasonal events
+     * @returns any Seasonal events list
+     * @throws ApiError
+     */
+    getApiV1AdminSeasonalEvents() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/seasonal-events',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Create seasonal event
+     * @param requestBody
+     * @returns any Seasonal event created
+     * @throws ApiError
+     */
+    postApiV1AdminSeasonalEvents(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/seasonal-events',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get seasonal event by ID
+     * @param id
+     * @returns any Seasonal event details
+     * @throws ApiError
+     */
+    getApiV1AdminSeasonalEvents1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/admin/seasonal-events/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Seasonal event not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Update seasonal event
+     * @param id
+     * @param requestBody
+     * @returns any Seasonal event updated
+     * @throws ApiError
+     */
+    putApiV1AdminSeasonalEvents(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/admin/seasonal-events/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Seasonal event not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Deactivate seasonal event
+     * @param id
+     * @returns any Seasonal event deactivated
+     * @throws ApiError
+     */
+    postApiV1AdminSeasonalEventsDeactivate(id) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/seasonal-events/{id}/deactivate',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Admin required`,
+                404: `Seasonal event not found`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Create a sponsored stake
+     * @param id
+     * @param requestBody
+     * @returns any Sponsored stake created
+     * @throws ApiError
+     */
+    postApiV1AdminSponsorsStake(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/sponsors/{id}/stake',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Create a sponsored pack
+     * @param id
+     * @param requestBody
+     * @returns any Sponsored pack created
+     * @throws ApiError
+     */
+    postApiV1AdminSponsorsPack(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/sponsors/{id}/pack',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+                401: `Unauthorized`,
+                403: `Admin required`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Cleanup anonymous lineups
+     * Soft deletes anonymous lineups older than 7 days and hard deletes soft-deleted lineups older than 30 days. Requires secret token authentication.
+     * @param requestBody
+     * @returns any Cleanup completed
+     * @throws ApiError
+     */
+    postApiV1AdminCleanupLineups(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/cleanup/lineups',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Cleanup anonymous tactics boards
+     * Soft deletes anonymous tactics boards older than 7 days and hard deletes soft-deleted tactics boards older than 30 days. Requires secret token authentication.
+     * @param requestBody
+     * @returns any Cleanup completed
+     * @throws ApiError
+     */
+    postApiV1AdminCleanupTacticsBoards(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/cleanup/tactics-boards',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Cleanup anonymous transfer plans
+     * Soft deletes anonymous transfer plans older than 7 days and hard deletes soft-deleted transfer plans older than 30 days. Requires secret token authentication.
+     * @param requestBody
+     * @returns any Cleanup completed
+     * @throws ApiError
+     */
+    postApiV1AdminCleanupTransferPlans(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/admin/cleanup/transfer-plans',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                401: `Unauthorized - authentication required`,
-                403: `Forbidden - admin access required`,
-                500: `Database connection error`,
+                401: `Unauthorized`,
+                500: `Internal server error`,
             },
         });
     }