@footballbingo/client 1.0.0 → 2.0.0

package/dist/services/ContentStandingsService.d.ts

@@ -1,5 +1,4 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
-import type { StandingsDTO } from '../models/StandingsDTO';
+import type { StandingsResponse } from '../models/StandingsResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ContentStandingsService {
@@ -7,14 +6,17 @@ export declare class ContentStandingsService {
     constructor(httpRequest: BaseHttpRequest);
     /**
      * Get league standings
-     * Retrieve league table standings with team rankings, points, and form
-     * @param league League ID
-     * @param season Season year (e.g., '2024')
-     * @param team Filter by specific team ID
+     * @param league
+     * @param season
+     * @param team
+     * @param live
+     * @param skipCache
      * @returns any Standings retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStandings(league: string, season: string, team?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: StandingsDTO;
-    })>;
+    getApiV1ContentStandings(league?: number, season?: string, team?: number, live?: boolean | null, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: StandingsResponse;
+        message?: string;
+    }>;
 }

package/dist/services/ContentStandingsService.js

@@ -7,14 +7,15 @@ class ContentStandingsService {
     }
     /**
      * Get league standings
-     * Retrieve league table standings with team rankings, points, and form
-     * @param league League ID
-     * @param season Season year (e.g., '2024')
-     * @param team Filter by specific team ID
+     * @param league
+     * @param season
+     * @param team
+     * @param live
+     * @param skipCache
      * @returns any Standings retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStandings(league, season, team) {
+    getApiV1ContentStandings(league, season, team, live, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/standings',
@@ -22,6 +23,8 @@ class ContentStandingsService {
                 'league': league,
                 'season': season,
                 'team': team,
+                'live': live,
+                'skipCache': skipCache,
             },
             errors: {
                 400: `Missing required parameters`,

package/dist/services/ContentStatisticsService.d.ts

@@ -1,51 +1,54 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
-import type { PlayerDTO } from '../models/PlayerDTO';
+import type { InjuriesResponse } from '../models/InjuriesResponse';
+import type { SidelinedResponse } from '../models/SidelinedResponse';
+import type { StatsByTypeResponse } from '../models/StatsByTypeResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ContentStatisticsService {
     readonly httpRequest: BaseHttpRequest;
     constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Get football statistics by type
-     * Retrieve various types of football statistics (top scorers, top assists, top cards, etc.)
-     * @param type Type of statistics to retrieve
-     * @param league League ID
-     * @param season Season year (e.g., '2024')
-     * @returns any Statistics retrieved successfully
-     * @throws ApiError
-     */
-    getApiV1ContentStatistics(type: 'topscorers' | 'topassists' | 'topyellowcards' | 'topredcards', league: string, season: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<Record<string, any>>;
-    })>;
     /**
      * Get player injuries
-     * Retrieve current player injuries and injury status
-     * @param league Filter by league ID
-     * @param team Filter by team ID
-     * @param player Filter by player ID
-     * @param season Filter by season year (e.g., '2024')
+     * @param league
+     * @param season
+     * @param player
+     * @param team
+     * @param fixture
+     * @param date
+     * @param skipCache
      * @returns any Injuries retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStatisticsInjuries(league?: string, team?: string, player?: string, season?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<{
-            player?: PlayerDTO;
-            type?: string;
-            reason?: string;
-            start?: string;
-            end?: string;
-        }>;
-    })>;
+    getApiV1ContentStatisticsInjuries(league?: number, season?: string, player?: number, team?: number, fixture?: number, date?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: InjuriesResponse;
+        message?: string;
+    }>;
     /**
      * Get sidelined players
-     * Retrieve players who are sidelined (injured, suspended, or unavailable)
-     * @param league Filter by league ID
-     * @param team Filter by team ID
-     * @param player Filter by player ID
+     * @param player
+     * @param coach
+     * @param skipCache
      * @returns any Sidelined players retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStatisticsSidelined(league?: string, team?: string, player?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<Record<string, any>>;
-    })>;
+    getApiV1ContentStatisticsSidelined(player?: number, coach?: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: SidelinedResponse;
+        message?: string;
+    }>;
+    /**
+     * Get football statistics by type
+     * @param type
+     * @param league
+     * @param season
+     * @param team
+     * @param date
+     * @returns any Statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentStatistics(type: 'topscorers' | 'topassists' | 'topyellowcards' | 'topredcards', league: number, season: number, team?: number, date?: string): CancelablePromise<{
+        success: boolean;
+        data: StatsByTypeResponse;
+        message?: string;
+    }>;
 }

package/dist/services/ContentStatisticsService.js

@@ -6,50 +6,51 @@ class ContentStatisticsService {
         this.httpRequest = httpRequest;
     }
     /**
-     * Get football statistics by type
-     * Retrieve various types of football statistics (top scorers, top assists, top cards, etc.)
-     * @param type Type of statistics to retrieve
-     * @param league League ID
-     * @param season Season year (e.g., '2024')
-     * @returns any Statistics retrieved successfully
+     * Get player injuries
+     * @param league
+     * @param season
+     * @param player
+     * @param team
+     * @param fixture
+     * @param date
+     * @param skipCache
+     * @returns any Injuries retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStatistics(type, league, season) {
+    getApiV1ContentStatisticsInjuries(league, season, player, team, fixture, date, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/statistics/{type}',
-            path: {
-                'type': type,
-            },
+            url: '/api/v1/content/statistics/injuries',
             query: {
                 'league': league,
                 'season': season,
+                'player': player,
+                'team': team,
+                'fixture': fixture,
+                'date': date,
+                'skipCache': skipCache,
             },
             errors: {
-                400: `Invalid statistics type or missing parameters`,
                 500: `Internal server error`,
             },
         });
     }
     /**
-     * Get player injuries
-     * Retrieve current player injuries and injury status
-     * @param league Filter by league ID
-     * @param team Filter by team ID
-     * @param player Filter by player ID
-     * @param season Filter by season year (e.g., '2024')
-     * @returns any Injuries retrieved successfully
+     * Get sidelined players
+     * @param player
+     * @param coach
+     * @param skipCache
+     * @returns any Sidelined players retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStatisticsInjuries(league, team, player, season) {
+    getApiV1ContentStatisticsSidelined(player, coach, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/statistics/injuries',
+            url: '/api/v1/content/statistics/sidelined',
             query: {
-                'league': league,
-                'team': team,
                 'player': player,
-                'season': season,
+                'coach': coach,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -57,24 +58,30 @@ class ContentStatisticsService {
         });
     }
     /**
-     * Get sidelined players
-     * Retrieve players who are sidelined (injured, suspended, or unavailable)
-     * @param league Filter by league ID
-     * @param team Filter by team ID
-     * @param player Filter by player ID
-     * @returns any Sidelined players retrieved successfully
+     * Get football statistics by type
+     * @param type
+     * @param league
+     * @param season
+     * @param team
+     * @param date
+     * @returns any Statistics retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentStatisticsSidelined(league, team, player) {
+    getApiV1ContentStatistics(type, league, season, team, date) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/statistics/sidelined',
+            url: '/api/v1/content/statistics/{type}',
+            path: {
+                'type': type,
+            },
             query: {
                 'league': league,
+                'season': season,
                 'team': team,
-                'player': player,
+                'date': date,
             },
             errors: {
+                400: `Invalid statistics type or missing parameters`,
                 500: `Internal server error`,
             },
         });

package/dist/services/ContentTeamsService.d.ts

@@ -1,7 +1,8 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
-import type { PlayerDTO } from '../models/PlayerDTO';
-import type { TeamDetailDTO } from '../models/TeamDetailDTO';
-import type { TeamStatisticsDTO } from '../models/TeamStatisticsDTO';
+import type { TeamCoachResponse } from '../models/TeamCoachResponse';
+import type { TeamResponse } from '../models/TeamResponse';
+import type { TeamSeasonsResponse } from '../models/TeamSeasonsResponse';
+import type { TeamSquadResponse } from '../models/TeamSquadResponse';
+import type { TeamStatsResponse } from '../models/TeamStatsResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ContentTeamsService {
@@ -9,59 +10,87 @@ export declare class ContentTeamsService {
     constructor(httpRequest: BaseHttpRequest);
     /**
      * Get team information
-     * Retrieve team details including venue, country, and founding information
-     * @param id Filter by team ID
-     * @param name Filter by team name
-     * @param league Filter by league ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param country Filter by country name
-     * @param search Search teams by name
+     * @param id
+     * @param name
+     * @param league
+     * @param season
+     * @param country
+     * @param code
+     * @param venue
+     * @param search
+     * @param skipCache
      * @returns any Team data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeams(id?: string, name?: string, league?: string, season?: string, country?: string, search?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: TeamDetailDTO;
-    })>;
+    getApiV1ContentTeams(id?: number, name?: string, league?: number, season?: number, country?: string, code?: string, venue?: string, search?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: TeamResponse;
+        message?: string;
+    }>;
     /**
-     * Get team squad
-     * Retrieve current squad/roster for a team including all players
-     * @param team Team ID
-     * @param season Season year (e.g., '2024')
+     * Get team season statistics
+     * @param team
+     * @param season
+     * @param league
+     * @param date
+     * @param skipCache
+     * @returns any Team statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsStats(team?: number, season?: number, league?: number, date?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: TeamStatsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get team squad (players)
+     * @param team
+     * @param player
+     * @param skipCache
      * @returns any Squad data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeamsSquad(team: string, season?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<PlayerDTO>;
-    })>;
+    getApiV1ContentTeamsPlayers(team?: number, player?: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: TeamSquadResponse;
+        message?: string;
+    }>;
     /**
-     * Get team coach
-     * Retrieve information about the team's current coach/manager
-     * @param team Team ID
-     * @returns any Coach data retrieved successfully
+     * Get team squad (alias)
+     * @param team
+     * @param player
+     * @param skipCache
+     * @returns any Squad data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeamsCoach(team: string): CancelablePromise<(ApiResponseDTO & {
-        data?: {
-            id?: string;
-            name?: string;
-            firstname?: string;
-            lastname?: string;
-            age?: number;
-            nationality?: string;
-            photo?: string;
-        };
-    })>;
+    getApiV1ContentTeamsSquad(team?: number, player?: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: TeamSquadResponse;
+        message?: string;
+    }>;
     /**
-     * Get team season statistics
-     * Retrieve detailed season statistics for a team including wins, losses, goals, clean sheets, etc.
-     * @param team Team ID
-     * @param league League ID
-     * @param season Season year (e.g., '2024')
-     * @param date Filter by date (YYYY-MM-DD)
-     * @returns any Team statistics retrieved successfully
+     * Get team seasons
+     * @param team
+     * @returns any Team seasons retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsSeasons(team: number): CancelablePromise<{
+        success: boolean;
+        data: TeamSeasonsResponse;
+        message?: string;
+    }>;
+    /**
+     * Get team coach
+     * @param team
+     * @param id
+     * @param search
+     * @param skipCache
+     * @returns any Coach data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeamsStatistics(team: string, league: string, season: string, date?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: TeamStatisticsDTO;
-    })>;
+    getApiV1ContentTeamsCoach(team?: number, id?: number, search?: string, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: TeamCoachResponse;
+        message?: string;
+    }>;
 }

package/dist/services/ContentTeamsService.js

@@ -7,17 +7,19 @@ class ContentTeamsService {
     }
     /**
      * Get team information
-     * Retrieve team details including venue, country, and founding information
-     * @param id Filter by team ID
-     * @param name Filter by team name
-     * @param league Filter by league ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param country Filter by country name
-     * @param search Search teams by name
+     * @param id
+     * @param name
+     * @param league
+     * @param season
+     * @param country
+     * @param code
+     * @param venue
+     * @param search
+     * @param skipCache
      * @returns any Team data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeams(id, name, league, season, country, search) {
+    getApiV1ContentTeams(id, name, league, season, country, code, venue, search, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/teams',
@@ -27,7 +29,10 @@ class ContentTeamsService {
                 'league': league,
                 'season': season,
                 'country': country,
+                'code': code,
+                'venue': venue,
                 'search': search,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,
@@ -35,20 +40,71 @@ class ContentTeamsService {
         });
     }
     /**
-     * Get team squad
-     * Retrieve current squad/roster for a team including all players
-     * @param team Team ID
-     * @param season Season year (e.g., '2024')
+     * Get team season statistics
+     * @param team
+     * @param season
+     * @param league
+     * @param date
+     * @param skipCache
+     * @returns any Team statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsStats(team, season, league, date, skipCache) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/teams/stats',
+            query: {
+                'team': team,
+                'season': season,
+                'league': league,
+                'date': date,
+                'skipCache': skipCache,
+            },
+            errors: {
+                400: `Missing required parameters`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get team squad (players)
+     * @param team
+     * @param player
+     * @param skipCache
+     * @returns any Squad data retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsPlayers(team, player, skipCache) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/teams/players',
+            query: {
+                'team': team,
+                'player': player,
+                'skipCache': skipCache,
+            },
+            errors: {
+                400: `Missing team ID`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get team squad (alias)
+     * @param team
+     * @param player
+     * @param skipCache
      * @returns any Squad data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeamsSquad(team, season) {
+    getApiV1ContentTeamsSquad(team, player, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/teams/squad',
             query: {
                 'team': team,
-                'season': season,
+                'player': player,
+                'skipCache': skipCache,
             },
             errors: {
                 400: `Missing team ID`,
@@ -57,16 +113,15 @@ class ContentTeamsService {
         });
     }
     /**
-     * Get team coach
-     * Retrieve information about the team's current coach/manager
-     * @param team Team ID
-     * @returns any Coach data retrieved successfully
+     * Get team seasons
+     * @param team
+     * @returns any Team seasons retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeamsCoach(team) {
+    getApiV1ContentTeamsSeasons(team) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/teams/coach',
+            url: '/api/v1/content/teams/seasons',
             query: {
                 'team': team,
             },
@@ -77,27 +132,26 @@ class ContentTeamsService {
         });
     }
     /**
-     * Get team season statistics
-     * Retrieve detailed season statistics for a team including wins, losses, goals, clean sheets, etc.
-     * @param team Team ID
-     * @param league League ID
-     * @param season Season year (e.g., '2024')
-     * @param date Filter by date (YYYY-MM-DD)
-     * @returns any Team statistics retrieved successfully
+     * Get team coach
+     * @param team
+     * @param id
+     * @param search
+     * @param skipCache
+     * @returns any Coach data retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTeamsStatistics(team, league, season, date) {
+    getApiV1ContentTeamsCoach(team, id, search, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/api/v1/content/teams/statistics',
+            url: '/api/v1/content/teams/coach',
             query: {
                 'team': team,
-                'league': league,
-                'season': season,
-                'date': date,
+                'id': id,
+                'search': search,
+                'skipCache': skipCache,
             },
             errors: {
-                400: `Missing required parameters`,
+                400: `Missing team ID`,
                 500: `Internal server error`,
             },
         });

package/dist/services/ContentTransfersService.d.ts

@@ -1,5 +1,4 @@
-import type { ApiResponseDTO } from '../models/ApiResponseDTO';
-import type { TransferDTO } from '../models/TransferDTO';
+import type { TransfersResponse } from '../models/TransfersResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import type { BaseHttpRequest } from '../core/BaseHttpRequest';
 export declare class ContentTransfersService {
@@ -7,17 +6,15 @@ export declare class ContentTransfersService {
     constructor(httpRequest: BaseHttpRequest);
     /**
      * Get player transfers
-     * Retrieve player transfer information including past and current transfers
-     * @param player Filter by player ID
-     * @param team Filter by team ID (either from or to)
-     * @param league Filter by league ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param from Filter transfers from this date (YYYY-MM-DD)
-     * @param to Filter transfers until this date (YYYY-MM-DD)
+     * @param player
+     * @param team
+     * @param skipCache
      * @returns any Transfers retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTransfers(player?: string, team?: string, league?: string, season?: string, from?: string, to?: string): CancelablePromise<(ApiResponseDTO & {
-        data?: Array<TransferDTO>;
-    })>;
+    getApiV1ContentTransfers(player?: number, team?: number, skipCache?: boolean | null): CancelablePromise<{
+        success: boolean;
+        data: TransfersResponse;
+        message?: string;
+    }>;
 }

package/dist/services/ContentTransfersService.js

@@ -7,27 +7,20 @@ class ContentTransfersService {
     }
     /**
      * Get player transfers
-     * Retrieve player transfer information including past and current transfers
-     * @param player Filter by player ID
-     * @param team Filter by team ID (either from or to)
-     * @param league Filter by league ID
-     * @param season Filter by season year (e.g., '2024')
-     * @param from Filter transfers from this date (YYYY-MM-DD)
-     * @param to Filter transfers until this date (YYYY-MM-DD)
+     * @param player
+     * @param team
+     * @param skipCache
      * @returns any Transfers retrieved successfully
      * @throws ApiError
      */
-    getApiV1ContentTransfers(player, team, league, season, from, to) {
+    getApiV1ContentTransfers(player, team, skipCache) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/api/v1/content/transfers',
             query: {
                 'player': player,
                 'team': team,
-                'league': league,
-                'season': season,
-                'from': from,
-                'to': to,
+                'skipCache': skipCache,
             },
             errors: {
                 500: `Internal server error`,