@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/AdminService.d.ts

@@ -1,349 +1,930 @@
+import type { AdminAchievementStatsResponse } from '../models/AdminAchievementStatsResponse';
+import type { AdminAdjustBalanceResponse } from '../models/AdminAdjustBalanceResponse';
+import type { AdminArchiveGameTemplateResponse } from '../models/AdminArchiveGameTemplateResponse';
+import type { AdminBanUserResponse } from '../models/AdminBanUserResponse';
+import type { AdminBroadcastNotificationResponse } from '../models/AdminBroadcastNotificationResponse';
+import type { AdminCacheStatsResponse } from '../models/AdminCacheStatsResponse';
+import type { AdminChallengeStatsResponse } from '../models/AdminChallengeStatsResponse';
+import type { AdminCheckApiQuotaResponse } from '../models/AdminCheckApiQuotaResponse';
+import type { AdminCheckDatabaseResponse } from '../models/AdminCheckDatabaseResponse';
+import type { AdminCheckEnvironmentResponse } from '../models/AdminCheckEnvironmentResponse';
+import type { AdminCheckMemoryResponse } from '../models/AdminCheckMemoryResponse';
+import type { AdminCheckPredictionResponse } from '../models/AdminCheckPredictionResponse';
+import type { AdminCleanupResponse } from '../models/AdminCleanupResponse';
+import type { AdminClearCacheByTypeResponse } from '../models/AdminClearCacheByTypeResponse';
+import type { AdminClearCacheResponse } from '../models/AdminClearCacheResponse';
+import type { AdminCreateSponsoredPackResponse } from '../models/AdminCreateSponsoredPackResponse';
+import type { AdminCreateSponsoredStakeResponse } from '../models/AdminCreateSponsoredStakeResponse';
+import type { AdminDashboardResponse } from '../models/AdminDashboardResponse';
+import type { AdminDeactivateSeasonalEventResponse } from '../models/AdminDeactivateSeasonalEventResponse';
+import type { AdminDeleteCommentResponse } from '../models/AdminDeleteCommentResponse';
+import type { AdminDeleteFeatureFlagResponse } from '../models/AdminDeleteFeatureFlagResponse';
+import type { AdminEndSessionResponse } from '../models/AdminEndSessionResponse';
+import type { AdminEventLogResponse } from '../models/AdminEventLogResponse';
+import type { AdminEventReportByIdResponse } from '../models/AdminEventReportByIdResponse';
+import type { AdminEventReportsResponse } from '../models/AdminEventReportsResponse';
+import type { AdminEventReportStatsResponse } from '../models/AdminEventReportStatsResponse';
+import type { AdminEventStatsResponse } from '../models/AdminEventStatsResponse';
+import type { AdminEventTypesResponse } from '../models/AdminEventTypesResponse';
+import type { AdminFeatureFlagsResponse } from '../models/AdminFeatureFlagsResponse';
+import type { AdminGameTemplateResponse } from '../models/AdminGameTemplateResponse';
+import type { AdminImpersonateUserResponse } from '../models/AdminImpersonateUserResponse';
+import type { AdminJobStatusResponse } from '../models/AdminJobStatusResponse';
+import type { AdminListAchievementsResponse } from '../models/AdminListAchievementsResponse';
+import type { AdminListChallengesResponse } from '../models/AdminListChallengesResponse';
+import type { AdminListGameTemplatesResponse } from '../models/AdminListGameTemplatesResponse';
+import type { AdminListImpersonationsResponse } from '../models/AdminListImpersonationsResponse';
+import type { AdminListLiveSessionsResponse } from '../models/AdminListLiveSessionsResponse';
+import type { AdminListPredictionsResponse } from '../models/AdminListPredictionsResponse';
+import type { AdminListSeasonalEventsResponse } from '../models/AdminListSeasonalEventsResponse';
+import type { AdminModerationQueueResponse } from '../models/AdminModerationQueueResponse';
+import type { AdminNotificationLogResponse } from '../models/AdminNotificationLogResponse';
+import type { AdminNotificationStatsResponse } from '../models/AdminNotificationStatsResponse';
+import type { AdminPredictionStatsResponse } from '../models/AdminPredictionStatsResponse';
+import type { AdminResolvePredictionsForMatchResponse } from '../models/AdminResolvePredictionsForMatchResponse';
+import type { AdminReviewEventReportResponse } from '../models/AdminReviewEventReportResponse';
+import type { AdminRevokeImpersonationResponse } from '../models/AdminRevokeImpersonationResponse';
+import type { AdminSearchUsersResponse } from '../models/AdminSearchUsersResponse';
+import type { AdminSeasonalEventResponse } from '../models/AdminSeasonalEventResponse';
+import type { AdminSessionDetailsResponse } from '../models/AdminSessionDetailsResponse';
+import type { AdminSetAdminStatusResponse } from '../models/AdminSetAdminStatusResponse';
+import type { AdminSetFeatureFlagResponse } from '../models/AdminSetFeatureFlagResponse';
+import type { AdminTestApiSportsResponse } from '../models/AdminTestApiSportsResponse';
+import type { AdminTopUsersResponse } from '../models/AdminTopUsersResponse';
+import type { AdminTriggerResolvePredictionsResponse } from '../models/AdminTriggerResolvePredictionsResponse';
+import type { AdminUnbanUserResponse } from '../models/AdminUnbanUserResponse';
+import type { AdminUserDetailsResponse } from '../models/AdminUserDetailsResponse';
+import type { AdminUserGrowthResponse } from '../models/AdminUserGrowthResponse';
+import type { AdminUserWalletResponse } from '../models/AdminUserWalletResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class AdminService {
     readonly httpRequest: BaseHttpRequest;
     constructor(httpRequest: BaseHttpRequest);
     /**
-     * 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
-     * @throws ApiError
-     */
-    postApiV1AdminCleanupLineups(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of lineups soft-deleted
-             */
-            softDeleted?: number;
-            /**
-             * Number of lineups hard-deleted
-             */
-            hardDeleted?: number;
-            message?: string;
-        };
+     * 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?: {
+        userId: string;
+        type: 'xp' | 'coins';
+        amount: number;
+        reason: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminAdjustBalanceResponse;
+        message?: string;
     }>;
     /**
-     * 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
-     * @throws ApiError
-     */
-    postApiV1AdminCleanupTacticsBoards(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of tactics boards soft-deleted
-             */
-            softDeleted?: number;
-            /**
-             * Number of tactics boards hard-deleted
-             */
-            hardDeleted?: number;
-            message?: string;
-        };
+     * 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: string, limit?: number, offset?: number | null): CancelablePromise<{
+        success: boolean;
+        data: AdminUserWalletResponse;
+        message?: string;
     }>;
     /**
-     * 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
-     * @throws ApiError
-     */
-    postApiV1AdminCleanupTransferPlans(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of transfer plans soft-deleted
-             */
-            softDeleted?: number;
-            /**
-             * Number of transfer plans hard-deleted
-             */
-            hardDeleted?: number;
-            message?: string;
+     * Get dashboard stats overview
+     * @returns any Dashboard statistics
+     * @throws ApiError
+     */
+    getApiV1AdminDashboard(): CancelablePromise<{
+        success: boolean;
+        data: AdminDashboardResponse;
+        message?: string;
+    }>;
+    /**
+     * Get user growth data for charts
+     * @param days
+     * @returns any User growth data
+     * @throws ApiError
+     */
+    getApiV1AdminDashboardUserGrowth(days?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminUserGrowthResponse;
+        message?: string;
+    }>;
+    /**
+     * Get top users leaderboard
+     * @param limit
+     * @param sortBy
+     * @returns any Top users
+     * @throws ApiError
+     */
+    getApiV1AdminDashboardTopUsers(limit?: number, sortBy?: 'xp' | 'coins' | 'games'): CancelablePromise<{
+        success: boolean;
+        data: AdminTopUsersResponse;
+        message?: string;
+    }>;
+    /**
+     * 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?: string, offset?: number | null, limit?: number, sortBy?: 'createdAt' | 'xp' | 'coins' | 'lastLogin' | 'username', sortOrder?: 'asc' | 'desc', filter?: 'all' | 'premium' | 'banned' | 'admin' | 'guest'): CancelablePromise<{
+        success: boolean;
+        data: AdminSearchUsersResponse;
+        message?: string;
+    }>;
+    /**
+     * Get detailed user info
+     * @param userId
+     * @returns any User details
+     * @throws ApiError
+     */
+    getApiV1AdminUsers1(userId: string): CancelablePromise<{
+        success: boolean;
+        data: AdminUserDetailsResponse;
+        message?: string;
+    }>;
+    /**
+     * Ban a user
+     * @param userId
+     * @param requestBody
+     * @returns any User banned
+     * @throws ApiError
+     */
+    postApiV1AdminUsersBan(userId: string, requestBody?: {
+        reason?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminBanUserResponse;
+        message?: string;
+    }>;
+    /**
+     * Unban a user
+     * @param userId
+     * @returns any User unbanned
+     * @throws ApiError
+     */
+    postApiV1AdminUsersUnban(userId: string): CancelablePromise<{
+        success: boolean;
+        data: AdminUnbanUserResponse;
+        message?: string;
+    }>;
+    /**
+     * Set admin status
+     * @param userId
+     * @param requestBody
+     * @returns any Admin status updated
+     * @throws ApiError
+     */
+    postApiV1AdminUsersAdminStatus(userId: string, requestBody?: {
+        isAdmin: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminSetAdminStatusResponse;
+        message?: string;
+    }>;
+    /**
+     * Adjust user balance (coins/xp)
+     * @param userId
+     * @param requestBody
+     * @returns any Balance adjusted
+     * @throws ApiError
+     */
+    postApiV1AdminUsersBalance(userId: string, requestBody?: {
+        type: 'xp' | 'coins';
+        amount: number;
+        reason: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminAdjustBalanceResponse;
+        message?: string;
+    }>;
+    /**
+     * Impersonate a user (for debugging)
+     * @param userId
+     * @returns any Impersonation token generated
+     * @throws ApiError
+     */
+    postApiV1AdminUsersImpersonate(userId: string): CancelablePromise<{
+        success: boolean;
+        data: AdminImpersonateUserResponse;
+        message?: string;
+    }>;
+    /**
+     * List active impersonation sessions
+     * @returns any Active impersonation sessions
+     * @throws ApiError
+     */
+    getApiV1AdminImpersonations(): CancelablePromise<{
+        success: boolean;
+        data: AdminListImpersonationsResponse;
+        message?: string;
+    }>;
+    /**
+     * Revoke an impersonation token
+     * @param requestBody
+     * @returns any Impersonation token revoked
+     * @throws ApiError
+     */
+    postApiV1AdminImpersonationsRevoke(requestBody?: {
+        token: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminRevokeImpersonationResponse;
+        message?: string;
+    }>;
+    /**
+     * List all game templates
+     * @param includeArchived
+     * @param offset
+     * @param limit
+     * @returns any List of game templates
+     * @throws ApiError
+     */
+    getApiV1AdminGames(includeArchived?: boolean | null, offset?: number | null, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminListGameTemplatesResponse;
+        message?: string;
+    }>;
+    /**
+     * Create game template
+     * @param requestBody
+     * @returns any Game template created
+     * @throws ApiError
+     */
+    postApiV1AdminGames(requestBody?: {
+        name: string;
+        boardSize: number;
+        eventPoolId?: string;
+        gameType?: string;
+        isMultiplayer?: boolean;
+        isPrivate?: boolean;
+        maxPlayers?: number;
+        tags?: Array<string>;
+        entryFee?: number;
+        prizePool?: number;
+        isGlobalGame?: boolean;
+        sponsorId?: string;
+        prizeDistribution?: Array<{
+            position: number;
+            percentage: number;
+        }>;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminGameTemplateResponse;
+        message?: string;
+    }>;
+    /**
+     * Get single game template
+     * @param id
+     * @returns any Game template details
+     * @throws ApiError
+     */
+    getApiV1AdminGames1(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminGameTemplateResponse;
+        message?: string;
+    }>;
+    /**
+     * Update game template
+     * @param id
+     * @param requestBody
+     * @returns any Game template updated
+     * @throws ApiError
+     */
+    putApiV1AdminGames(id: string, requestBody?: {
+        name?: string;
+        boardSize?: number;
+        eventPoolId?: string;
+        gameType?: string;
+        isMultiplayer?: boolean;
+        isPrivate?: boolean;
+        maxPlayers?: number;
+        tags?: Array<string>;
+        entryFee?: number;
+        prizePool?: number;
+        isGlobalGame?: boolean;
+        sponsorId?: string;
+        prizeDistribution?: Array<{
+            position: number;
+            percentage: number;
+        }>;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminGameTemplateResponse;
+        message?: string;
+    }>;
+    /**
+     * Archive game template
+     * @param id
+     * @param requestBody
+     * @returns any Game template archived
+     * @throws ApiError
+     */
+    postApiV1AdminGamesArchive(id: string, requestBody?: {
+        reason?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminArchiveGameTemplateResponse;
+        message?: string;
+    }>;
+    /**
+     * List all live/active sessions
+     * @returns any Live sessions
+     * @throws ApiError
+     */
+    getApiV1AdminSessionsLive(): CancelablePromise<{
+        success: boolean;
+        data: AdminListLiveSessionsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get session details
+     * @param sessionCode
+     * @returns any Session details
+     * @throws ApiError
+     */
+    getApiV1AdminSessions(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: AdminSessionDetailsResponse;
+        message?: string;
+    }>;
+    /**
+     * Force end a session
+     * @param sessionCode
+     * @returns any Session ended
+     * @throws ApiError
+     */
+    postApiV1AdminSessionsEnd(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: AdminEndSessionResponse;
+        message?: string;
+    }>;
+    /**
+     * List all achievements
+     * @param category
+     * @param includeInactive
+     * @returns any Achievements list
+     * @throws ApiError
+     */
+    getApiV1AdminAchievements(category?: string, includeInactive?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: AdminListAchievementsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get achievement stats (unlock rate, etc.)
+     * @param id
+     * @returns any Achievement statistics
+     * @throws ApiError
+     */
+    getApiV1AdminAchievementsStats(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminAchievementStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * List all challenges
+     * @param type
+     * @param isActive
+     * @param offset
+     * @param limit
+     * @returns any Challenges list
+     * @throws ApiError
+     */
+    getApiV1AdminChallenges(type?: string, isActive?: boolean | null, offset?: number | null, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminListChallengesResponse;
+        message?: string;
+    }>;
+    /**
+     * Get challenge stats
+     * @param id
+     * @returns any Challenge statistics
+     * @throws ApiError
+     */
+    getApiV1AdminChallengesStats(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminChallengeStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * List predictions with filters
+     * @param fixtureId
+     * @param userId
+     * @param isResolved
+     * @param offset
+     * @param limit
+     * @returns any Predictions list
+     * @throws ApiError
+     */
+    getApiV1AdminPredictions(fixtureId?: string, userId?: string, isResolved?: boolean | null, offset?: number | null, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminListPredictionsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get prediction stats for a fixture
+     * @param fixtureId
+     * @returns any Prediction statistics for fixture
+     * @throws ApiError
+     */
+    getApiV1AdminPredictionsFixtureStats(fixtureId: string): CancelablePromise<{
+        success: boolean;
+        data: AdminPredictionStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * Manually resolve predictions for a fixture
+     * @param fixtureId
+     * @returns any Predictions resolved
+     * @throws ApiError
+     */
+    postApiV1AdminPredictionsFixtureResolve(fixtureId: string): CancelablePromise<{
+        success: boolean;
+        data: AdminResolvePredictionsForMatchResponse;
+        message?: string;
+    }>;
+    /**
+     * Get notification stats
+     * @returns any Notification statistics
+     * @throws ApiError
+     */
+    getApiV1AdminNotificationsStats(): CancelablePromise<{
+        success: boolean;
+        data: AdminNotificationStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get notification log
+     * @param type
+     * @param offset
+     * @param limit
+     * @returns any Notification log entries
+     * @throws ApiError
+     */
+    getApiV1AdminNotificationsLog(type?: string, offset?: number | null, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminNotificationLogResponse;
+        message?: string;
+    }>;
+    /**
+     * Broadcast notification to users
+     * @param requestBody
+     * @returns any Broadcast sent
+     * @throws ApiError
+     */
+    postApiV1AdminNotificationsBroadcast(requestBody?: {
+        title: string;
+        body: string;
+        data?: Record<string, string>;
+        filter?: {
+            premium?: boolean;
+            hasNotifications?: boolean;
         };
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminBroadcastNotificationResponse;
+        message?: string;
+    }>;
+    /**
+     * Get moderation queue (pending reports, flagged content)
+     * @returns any Moderation queue
+     * @throws ApiError
+     */
+    getApiV1AdminModerationQueue(): CancelablePromise<{
+        success: boolean;
+        data: AdminModerationQueueResponse;
+        message?: string;
+    }>;
+    /**
+     * Review an event report
+     * @param id
+     * @param requestBody
+     * @returns any Report reviewed
+     * @throws ApiError
+     */
+    postApiV1AdminModerationReportsReview(id: string, requestBody?: {
+        status: 'approved' | 'rejected';
+        notes?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminReviewEventReportResponse;
+        message?: string;
+    }>;
+    /**
+     * Delete a comment
+     * @param id
+     * @returns any Comment deleted
+     * @throws ApiError
+     */
+    deleteApiV1AdminModerationComments(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminDeleteCommentResponse;
+        message?: string;
+    }>;
+    /**
+     * 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?: string, userId?: string, startDate?: string, endDate?: string, offset?: number | null, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminEventLogResponse;
+        message?: string;
+    }>;
+    /**
+     * Get all event types with counts
+     * @returns any Event types with counts
+     * @throws ApiError
+     */
+    getApiV1AdminAnalyticsEventsTypes(): CancelablePromise<{
+        success: boolean;
+        data: AdminEventTypesResponse;
+        message?: string;
+    }>;
+    /**
+     * Get event stats aggregated by type and day
+     * @param days
+     * @returns any Aggregated event statistics
+     * @throws ApiError
+     */
+    getApiV1AdminAnalyticsEventsStats(days?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminEventStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * 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?: 'pending' | 'approved' | 'rejected', reportType?: string, fixtureId?: number | null, userId?: string, offset?: number | null, limit?: number): CancelablePromise<{
+        success: boolean;
+        data: AdminEventReportsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get event report stats
+     * @returns any Event report statistics
+     * @throws ApiError
+     */
+    getApiV1AdminEventReportsStats(): CancelablePromise<{
+        success: boolean;
+        data: AdminEventReportStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get single event report by ID
+     * @param id
+     * @returns any Event report details
+     * @throws ApiError
+     */
+    getApiV1AdminEventReports1(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminEventReportByIdResponse;
+        message?: string;
+    }>;
+    /**
+     * Get job status (last run times)
+     * @returns any Job status information
+     * @throws ApiError
+     */
+    getApiV1AdminSystemJobs(): CancelablePromise<{
+        success: boolean;
+        data: AdminJobStatusResponse;
+        message?: string;
+    }>;
+    /**
+     * Clear cache by type
+     * @param type
+     * @returns any Cache cleared
+     * @throws ApiError
+     */
+    postApiV1AdminSystemCacheClear(type: 'all' | 'fixtures' | 'news' | 'stats'): CancelablePromise<{
+        success: boolean;
+        data: AdminClearCacheByTypeResponse;
+        message?: string;
+    }>;
+    /**
+     * Get feature flags
+     * @returns any Feature flags
+     * @throws ApiError
+     */
+    getApiV1AdminSystemFeatureFlags(): CancelablePromise<{
+        success: boolean;
+        data: AdminFeatureFlagsResponse;
+        message?: string;
+    }>;
+    /**
+     * Set feature flag
+     * @param requestBody
+     * @returns any Feature flag set
+     * @throws ApiError
+     */
+    postApiV1AdminSystemFeatureFlags(requestBody?: {
+        flag: string;
+        enabled: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminSetFeatureFlagResponse;
+        message?: string;
+    }>;
+    /**
+     * Delete feature flag
+     * @param flag
+     * @returns any Feature flag deleted
+     * @throws ApiError
+     */
+    deleteApiV1AdminSystemFeatureFlags(flag: string): CancelablePromise<{
+        success: boolean;
+        data: AdminDeleteFeatureFlagResponse;
+        message?: string;
     }>;
     /**
      * 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(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            message?: string;
-            /**
-             * Number of cache keys deleted
-             */
-            keysDeleted?: number;
-        };
+        success: boolean;
+        data: AdminClearCacheResponse;
+        message?: string;
     }>;
     /**
      * 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(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            message?: string;
-            /**
-             * Number of cache keys deleted
-             */
-            keysDeleted?: number;
-        };
+        success: boolean;
+        data: AdminClearCacheResponse;
+        message?: string;
     }>;
     /**
      * 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(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Cache statistics including memory usage and key counts
-             */
-            stats?: {
-                totalKeys?: number;
-                memoryUsage?: string;
-                fixtureKeys?: number;
-                newsKeys?: number;
-            };
-        };
+        success: boolean;
+        data: AdminCacheStatsResponse;
+        message?: string;
     }>;
     /**
-     * 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: string): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * User's prediction details
-             */
-            prediction?: Record<string, any>;
-            /**
-             * Actual fixture results (if resolved)
-             */
-            fixtureActual?: Record<string, any> | null;
-            /**
-             * Comparison between prediction and actual results
-             */
-            comparison?: Record<string, any> | null;
-        };
+    postApiV1AdminJobsResolvePredictions(): CancelablePromise<{
+        success: boolean;
+        data: AdminTriggerResolvePredictionsResponse;
+        message?: string;
     }>;
     /**
-     * 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(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Number of fixtures processed
-             */
-            fixturesProcessed?: number;
-            /**
-             * Number of predictions resolved
-             */
-            predictionsResolved?: number;
-            /**
-             * Array of any errors encountered
-             */
-            errors?: Array<Record<string, any>>;
-            /**
-             * Job execution duration in milliseconds
-             */
-            duration?: number;
-            message?: string;
-        };
+    getApiV1AdminDiagnosticsEnv(includeDetails?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: AdminCheckEnvironmentResponse;
+        message?: string;
     }>;
     /**
-     * Check environment configuration
-     * Validates environment variables and configuration. Returns status of required and optional environment variables. Requires admin authentication.
-     * @returns any Environment check completed
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsEnv(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Current NODE_ENV value
-             */
-            environment?: string;
-            /**
-             * List of missing required environment variables
-             */
-            missingRequired?: Array<string>;
-            /**
-             * Status of all environment variables (with preview)
-             */
-            envVariables?: Record<string, {
-                set?: boolean;
-                length?: number;
-                preview?: string;
-            }>;
-            timestamp?: string;
-        };
+     * Test API-Sports connection
+     * @param includeDetails
+     * @returns any API-Sports connection test result
+     * @throws ApiError
+     */
+    getApiV1AdminDiagnosticsApiSports(includeDetails?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: AdminTestApiSportsResponse;
+        message?: string;
     }>;
     /**
-     * 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
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsApiSports(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            configured?: boolean;
-            apiKeySet?: boolean;
-            apiKeyLength?: number;
-            apiKeyPreview?: string;
-            responseStatus?: number;
-            responseTime?: string;
-            /**
-             * API status information from API-Sports
-             */
-            apiStatus?: Record<string, any>;
-            message?: string;
-        };
+     * Check prediction details (debugging)
+     * @param id
+     * @returns any Prediction diagnostic details
+     * @throws ApiError
+     */
+    getApiV1AdminDiagnosticsPrediction(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminCheckPredictionResponse;
+        message?: string;
     }>;
     /**
      * 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
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsQuota(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Overall quota status
-             */
-            status?: 'ok' | 'warning' | 'critical';
-            quota?: {
-                /**
-                 * Number of API calls used
-                 */
-                used?: number;
-                /**
-                 * Total API call limit
-                 */
-                limit?: number;
-                /**
-                 * Remaining API calls
-                 */
-                remaining?: number;
-                /**
-                 * Percentage of quota used
-                 */
-                percentUsed?: number;
-                /**
-                 * When the quota resets
-                 */
-                resetAt?: string;
-            };
-            /**
-             * Recommendations if quota is high
-             */
-            recommendations?: Array<string>;
-            timestamp?: string;
-        };
+     * @param includeDetails
+     * @returns any API quota usage
+     * @throws ApiError
+     */
+    getApiV1AdminDiagnosticsQuota(includeDetails?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: AdminCheckApiQuotaResponse;
+        message?: string;
     }>;
     /**
      * Check memory usage
-     * Retrieves current Node.js process memory usage statistics. Requires admin authentication.
-     * @returns any Memory usage statistics retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsMemory(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Overall memory status
-             */
-            status?: 'ok' | 'warning' | 'critical';
-            memory?: {
-                /**
-                 * Resident Set Size (total memory)
-                 */
-                rss?: string;
-                /**
-                 * Total heap allocated
-                 */
-                heapTotal?: string;
-                /**
-                 * Heap actually used
-                 */
-                heapUsed?: string;
-                /**
-                 * Percentage of heap used
-                 */
-                heapUsedPercent?: string;
-                /**
-                 * C++ objects bound to JavaScript
-                 */
-                external?: string;
-                /**
-                 * ArrayBuffer and SharedArrayBuffer memory
-                 */
-                arrayBuffers?: string;
-            };
-            /**
-             * Recommendations if memory usage is high
-             */
-            recommendations?: Array<string>;
-            timestamp?: string;
-        };
+     * @param includeDetails
+     * @returns any Memory usage statistics
+     * @throws ApiError
+     */
+    getApiV1AdminDiagnosticsMemory(includeDetails?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: AdminCheckMemoryResponse;
+        message?: string;
     }>;
     /**
      * Check database health
-     * Tests database connectivity, query performance, and connection pool status. Requires admin authentication.
-     * @returns any Database health check completed successfully
-     * @throws ApiError
-     */
-    getApiV1AdminDiagnosticsDatabase(): CancelablePromise<{
-        success?: boolean;
-        data?: {
-            /**
-             * Overall database health status
-             */
-            status?: 'healthy' | 'warning' | 'slow';
-            database?: {
-                connected?: boolean;
-                /**
-                 * Time taken for simple health query
-                 */
-                simpleQuery?: string;
-                /**
-                 * Time taken for user count query
-                 */
-                userCountQuery?: string;
-                /**
-                 * Total time for all health checks
-                 */
-                totalDuration?: string;
-                userCount?: number;
-            };
-            /**
-             * Database connection pool statistics
-             */
-            connectionPool?: Record<string, any>;
-            slowQueryThreshold?: string;
-            /**
-             * Recommendations if database is slow
-             */
-            recommendations?: Array<string>;
-            timestamp?: string;
-        };
+     * @param includeDetails
+     * @returns any Database health check result
+     * @throws ApiError
+     */
+    getApiV1AdminDiagnosticsDatabase(includeDetails?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: AdminCheckDatabaseResponse;
+        message?: string;
+    }>;
+    /**
+     * List all seasonal events
+     * @returns any Seasonal events list
+     * @throws ApiError
+     */
+    getApiV1AdminSeasonalEvents(): CancelablePromise<{
+        success: boolean;
+        data: AdminListSeasonalEventsResponse;
+        message?: string;
+    }>;
+    /**
+     * Create seasonal event
+     * @param requestBody
+     * @returns any Seasonal event created
+     * @throws ApiError
+     */
+    postApiV1AdminSeasonalEvents(requestBody?: {
+        name: string;
+        theme: string;
+        bannerUrl?: string;
+        communityId?: string;
+        metadata?: Record<string, (string | number | boolean)>;
+        isActive?: boolean;
+        startsAt?: string;
+        endsAt?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminSeasonalEventResponse;
+        message?: string;
+    }>;
+    /**
+     * Get seasonal event by ID
+     * @param id
+     * @returns any Seasonal event details
+     * @throws ApiError
+     */
+    getApiV1AdminSeasonalEvents1(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminSeasonalEventResponse;
+        message?: string;
+    }>;
+    /**
+     * Update seasonal event
+     * @param id
+     * @param requestBody
+     * @returns any Seasonal event updated
+     * @throws ApiError
+     */
+    putApiV1AdminSeasonalEvents(id: string, requestBody?: {
+        name?: string;
+        theme?: string;
+        bannerUrl?: string | null;
+        communityId?: string | null;
+        metadata?: Record<string, (string | number | boolean)> | null;
+        isActive?: boolean;
+        startsAt?: string | null;
+        endsAt?: string | null;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminSeasonalEventResponse;
+        message?: string;
+    }>;
+    /**
+     * Deactivate seasonal event
+     * @param id
+     * @returns any Seasonal event deactivated
+     * @throws ApiError
+     */
+    postApiV1AdminSeasonalEventsDeactivate(id: string): CancelablePromise<{
+        success: boolean;
+        data: AdminDeactivateSeasonalEventResponse;
+        message?: string;
+    }>;
+    /**
+     * Create a sponsored stake
+     * @param id
+     * @param requestBody
+     * @returns any Sponsored stake created
+     * @throws ApiError
+     */
+    postApiV1AdminSponsorsStake(id: string, requestBody?: {
+        fixtureId: string;
+        predictionType: string;
+        predictionText: string;
+        predictionData?: Record<string, (string | number | boolean)>;
+        coinAmount: number;
+        maxAcceptors?: number;
+        closesAt: string;
+        expiresAt?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminCreateSponsoredStakeResponse;
+        message?: string;
+    }>;
+    /**
+     * Create a sponsored pack
+     * @param id
+     * @param requestBody
+     * @returns any Sponsored pack created
+     * @throws ApiError
+     */
+    postApiV1AdminSponsorsPack(id: string, requestBody?: {
+        name: string;
+        description?: string;
+        fixtureIds: Array<string>;
+        gameId: string;
+        coinCost: number;
+        discount?: number;
+        validFrom: string;
+        validTo: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminCreateSponsoredPackResponse;
+        message?: string;
+    }>;
+    /**
+     * 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?: {
+        daysOld?: number;
+        dryRun?: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminCleanupResponse;
+        message?: string;
+    }>;
+    /**
+     * 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?: {
+        daysOld?: number;
+        dryRun?: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminCleanupResponse;
+        message?: string;
+    }>;
+    /**
+     * 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?: {
+        daysOld?: number;
+        dryRun?: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: AdminCleanupResponse;
+        message?: string;
     }>;
 }