@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/BingoPacksService.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BingoPacksService = void 0;
+class BingoPacksService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get available packs
+     * Retrieve all currently available bingo packs for purchase
+     * @returns any Available packs retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Packs() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/packs',
+            errors: {
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get user's purchased packs
+     * Retrieve all packs purchased by the authenticated user
+     * @returns any User packs retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PacksMyPacks() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/packs/my-packs',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get pack details
+     * Retrieve detailed information about a specific bingo pack
+     * @param id
+     * @returns any Pack details retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1Packs1(id) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/packs/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Pack not found`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Purchase a pack
+     * Purchase a bingo pack and auto-join all associated fixture games
+     * @param id
+     * @returns any Pack purchased successfully
+     * @throws ApiError
+     */
+    postApiV1PacksPurchase(id) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/packs/{id}/purchase',
+            path: {
+                'id': id,
+            },
+            errors: {
+                400: `Insufficient coins, pack not found, or validation error`,
+                401: `Authentication required`,
+                409: `Pack already purchased`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Get all packs including inactive (admin)
+     * Retrieve all bingo packs for admin management, including inactive ones
+     * @returns any All packs retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1PacksAdminAll() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/packs/admin/all',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Create pack (admin)
+     * Create a new bingo pack (admin only)
+     * @param requestBody
+     * @returns any Pack created successfully
+     * @throws ApiError
+     */
+    postApiV1PacksAdmin(requestBody) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/packs/admin',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+    /**
+     * Update pack (admin)
+     * Update an existing bingo pack (admin only)
+     * @param id
+     * @param requestBody
+     * @returns any Pack updated successfully
+     * @throws ApiError
+     */
+    patchApiV1PacksAdmin(id, requestBody) {
+        return this.httpRequest.request({
+            method: 'PATCH',
+            url: '/api/v1/packs/admin/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Authentication required`,
+                500: `Server error`,
+            },
+        });
+    }
+}
+exports.BingoPacksService = BingoPacksService;

package/dist/services/BingoService.d.ts

