@footballbingo/client 4.4.0 → 4.5.1

package/dist/services/EventPoolsService.d.ts

@@ -1,115 +0,0 @@
-import type { CreateEventPoolData } from '../models/CreateEventPoolData';
-import type { DeleteEventPoolData } from '../models/DeleteEventPoolData';
-import type { GetEventPoolData } from '../models/GetEventPoolData';
-import type { ListEventPoolsData } from '../models/ListEventPoolsData';
-import type { UpdateEventPoolData } from '../models/UpdateEventPoolData';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import type { BaseHttpRequest } from '../core/BaseHttpRequest';
-export declare class EventPoolsService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * List event pools
-     * Retrieve all available event pools
-     * @returns any Event pools retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1EventPools(): CancelablePromise<{
-        success: boolean;
-        data: ListEventPoolsData;
-        message?: string;
-    }>;
-    /**
-     * Create event pool
-     * Create a new custom event pool for bingo games
-     * @param requestBody
-     * @returns any Event pool created successfully
-     * @throws ApiError
-     */
-    postApiV1EventPools(requestBody?: {
-        name: string;
-        description?: string;
-        type?: 'basic' | 'expert' | 'advanced' | 'custom';
-        tags?: Array<string>;
-        events: Array<(string | {
-            baseEventId: string;
-            displayText: string;
-            target?: 'player' | 'team';
-            playerName?: string;
-            teamName?: string;
-            condition?: {
-                beforeMinute?: number;
-                afterMinute?: number;
-                half?: 'first' | 'second';
-            };
-        })>;
-        difficulty?: 'Beginner' | 'Intermediate' | 'Expert';
-        icon?: string;
-        minBoardSize?: number;
-        isActive?: boolean;
-        isSystem?: boolean;
-    }): CancelablePromise<{
-        success: boolean;
-        data: CreateEventPoolData;
-        message?: string;
-    }>;
-    /**
-     * Get event pool by ID
-     * Retrieve detailed information about a specific event pool
-     * @param id
-     * @returns any Event pool retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1EventPools1(id: string): CancelablePromise<{
-        success: boolean;
-        data: GetEventPoolData;
-        message?: string;
-    }>;
-    /**
-     * Update event pool
-     * Update an existing event pool (admin only)
-     * @param id
-     * @param requestBody
-     * @returns any Event pool updated successfully
-     * @throws ApiError
-     */
-    putApiV1EventPools(id: string, requestBody?: {
-        name?: string;
-        description?: string;
-        type?: 'basic' | 'expert' | 'advanced' | 'custom';
-        tags?: Array<string>;
-        events?: Array<(string | {
-            baseEventId: string;
-            displayText: string;
-            target?: 'player' | 'team';
-            playerName?: string;
-            teamName?: string;
-            condition?: {
-                beforeMinute?: number;
-                afterMinute?: number;
-                half?: 'first' | 'second';
-            };
-        })>;
-        difficulty?: 'Beginner' | 'Intermediate' | 'Expert';
-        icon?: string;
-        minBoardSize?: number;
-        isActive?: boolean;
-        isSystem?: boolean;
-    }): CancelablePromise<{
-        success: boolean;
-        data: UpdateEventPoolData;
-        message?: string;
-    }>;
-    /**
-     * Delete event pool
-     * Delete an event pool (admin only, soft delete)
-     * @param id
-     * @returns any Event pool deleted successfully
-     * @throws ApiError
-     */
-    deleteApiV1EventPools(id: string): CancelablePromise<{
-        success: boolean;
-        data: DeleteEventPoolData;
-        message?: string;
-    }>;
-}

