@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/ContentOddsService.d.ts

@@ -1,81 +1,95 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { BetsResponse } from '../models/BetsResponse';
+import type { BookmakersResponse } from '../models/BookmakersResponse';
+import type { LiveBetsResponse } from '../models/LiveBetsResponse';
+import type { LiveOddsResponse } from '../models/LiveOddsResponse';
+import type { OddsMappingResponse } from '../models/OddsMappingResponse';
+import type { OddsResponse } from '../models/OddsResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ContentOddsService {
     readonly httpRequest: BaseHttpRequest;
     constructor(httpRequest: BaseHttpRequest);
     /**
-     * Get live betting odds
-     * Retrieve real-time betting odds for live matches
-     * @param fixture Filter by fixture ID
-     * @param bookmaker Filter by bookmaker ID
-     * @param bet Filter by bet type ID
-     * @returns any Live odds retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1ContentOddsLive(fixture?: string, bookmaker?: string, bet?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<Record<string, any>>;
-    })>;
-    /**
-     * Get live bet types
-     * Retrieve available bet types for live matches
-     * @param fixture Filter by fixture ID
-     * @returns any Live bets retrieved successfully
+     * Get betting odds
+     * @param fixture
+     * @param league
+     * @param season
+     * @param page
+     * @param bookmaker
+     * @param bet
+     * @param date
+     * @param skipCache
+     * @returns any Odds retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsLiveBets(fixture?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<Record<string, any>>;
-    })>;
+    getApiV1ContentOdds(fixture?: string, league?: string, season?: string, page?: number, bookmaker?: string, bet?: string, date?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: OddsResponse;
+        message?: string;
+    }>;
     /**
-     * Get betting odds
-     * Retrieve betting odds for fixtures with optional filtering
-     * @param fixture Filter by fixture ID
-     * @param league Filter by league ID
-     * @param season Filter by season
-     * @param bookmaker Filter by bookmaker ID
-     * @param bet Filter by bet type ID
-     * @param date Filter by date (YYYY-MM-DD)
-     * @returns any Odds retrieved successfully
+     * Get live betting odds
+     * @param fixture
+     * @param league
+     * @param bet
+     * @param skipCache
+     * @returns any Live odds retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOdds(fixture?: string, league?: string, season?: string, bookmaker?: string, bet?: string, date?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<Record<string, any>>;
-    })>;
+    getApiV1ContentOddsLive(fixture?: string, league?: string, bet?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: LiveOddsResponse;
+        message?: string;
+    }>;
     /**
      * Get odds bet mapping
-     * Retrieve mapping of bet types and their IDs
+     * @param page
+     * @param skipCache
      * @returns any Odds mapping retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsMapping(): CancelablePromise<(ApiResponseDTO & {
-        data?: Record<string, any>;
-    })>;
+    getApiV1ContentOddsMapping(page?: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: OddsMappingResponse;
+        message?: string;
+    }>;
     /**
      * Get bookmakers
-     * Retrieve list of available bookmakers
-     * @param id Filter by bookmaker ID
-     * @param search Search bookmakers by name
+     * @param id
+     * @param search
+     * @param skipCache
      * @returns any Bookmakers retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsBookmakers(id?: string, search?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<{
-            id?: string;
-            name?: string;
-        }>;
-    })>;
+    getApiV1ContentOddsBookmakers(id?: number, search?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: BookmakersResponse;
+        message?: string;
+    }>;
     /**
      * Get bet types
-     * Retrieve list of available bet types and markets
-     * @param id Filter by bet type ID
-     * @param search Search bet types by name
+     * @param id
+     * @param search
+     * @param skipCache
      * @returns any Bet types retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsBets(id?: string, search?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<{
-            id?: string;
-            name?: string;
-        }>;
-    })>;
+    getApiV1ContentOddsBets(id?: number, search?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: BetsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get live bet types
+     * @param id
+     * @param search
+     * @param skipCache
+     * @returns any Live bets retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentOddsLiveBets(id?: number, search?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: LiveBetsResponse;
+        message?: string;
+    }>;
 }

package/dist/services/ContentOddsService.js

@@ -6,22 +6,31 @@ class ContentOddsService {
         this.httpRequest = httpRequest;
     }
     /**
-     * Get live betting odds
-     * Retrieve real-time betting odds for live matches
-     * @param fixture Filter by fixture ID
-     * @param bookmaker Filter by bookmaker ID
-     * @param bet Filter by bet type ID
-     * @returns any Live odds retrieved successfully
+     * Get betting odds
+     * @param fixture
+     * @param league
+     * @param season
+     * @param page
+     * @param bookmaker
+     * @param bet
+     * @param date
+     * @param skipCache
+     * @returns any Odds retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsLive(fixture, bookmaker, bet) {
+    getApiV1ContentOdds(fixture, league, season, page, bookmaker, bet, date, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/odds/live',
+            url: '/api/v1/content/odds',
             query: {
                 'fixture': fixture,
+                'league': league,
+                'season': season,
+                'page': page,
                 'bookmaker': bookmaker,
                 'bet': bet,
+                'date': date,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -29,18 +38,23 @@ class ContentOddsService {
         });
     }
     /**
-     * Get live bet types
-     * Retrieve available bet types for live matches
-     * @param fixture Filter by fixture ID
-     * @returns any Live bets retrieved successfully
+     * Get live betting odds
+     * @param fixture
+     * @param league
+     * @param bet
+     * @param skipCache
+     * @returns any Live odds retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsLiveBets(fixture) {
+    getApiV1ContentOddsLive(fixture, league, bet, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/odds/live-bets',
+            url: '/api/v1/content/odds/live',
             query: {
                 'fixture': fixture,
+                'league': league,
+                'bet': bet,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -48,28 +62,19 @@ class ContentOddsService {
         });
     }
     /**
-     * Get betting odds
-     * Retrieve betting odds for fixtures with optional filtering
-     * @param fixture Filter by fixture ID
-     * @param league Filter by league ID
-     * @param season Filter by season
-     * @param bookmaker Filter by bookmaker ID
-     * @param bet Filter by bet type ID
-     * @param date Filter by date (YYYY-MM-DD)
-     * @returns any Odds retrieved successfully
+     * Get odds bet mapping
+     * @param page
+     * @param skipCache
+     * @returns any Odds mapping retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOdds(fixture, league, season, bookmaker, bet, date) {
+    getApiV1ContentOddsMapping(page = 1, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/odds',
+            url: '/api/v1/content/odds/mapping',
             query: {
-                'fixture': fixture,
-                'league': league,
-                'season': season,
-                'bookmaker': bookmaker,
-                'bet': bet,
-                'date': date,
+                'page': page,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -77,35 +82,43 @@ class ContentOddsService {
         });
     }
     /**
-     * Get odds bet mapping
-     * Retrieve mapping of bet types and their IDs
-     * @returns any Odds mapping retrieved successfully
+     * Get bookmakers
+     * @param id
+     * @param search
+     * @param skipCache
+     * @returns any Bookmakers retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsMapping() {
+    getApiV1ContentOddsBookmakers(id, search, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/odds/mapping',
+            url: '/api/v1/content/odds/bookmakers',
+            query: {
+                'id': id,
+                'search': search,
+                'skipCache': skipCache,
+            },
             errors: {
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get bookmakers
-     * Retrieve list of available bookmakers
-     * @param id Filter by bookmaker ID
-     * @param search Search bookmakers by name
-     * @returns any Bookmakers retrieved successfully
+     * Get bet types
+     * @param id
+     * @param search
+     * @param skipCache
+     * @returns any Bet types retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsBookmakers(id, search) {
+    getApiV1ContentOddsBets(id, search, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/odds/bookmakers',
+            url: '/api/v1/content/odds/bets',
             query: {
                 'id': id,
                 'search': search,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -113,20 +126,21 @@ class ContentOddsService {
         });
     }
     /**
-     * Get bet types
-     * Retrieve list of available bet types and markets
-     * @param id Filter by bet type ID
-     * @param search Search bet types by name
-     * @returns any Bet types retrieved successfully
+     * Get live bet types
+     * @param id
+     * @param search
+     * @param skipCache
+     * @returns any Live bets retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentOddsBets(id, search) {
+    getApiV1ContentOddsLiveBets(id, search, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/odds/bets',
+            url: '/api/v1/content/odds/live/bets',
             query: {
                 'id': id,
                 'search': search,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,

package/dist/services/ContentPlayersService.d.ts

@@ -1,6 +1,7 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
-import type { PlayerDTO } from '../models/PlayerDTO';
-import type { PlayerStatisticsDTO } from '../models/PlayerStatisticsDTO';
+import type { PlayerHistoryResponse } from '../models/PlayerHistoryResponse';
+import type { PlayerSeasonsResponse } from '../models/PlayerSeasonsResponse';
+import type { PlayersResponse } from '../models/PlayersResponse';
+import type { PlayerStatisticsResponse } from '../models/PlayerStatisticsResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ContentPlayersService {
@@ -8,57 +9,56 @@ export declare class ContentPlayersService {
     constructor(httpRequest: BaseHttpRequest);
     /**
      * Get players
-     * Retrieve player information with optional filtering by team, league, or search
-     * @param id Filter by player ID
-     * @param team Filter by team ID
-     * @param league Filter by league ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param search Search players by name
-     * @param page Page number for pagination
+     * @param search
+     * @param player
+     * @param skipCache
      * @returns any Players retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayers(id?: string, team?: string, league?: string, season?: string, search?: string, page?: number): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<PlayerDTO>;
-    })>;
+    getApiV1ContentPlayers(search?: string, player?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: PlayersResponse;
+        message?: string;
+    }>;
     /**
      * Get player history
-     * Retrieve historical data for a player including past teams and transfers
-     * @param player Player ID
+     * @param player
+     * @param skipCache
      * @returns any Player history retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayersHistory(player: string): CancelablePromise<(ApiResponseDTO & {
-        data?: {
-            player?: PlayerDTO;
-            history?: Array<Record<string, any>>;
-        };
-    })>;
+    getApiV1ContentPlayersHistory(player: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: PlayerHistoryResponse;
+        message?: string;
+    }>;
     /**
      * Get player statistics
-     * Retrieve detailed statistics for a player including goals, assists, cards, and performance metrics
-     * @param id Player ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param league Filter by league ID
-     * @param team Filter by team ID
+     * @param id
+     * @param team
+     * @param league
+     * @param season
+     * @param page
+     * @param search
+     * @param skipCache
      * @returns any Player statistics retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayersStatistics(id: string, season?: string, league?: string, team?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: PlayerStatisticsDTO;
-    })>;
+    getApiV1ContentPlayersStatistics(id?: string, team?: string, league?: string, season?: string, page?: number, search?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: PlayerStatisticsResponse;
+        message?: string;
+    }>;
     /**
      * Get player seasons
-     * Retrieve all seasons where a player has data available
-     * @param player Player ID
+     * @param player
+     * @param skipCache
      * @returns any Player seasons retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayersSeasons(player: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<{
-            year?: string;
-            team?: string;
-            league?: string;
-        }>;
-    })>;
+    getApiV1ContentPlayersSeasons(player: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: PlayerSeasonsResponse;
+        message?: string;
+    }>;
 }

package/dist/services/ContentPlayersService.js

@@ -7,27 +7,20 @@ class ContentPlayersService {
     }
     /**
      * Get players
-     * Retrieve player information with optional filtering by team, league, or search
-     * @param id Filter by player ID
-     * @param team Filter by team ID
-     * @param league Filter by league ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param search Search players by name
-     * @param page Page number for pagination
+     * @param search
+     * @param player
+     * @param skipCache
      * @returns any Players retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayers(id, team, league, season, search, page = 1) {
+    getApiV1ContentPlayers(search, player, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/players',
             query: {
-                'id': id,
-                'team': team,
-                'league': league,
-                'season': season,
                 'search': search,
-                'page': page,
+                'player': player,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -36,17 +29,18 @@ class ContentPlayersService {
     }
     /**
      * Get player history
-     * Retrieve historical data for a player including past teams and transfers
-     * @param player Player ID
+     * @param player
+     * @param skipCache
      * @returns any Player history retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayersHistory(player) {
+    getApiV1ContentPlayersHistory(player, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/players/history',
             query: {
                 'player': player,
+                'skipCache': skipCache,
             },
             errors: {
                 400: `Missing player ID`,
@@ -56,23 +50,28 @@ class ContentPlayersService {
     }
     /**
      * Get player statistics
-     * Retrieve detailed statistics for a player including goals, assists, cards, and performance metrics
-     * @param id Player ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param league Filter by league ID
-     * @param team Filter by team ID
+     * @param id
+     * @param team
+     * @param league
+     * @param season
+     * @param page
+     * @param search
+     * @param skipCache
      * @returns any Player statistics retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayersStatistics(id, season, league, team) {
+    getApiV1ContentPlayersStatistics(id, team, league, season, page, search, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/players/statistics',
             query: {
                 'id': id,
-                'season': season,
-                'league': league,
                 'team': team,
+                'league': league,
+                'season': season,
+                'page': page,
+                'search': search,
+                'skipCache': skipCache,
             },
             errors: {
                 400: `Missing player ID`,
@@ -82,17 +81,18 @@ class ContentPlayersService {
     }
     /**
      * Get player seasons
-     * Retrieve all seasons where a player has data available
-     * @param player Player ID
+     * @param player
+     * @param skipCache
      * @returns any Player seasons retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentPlayersSeasons(player) {
+    getApiV1ContentPlayersSeasons(player, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/players/seasons',
             query: {
                 'player': player,
+                'skipCache': skipCache,
             },
             errors: {
                 400: `Missing player ID`,

package/dist/services/ContentRoundsService.d.ts

@@ -0,0 +1,22 @@
+import type { RoundsResponse } from '../models/RoundsResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ContentRoundsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get fixture rounds for a league and season
+     * @param league
+     * @param season
+     * @param current
+     * @param dates
+     * @param skipCache
+     * @returns any Rounds retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentRounds(league: number, season: number, current?: boolean | null, dates?: boolean | null, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: RoundsResponse;
+        message?: string;
+    }>;
+}

package/dist/services/ContentRoundsService.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentRoundsService = void 0;
+class ContentRoundsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get fixture rounds for a league and season
+     * @param league
+     * @param season
+     * @param current
+     * @param dates
+     * @param skipCache
+     * @returns any Rounds retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentRounds(league, season, current, dates, skipCache) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/rounds',
+            query: {
+                'league': league,
+                'season': season,
+                'current': current,
+                'dates': dates,
+                'skipCache': skipCache,
+            },
+            errors: {
+                400: `Missing required parameters`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentRoundsService = ContentRoundsService;

package/dist/services/ContentSeasonsService.d.ts

@@ -0,0 +1,17 @@
+import type { SeasonsResponse } from '../models/SeasonsResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ContentSeasonsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get all available seasons
+     * @returns any Seasons retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentSeasons(): CancelablePromise<{
+        success: boolean;
+        data: SeasonsResponse;
+        message?: string;
+    }>;
+}

package/dist/services/ContentSeasonsService.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentSeasonsService = void 0;
+class ContentSeasonsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Get all available seasons
+     * @returns any Seasons retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentSeasons() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/seasons',
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentSeasonsService = ContentSeasonsService;