@footballbingo/client 4.5.0 → 4.6.0

package/dist/services/AdminService.js

@@ -1,1381 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdminService = void 0;
-class AdminService {
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * 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
-     */
-    deleteApiV1AdminModerationComments(id) {
-        return this.httpRequest.request({
-            method: 'DELETE',
-            url: '/api/v1/admin/moderation/comments/{id}',
-            path: {
-                'id': id,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                404: `Comment not found`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * 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
-     */
-    postApiV1AdminSystemCacheClear(type) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/admin/system/cache/{type}/clear',
-            path: {
-                'type': type,
-            },
-            errors: {
-                400: `Bad request`,
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * 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
-     */
-    postApiV1AdminSystemFeatureFlags(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            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: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Clear fixture cache
-     * @returns any Fixture cache cleared
-     * @throws ApiError
-     */
-    deleteApiV1AdminCacheFixtures() {
-        return this.httpRequest.request({
-            method: 'DELETE',
-            url: '/api/v1/admin/cache/fixtures',
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Clear news cache
-     * @returns any News cache cleared
-     * @throws ApiError
-     */
-    deleteApiV1AdminCacheNews() {
-        return this.httpRequest.request({
-            method: 'DELETE',
-            url: '/api/v1/admin/cache/news',
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Get cache statistics
-     * @returns any Cache statistics
-     * @throws ApiError
-     */
-    getApiV1AdminCacheStats() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/cache/stats',
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Manually trigger prediction resolution
-     * @returns any Prediction resolution job completed
-     * @throws ApiError
-     */
-    postApiV1AdminJobsResolvePredictions() {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/admin/jobs/resolve-predictions',
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Check environment variables configuration
-     * @param includeDetails
-     * @returns any Environment check results
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsEnv(includeDetails = false) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/diagnostics/env',
-            query: {
-                'includeDetails': includeDetails,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Test API-Sports connection
-     * @param includeDetails
-     * @returns any API-Sports connection test result
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsApiSports(includeDetails = false) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/diagnostics/api-sports',
-            query: {
-                'includeDetails': includeDetails,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Check prediction details (debugging)
-     * @param id
-     * @returns any Prediction diagnostic details
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsPrediction(id) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/diagnostics/prediction/{id}',
-            path: {
-                'id': id,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                404: `Prediction not found`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Check API-Sports quota usage
-     * @param includeDetails
-     * @returns any API quota usage
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsQuota(includeDetails = false) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/diagnostics/quota',
-            query: {
-                'includeDetails': includeDetails,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Check memory usage
-     * @param includeDetails
-     * @returns any Memory usage statistics
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsMemory(includeDetails = false) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/admin/diagnostics/memory',
-            query: {
-                'includeDetails': includeDetails,
-            },
-            errors: {
-                401: `Unauthorized`,
-                403: `Admin required`,
-                500: `Internal server error`,
-            },
-        });
-    }
-    /**
-     * Check database health
-     * @param includeDetails
-     * @returns any Database health check result
-     * @throws ApiError
-     */
-    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`,
-                500: `Internal server error`,
-            },
-        });
-    }
-}
-exports.AdminService = AdminService;