package/dist/services/EventPoolsService.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventPoolsService = void 0;
-class EventPoolsService {
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * List event pools
-     * Retrieve all available event pools
-     * @returns any Event pools retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1EventPools() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/event-pools',
-            errors: {
-                500: `Server error`,
-            },
-        });
-    }
-    /**
-     * Create event pool
-     * Create a new custom event pool for bingo games
-     * @param requestBody
-     * @returns any Event pool created successfully
-     * @throws ApiError
-     */
-    postApiV1EventPools(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/event-pools',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Invalid input or insufficient events`,
-                401: `Authentication required`,
-                500: `Server error`,
-            },
-        });
-    }
-    /**
-     * Get event pool by ID
-     * Retrieve detailed information about a specific event pool
-     * @param id
-     * @returns any Event pool retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1EventPools1(id) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/event-pools/{id}',
-            path: {
-                'id': id,
-            },
-            errors: {
-                404: `Event pool not found`,
-                500: `Server error`,
-            },
-        });
-    }
-    /**
-     * Update event pool
-     * Update an existing event pool (admin only)
-     * @param id
-     * @param requestBody
-     * @returns any Event pool updated successfully
-     * @throws ApiError
-     */
-    putApiV1EventPools(id, requestBody) {
-        return this.httpRequest.request({
-            method: 'PUT',
-            url: '/api/v1/event-pools/{id}',
-            path: {
-                'id': id,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Invalid input`,
-                401: `Authentication required`,
-                404: `Event pool not found`,
-                500: `Server error`,
-            },
-        });
-    }
-    /**
-     * Delete event pool
-     * Delete an event pool (admin only, soft delete)
-     * @param id
-     * @returns any Event pool deleted successfully
-     * @throws ApiError
-     */
-    deleteApiV1EventPools(id) {
-        return this.httpRequest.request({
-            method: 'DELETE',
-            url: '/api/v1/event-pools/{id}',
-            path: {
-                'id': id,
-            },
-            errors: {
-                401: `Authentication required`,
-                404: `Event pool not found`,
-                500: `Server error`,
-            },
-        });
-    }
-}
-exports.EventPoolsService = EventPoolsService;

package/dist/services/FlashPredictionsService.d.ts

@@ -1,214 +0,0 @@
-import type { ActiveFlashResponse } from '../models/ActiveFlashResponse';
-import type { FlashHistoryItem } from '../models/FlashHistoryItem';
-import type { FlashHistoryMeItem } from '../models/FlashHistoryMeItem';
-import type { FlashLeaderboardEntry } from '../models/FlashLeaderboardEntry';
-import type { FlashPlayersResponse } from '../models/FlashPlayersResponse';
-import type { FlashSession } from '../models/FlashSession';
-import type { FlashSessionsResponse } from '../models/FlashSessionsResponse';
-import type { FlashSessionSummary } from '../models/FlashSessionSummary';
-import type { FlashStatsResponse } from '../models/FlashStatsResponse';
-import type { QuickPicksResponse } from '../models/QuickPicksResponse';
-import type { ResolveFlashResponse } from '../models/ResolveFlashResponse';
-import type { SubmitAnswerResponse } from '../models/SubmitAnswerResponse';
-import type { SubmitQuickPicksResponse } from '../models/SubmitQuickPicksResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import type { BaseHttpRequest } from '../core/BaseHttpRequest';
-export declare class FlashPredictionsService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Get active flash predictions for a fixture
-     * @param fixtureId
-     * @returns any Active flash predictions
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashActive(fixtureId: string): CancelablePromise<{
-        success: boolean;
-        data: ActiveFlashResponse;
-        message?: string;
-    }>;
-    /**
-     * Get resolved flash predictions for a fixture
-     * @param fixtureId
-     * @param limit
-     * @param offset
-     * @returns any Resolved flash predictions
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashHistory(fixtureId: string, limit?: number, offset?: number | null): CancelablePromise<{
-        success: boolean;
-        data: {
-            items: Array<FlashHistoryItem>;
-            pagination: {
-                total: number;
-                limit: number;
-                offset: number;
-                hasMore: boolean;
-            };
-        };
-        message?: string;
-    }>;
-    /**
-     * Get user's flash prediction stats
-     * @returns any User flash stats
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashStats(): CancelablePromise<{
-        success: boolean;
-        data: FlashStatsResponse;
-        message?: string;
-    }>;
-    /**
-     * Get flash session summary for a fixture
-     * @param fixtureId
-     * @returns any Flash session summary
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashSummary(fixtureId: string): CancelablePromise<{
-        success: boolean;
-        data: FlashSessionSummary;
-        message?: string;
-    }>;
-    /**
-     * Submit answer to a flash prediction
-     * @param id
-     * @param requestBody
-     * @returns any Answer submitted
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashAnswer(id: string, requestBody?: {
-        answer: string;
-    }): CancelablePromise<{
-        success: boolean;
-        data: SubmitAnswerResponse;
-        message?: string;
-    }>;
-    /**
-     * Resolve a flash prediction (admin)
-     * @param id
-     * @param requestBody
-     * @returns any Flash prediction resolved
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashResolve(id: string, requestBody?: {
-        correctAnswer: string;
-    }): CancelablePromise<{
-        success: boolean;
-        data: ResolveFlashResponse;
-        message?: string;
-    }>;
-    /**
-     * Get user's active flash play sessions
-     * @returns any User flash sessions
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashSessions(): CancelablePromise<{
-        success: boolean;
-        data: FlashSessionsResponse;
-        message?: string;
-    }>;
-    /**
-     * Get active player count for a fixture
-     * @param fixtureId
-     * @returns any Player count
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashPlayers(fixtureId: string): CancelablePromise<{
-        success: boolean;
-        data: FlashPlayersResponse;
-        message?: string;
-    }>;
-    /**
-     * Get flash prediction leaderboard for a fixture
-     * @param fixtureId
-     * @param limit
-     * @param offset
-     * @returns any Flash leaderboard
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashLeaderboard(fixtureId: string, limit?: number, offset?: number | null): CancelablePromise<{
-        success: boolean;
-        data: {
-            items: Array<FlashLeaderboardEntry>;
-            pagination: {
-                total: number;
-                limit: number;
-                offset: number;
-                hasMore: boolean;
-            };
-        };
-    }>;
-    /**
-     * Get user's flash prediction history
-     * @param limit
-     * @param offset
-     * @returns any User flash prediction history
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashHistoryMe(limit?: number, offset?: number | null): CancelablePromise<{
-        success: boolean;
-        data: {
-            items: Array<FlashHistoryMeItem>;
-            pagination: {
-                total: number;
-                limit: number;
-                offset: number;
-                hasMore: boolean;
-            };
-        };
-    }>;
-    /**
-     * Join a flash play session for a fixture
-     * @param requestBody
-     * @returns any Joined flash session
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashJoin(requestBody?: {
-        fixtureId: string;
-    }): CancelablePromise<{
-        success: boolean;
-        data: FlashSession;
-        message?: string;
-    }>;
-    /**
-     * Leave a flash play session for a fixture
-     * @param requestBody
-     * @returns any Left flash session
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashLeave(requestBody?: {
-        fixtureId: string;
-    }): CancelablePromise<{
-        success: boolean;
-        data: any;
-        message?: string;
-    }>;
-    /**
-     * Get pre-match quick pick options
-     * @param fixtureId
-     * @returns any Quick pick options
-     * @throws ApiError
-     */
-    getApiV1PredictionsQuickPicks(fixtureId: string): CancelablePromise<{
-        success: boolean;
-        data: QuickPicksResponse;
-        message?: string;
-    }>;
-    /**
-     * Submit quick pick predictions
-     * @param requestBody
-     * @returns any Quick picks submitted
-     * @throws ApiError
-     */
-    postApiV1PredictionsQuickPicks(requestBody?: {
-        fixtureId: string;
-        picks: Array<{
-            pickId: string;
-            answer: string;
-        }>;
-    }): CancelablePromise<{
-        success: boolean;
-        data: SubmitQuickPicksResponse;
-        message?: string;
-    }>;
-}

package/dist/services/FlashPredictionsService.js

@@ -1,267 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlashPredictionsService = void 0;
-class FlashPredictionsService {
-    constructor(httpRequest) {
-        this.httpRequest = httpRequest;
-    }
-    /**
-     * Get active flash predictions for a fixture
-     * @param fixtureId
-     * @returns any Active flash predictions
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashActive(fixtureId) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/active',
-            query: {
-                'fixtureId': fixtureId,
-            },
-            errors: {
-                400: `fixtureId required`,
-            },
-        });
-    }
-    /**
-     * Get resolved flash predictions for a fixture
-     * @param fixtureId
-     * @param limit
-     * @param offset
-     * @returns any Resolved flash predictions
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashHistory(fixtureId, limit = 20, offset) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/history',
-            query: {
-                'fixtureId': fixtureId,
-                'limit': limit,
-                'offset': offset,
-            },
-            errors: {
-                400: `fixtureId required`,
-            },
-        });
-    }
-    /**
-     * Get user's flash prediction stats
-     * @returns any User flash stats
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashStats() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/stats',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get flash session summary for a fixture
-     * @param fixtureId
-     * @returns any Flash session summary
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashSummary(fixtureId) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/summary',
-            query: {
-                'fixtureId': fixtureId,
-            },
-            errors: {
-                400: `fixtureId required`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Submit answer to a flash prediction
-     * @param id
-     * @param requestBody
-     * @returns any Answer submitted
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashAnswer(id, requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/predictions/flash/{id}/answer',
-            path: {
-                'id': id,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Already answered or window closed`,
-                401: `Unauthorized`,
-                404: `Flash prediction not found`,
-            },
-        });
-    }
-    /**
-     * Resolve a flash prediction (admin)
-     * @param id
-     * @param requestBody
-     * @returns any Flash prediction resolved
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashResolve(id, requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/predictions/flash/{id}/resolve',
-            path: {
-                'id': id,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Already resolved`,
-                401: `Unauthorized`,
-                404: `Flash prediction not found`,
-            },
-        });
-    }
-    /**
-     * Get user's active flash play sessions
-     * @returns any User flash sessions
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashSessions() {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/sessions',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get active player count for a fixture
-     * @param fixtureId
-     * @returns any Player count
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashPlayers(fixtureId) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/players/{fixtureId}',
-            path: {
-                'fixtureId': fixtureId,
-            },
-        });
-    }
-    /**
-     * Get flash prediction leaderboard for a fixture
-     * @param fixtureId
-     * @param limit
-     * @param offset
-     * @returns any Flash leaderboard
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashLeaderboard(fixtureId, limit = 20, offset) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/leaderboard/{fixtureId}',
-            path: {
-                'fixtureId': fixtureId,
-            },
-            query: {
-                'limit': limit,
-                'offset': offset,
-            },
-        });
-    }
-    /**
-     * Get user's flash prediction history
-     * @param limit
-     * @param offset
-     * @returns any User flash prediction history
-     * @throws ApiError
-     */
-    getApiV1PredictionsFlashHistoryMe(limit = 20, offset) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/flash/history/me',
-            query: {
-                'limit': limit,
-                'offset': offset,
-            },
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Join a flash play session for a fixture
-     * @param requestBody
-     * @returns any Joined flash session
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashJoin(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/predictions/flash/join',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `fixtureId required`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Leave a flash play session for a fixture
-     * @param requestBody
-     * @returns any Left flash session
-     * @throws ApiError
-     */
-    postApiV1PredictionsFlashLeave(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/predictions/flash/leave',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `fixtureId required`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * Get pre-match quick pick options
-     * @param fixtureId
-     * @returns any Quick pick options
-     * @throws ApiError
-     */
-    getApiV1PredictionsQuickPicks(fixtureId) {
-        return this.httpRequest.request({
-            method: 'GET',
-            url: '/api/v1/predictions/quick-picks/{fixtureId}',
-            path: {
-                'fixtureId': fixtureId,
-            },
-        });
-    }
-    /**
-     * Submit quick pick predictions
-     * @param requestBody
-     * @returns any Quick picks submitted
-     * @throws ApiError
-     */
-    postApiV1PredictionsQuickPicks(requestBody) {
-        return this.httpRequest.request({
-            method: 'POST',
-            url: '/api/v1/predictions/quick-picks',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `Invalid input`,
-                401: `Unauthorized`,
-            },
-        });
-    }
-}
-exports.FlashPredictionsService = FlashPredictionsService;