@@ -0,0 +1,403 @@
+import type { AutoStartGamesData } from '../models/AutoStartGamesData';
+import type { BoardExportData } from '../models/BoardExportData';
+import type { BoardPlaybackData } from '../models/BoardPlaybackData';
+import type { BoardShareUrlData } from '../models/BoardShareUrlData';
+import type { ClaimTileData } from '../models/ClaimTileData';
+import type { CreateGameData } from '../models/CreateGameData';
+import type { EndGameData } from '../models/EndGameData';
+import type { EventTypesData } from '../models/EventTypesData';
+import type { FeaturedGamesData } from '../models/FeaturedGamesData';
+import type { GameActivitiesData } from '../models/GameActivitiesData';
+import type { GameBySessionCodeData } from '../models/GameBySessionCodeData';
+import type { GameStateData } from '../models/GameStateData';
+import type { JoinGameData } from '../models/JoinGameData';
+import type { KickPlayerData } from '../models/KickPlayerData';
+import type { LeaderboardData } from '../models/LeaderboardData';
+import type { LeaveGameData } from '../models/LeaveGameData';
+import type { MarkTileData } from '../models/MarkTileData';
+import type { PlayerBoardData } from '../models/PlayerBoardData';
+import type { ReadyStatusData } from '../models/ReadyStatusData';
+import type { ReportEventData } from '../models/ReportEventData';
+import type { SeedDefaultGamesData } from '../models/SeedDefaultGamesData';
+import type { SharedBoardData } from '../models/SharedBoardData';
+import type { SimulateBulkEventsData } from '../models/SimulateBulkEventsData';
+import type { SimulateMatchEventData } from '../models/SimulateMatchEventData';
+import type { StartGameData } from '../models/StartGameData';
+import type { UserGamesData } from '../models/UserGamesData';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class BingoService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get all available bingo event types
+     * Returns all resolvable bingo events grouped by category for UI dropdowns
+     * @returns any List of event types grouped by category
+     * @throws ApiError
+     */
+    getApiV1BingoEventTypes(): CancelablePromise<{
+        success: boolean;
+        data: EventTypesData;
+        message?: string;
+    }>;
+    /**
+     * Get featured/public games for a fixture
+     * @param fixtureId
+     * @param limit
+     * @param status
+     * @returns any Featured games retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoFeaturedGames(fixtureId: string, limit?: number | null, status?: string): CancelablePromise<{
+        success: boolean;
+        data: FeaturedGamesData;
+        message?: string;
+    }>;
+    /**
+     * Create a new bingo game
+     * @param requestBody
+     * @returns any Game created successfully
+     * @throws ApiError
+     */
+    postApiV1BingoGames(requestBody?: {
+        matchId: (string | number);
+        boardSize?: number;
+        boardGeneration?: 'shuffle' | 'random';
+        eventPoolId: string | null;
+        customEvents?: Array<{
+            type: 'goal' | 'penalty_goal' | 'free_kick_goal' | 'own_goal' | 'yellow_card' | 'red_card' | 'second_yellow' | 'dissent_card' | 'time_wasting_card' | 'off_ball_card' | 'corner' | 'free_kick' | 'penalty_awarded' | 'throw_in' | 'assist' | 'shot_on_target' | 'shot_off_target' | 'save' | 'block' | 'substitution' | 'offside' | 'first_goal' | 'halftime_lead' | 'clean_sheet' | 'hat_trick';
+            target?: 'player' | 'team' | 'match';
+            playerId?: number;
+            playerName?: string;
+            teamId?: number;
+            teamName?: string;
+            condition?: {
+                minute?: number;
+                beforeMinute?: number;
+                afterMinute?: number;
+                half?: 'first' | 'second';
+                count?: number;
+            };
+            displayText: string;
+        }>;
+        maxPlayers?: number | null;
+        isPrivate?: boolean;
+        autoStart?: boolean;
+        isMultiplayer?: boolean;
+        gameType?: 'classic';
+        name?: string;
+        tags?: Array<string>;
+        entryFee?: number;
+        prizePool?: number;
+        prizeDistribution?: Array<{
+            position: number;
+            percentage: number;
+        }>;
+        sponsorId?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: CreateGameData;
+        message?: string;
+    }>;
+    /**
+     * Join game by session code or game ID
+     * @param requestBody
+     * @returns any Successfully joined game
+     * @throws ApiError
+     */
+    postApiV1BingoGamesJoin(requestBody?: {
+        sessionCode?: string;
+        gameId?: string;
+        fixtureId?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: JoinGameData;
+        message?: string;
+    }>;
+    /**
+     * Get my games
+     * @param status
+     * @param limit
+     * @param offset
+     * @returns any User games retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoGamesMe(status?: 'waiting' | 'inProgress' | 'finished' | 'all', limit?: number, offset?: number | null): CancelablePromise<{
+        success: boolean;
+        data: UserGamesData;
+        message?: string;
+    }>;
+    /**
+     * Get game by session code
+     * @param sessionCode
+     * @returns any Game retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoGamesCode(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: GameBySessionCodeData;
+        message?: string;
+    }>;
+    /**
+     * Update player ready status
+     * @param sessionCode
+     * @param requestBody
+     * @returns any Ready status updated successfully
+     * @throws ApiError
+     */
+    postApiV1BingoGamesReady(sessionCode: string, requestBody?: {
+        isReady: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: ReadyStatusData;
+        message?: string;
+    }>;
+    /**
+     * Start game (host only)
+     * @param sessionCode
+     * @returns any Game started successfully
+     * @throws ApiError
+     */
+    postApiV1BingoGamesStart(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: StartGameData;
+        message?: string;
+    }>;
+    /**
+     * Leave game
+     * @param sessionCode
+     * @returns any Successfully left game
+     * @throws ApiError
+     */
+    deleteApiV1BingoGamesCodeLeave(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: LeaveGameData;
+        message?: string;
+    }>;
+    /**
+     * Kick player (host only)
+     * @param sessionCode
+     * @param participationId
+     * @returns any Player kicked successfully
+     * @throws ApiError
+     */
+    deleteApiV1BingoGamesCodePlayersKick(sessionCode: string, participationId: string): CancelablePromise<{
+        success: boolean;
+        data: KickPlayerData;
+        message?: string;
+    }>;
+    /**
+     * Get player board
+     * @param sessionCode
+     * @returns any Player board retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoGamesCodeBoard(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: PlayerBoardData;
+        message?: string;
+    }>;
+    /**
+     * Mark tile on board
+     * @param sessionCode
+     * @param requestBody
+     * @returns any Tile marked successfully
+     * @throws ApiError
+     */
+    patchApiV1BingoGamesCodeBoardMark(sessionCode: string, requestBody?: {
+        tileIndex: number;
+    }): CancelablePromise<{
+        success: boolean;
+        data: MarkTileData;
+        message?: string;
+    }>;
+    /**
+     * Claim an auto-marked tile for bonus points
+     * @param sessionCode
+     * @param requestBody
+     * @returns any Tile claimed successfully
+     * @throws ApiError
+     */
+    postApiV1BingoGamesCodeBoardClaim(sessionCode: string, requestBody?: {
+        tileIndex: number;
+    }): CancelablePromise<{
+        success: boolean;
+        data: ClaimTileData;
+        message?: string;
+    }>;
+    /**
+     * Get game state
+     * @param sessionCode
+     * @returns any Game state retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoGamesCodeState(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: GameStateData;
+        message?: string;
+    }>;
+    /**
+     * End game
+     * @param sessionCode
+     * @returns any Game ended successfully
+     * @throws ApiError
+     */
+    postApiV1BingoGamesCodeEnd(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: EndGameData;
+        message?: string;
+    }>;
+    /**
+     * Get game activities
+     * @param sessionCode
+     * @param limit
+     * @param offset
+     * @returns any Activities retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoGamesCodeActivities(sessionCode: string, limit?: number, offset?: number | null): CancelablePromise<{
+        success: boolean;
+        data: GameActivitiesData;
+        message?: string;
+    }>;
+    /**
+     * Get game leaderboard
+     * @param sessionCode
+     * @returns any Leaderboard retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoGamesCodeLeaderboard(sessionCode: string): CancelablePromise<{
+        success: boolean;
+        data: LeaderboardData;
+        message?: string;
+    }>;
+    /**
+     * Report a missed event for a board
+     * @param boardId
+     * @param requestBody
+     * @returns any Event reported successfully
+     * @throws ApiError
+     */
+    postApiV1BingoBoardsReportEvent(boardId: string, requestBody?: {
+        reportType: 'tile_mark_request' | 'missed_event' | 'dispute';
+        tileIndex?: number;
+        eventType: string;
+        minute: number;
+        teamName?: string;
+        playerName?: string;
+        description?: string;
+        evidenceUrl?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: ReportEventData;
+        message?: string;
+    }>;
+    /**
+     * Get board playback
+     * @param boardId
+     * @returns any Playback data retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1BingoBoardsPlayback(boardId: string): CancelablePromise<{
+        success: boolean;
+        data: BoardPlaybackData;
+        message?: string;
+    }>;
+    /**
+     * Get shared bingo board
+     * @param shareToken
+     * @returns any Shared board data
+     * @throws ApiError
+     */
+    getApiV1BingoBoardsShare(shareToken: string): CancelablePromise<{
+        success: boolean;
+        data: SharedBoardData;
+        message?: string;
+    }>;
+    /**
+     * Get share URL for board
+     * @param boardId
+     * @returns any Share URL generated
+     * @throws ApiError
+     */
+    getApiV1BingoBoardsShare1(boardId: string): CancelablePromise<{
+        success: boolean;
+        data: BoardShareUrlData;
+        message?: string;
+    }>;
+    /**
+     * Export board data for image generation
+     * @param boardId
+     * @returns any Export data for image generation
+     * @throws ApiError
+     */
+    getApiV1BingoBoardsExport(boardId: string): CancelablePromise<{
+        success: boolean;
+        data: BoardExportData;
+        message?: string;
+    }>;
+    /**
+     * Manually trigger auto-start for games (admin)
+     * @returns any Auto-start triggered successfully
+     * @throws ApiError
+     */
+    postApiV1BingoAdminAutoStartGames(): CancelablePromise<{
+        success: boolean;
+        data: AutoStartGamesData;
+        message?: string;
+    }>;
+    /**
+     * Seed default global games (admin)
+     * @param requestBody
+     * @returns any Default games seeded successfully
+     * @throws ApiError
+     */
+    postApiV1BingoAdminSeedDefaultGames(requestBody?: {
+        dryRun?: boolean;
+        upsert?: boolean;
+    }): CancelablePromise<{
+        success: boolean;
+        data: SeedDefaultGamesData;
+        message?: string;
+    }>;
+    /**
+     * Simulate a match event (dev only)
+     * Test endpoint for simulating match events. Admin only, disabled in production.
+     * @param requestBody
+     * @returns any Event simulated successfully
+     * @throws ApiError
+     */
+    postApiV1BingoTestMatchEvent(requestBody?: {
+        fixtureId: string;
+        eventType: string;
+        minute: number;
+        eventDetail?: string;
+        playerName?: string;
+        teamName?: string;
+    }): CancelablePromise<{
+        success: boolean;
+        data: SimulateMatchEventData;
+        message?: string;
+    }>;
+    /**
+     * Simulate bulk match events (dev only)
+     * Test endpoint for simulating multiple match events. Admin only, disabled in production.
+     * @param requestBody
+     * @returns any Bulk events simulated successfully
+     * @throws ApiError
+     */
+    postApiV1BingoTestMatchEventsBulk(requestBody?: {
+        fixtureId: string;
+        events: Array<{
+            eventType: string;
+            minute: number;
+            eventDetail?: string;
+            playerName?: string;
+            teamName?: string;
+        }>;
+    }): CancelablePromise<{
+        success: boolean;
+        data: SimulateBulkEventsData;
+        message?: string;
+    }>;
+}