@footballbingo/client 1.0.0

package/dist/services/ContentOddsService.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentOddsService = void 0;
+class ContentOddsService {
+    constructor(httpRequest) {
+        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
+     * @throws ApiError
+     */
+    getApiV1ContentOddsLive(fixture, bookmaker, bet) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/odds/live',
+            query: {
+                'fixture': fixture,
+                'bookmaker': bookmaker,
+                'bet': bet,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get live bet types
+     * Retrieve available bet types for live matches
+     * @param fixture Filter by fixture ID
+     * @returns any Live bets retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentOddsLiveBets(fixture) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/odds/live-bets',
+            query: {
+                'fixture': fixture,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ContentOdds(fixture, league, season, bookmaker, bet, date) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/odds',
+            query: {
+                'fixture': fixture,
+                'league': league,
+                'season': season,
+                'bookmaker': bookmaker,
+                'bet': bet,
+                'date': date,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get odds bet mapping
+     * Retrieve mapping of bet types and their IDs
+     * @returns any Odds mapping retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentOddsMapping() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/odds/mapping',
+            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
+     * @throws ApiError
+     */
+    getApiV1ContentOddsBookmakers(id, search) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/odds/bookmakers',
+            query: {
+                'id': id,
+                'search': search,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ContentOddsBets(id, search) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/odds/bets',
+            query: {
+                'id': id,
+                'search': search,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentOddsService = ContentOddsService;

package/dist/services/ContentPlayersService.d.ts

@@ -0,0 +1,64 @@
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { PlayerDTO } from '../models/PlayerDTO';
+import type { PlayerStatisticsDTO } from '../models/PlayerStatisticsDTO';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ContentPlayersService {
+    readonly httpRequest: BaseHttpRequest;
+    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
+     * @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>;
+    })>;
+    /**
+     * Get player history
+     * Retrieve historical data for a player including past teams and transfers
+     * @param player Player ID
+     * @returns any Player history retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayersHistory(player: string): CancelablePromise<(ApiResponseDTO & {
+        data?: {
+            player?: PlayerDTO;
+            history?: Array<Record<string, any>>;
+        };
+    })>;
+    /**
+     * 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
+     * @returns any Player statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayersStatistics(id: string, season?: string, league?: string, team?: string): CancelablePromise<(ApiResponseDTO & {
+        data?: PlayerStatisticsDTO;
+    })>;
+    /**
+     * Get player seasons
+     * Retrieve all seasons where a player has data available
+     * @param player Player ID
+     * @returns any Player seasons retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayersSeasons(player: string): CancelablePromise<(ApiResponseDTO & {
+        data?: Array<{
+            year?: string;
+            team?: string;
+            league?: string;
+        }>;
+    })>;
+}

package/dist/services/ContentPlayersService.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentPlayersService = void 0;
+class ContentPlayersService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * 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
+     * @returns any Players retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayers(id, team, league, season, search, page = 1) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/players',
+            query: {
+                'id': id,
+                'team': team,
+                'league': league,
+                'season': season,
+                'search': search,
+                'page': page,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get player history
+     * Retrieve historical data for a player including past teams and transfers
+     * @param player Player ID
+     * @returns any Player history retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayersHistory(player) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/players/history',
+            query: {
+                'player': player,
+            },
+            errors: {
+                400: `Missing player ID`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * 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
+     * @returns any Player statistics retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayersStatistics(id, season, league, team) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/players/statistics',
+            query: {
+                'id': id,
+                'season': season,
+                'league': league,
+                'team': team,
+            },
+            errors: {
+                400: `Missing player ID`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get player seasons
+     * Retrieve all seasons where a player has data available
+     * @param player Player ID
+     * @returns any Player seasons retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentPlayersSeasons(player) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/players/seasons',
+            query: {
+                'player': player,
+            },
+            errors: {
+                400: `Missing player ID`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentPlayersService = ContentPlayersService;

package/dist/services/ContentStandingsService.d.ts

@@ -0,0 +1,20 @@
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { StandingsDTO } from '../models/StandingsDTO';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ContentStandingsService {
+    readonly httpRequest: BaseHttpRequest;
+    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
+     * @returns any Standings retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentStandings(league: string, season: string, team?: string): CancelablePromise<(ApiResponseDTO & {
+        data?: StandingsDTO;
+    })>;
+}

package/dist/services/ContentStandingsService.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentStandingsService = void 0;
+class ContentStandingsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * 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
+     * @returns any Standings retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentStandings(league, season, team) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/standings',
+            query: {
+                'league': league,
+                'season': season,
+                'team': team,
+            },
+            errors: {
+                400: `Missing required parameters`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentStandingsService = ContentStandingsService;

package/dist/services/ContentStatisticsService.d.ts

@@ -0,0 +1,51 @@
+import type { ApiResponseDTO } from '../models/ApiResponseDTO';
+import type { PlayerDTO } from '../models/PlayerDTO';
+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')
+     * @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;
+        }>;
+    })>;
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ContentStatisticsSidelined(league?: string, team?: string, player?: string): CancelablePromise<(ApiResponseDTO & {
+        data?: Array<Record<string, any>>;
+    })>;
+}

package/dist/services/ContentStatisticsService.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentStatisticsService = void 0;
+class ContentStatisticsService {
+    constructor(httpRequest) {
+        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
+     * @throws ApiError
+     */
+    getApiV1ContentStatistics(type, league, season) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/statistics/{type}',
+            path: {
+                'type': type,
+            },
+            query: {
+                'league': league,
+                'season': season,
+            },
+            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
+     * @throws ApiError
+     */
+    getApiV1ContentStatisticsInjuries(league, team, player, season) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/statistics/injuries',
+            query: {
+                'league': league,
+                'team': team,
+                'player': player,
+                'season': season,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ContentStatisticsSidelined(league, team, player) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/statistics/sidelined',
+            query: {
+                'league': league,
+                'team': team,
+                'player': player,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentStatisticsService = ContentStatisticsService;

package/dist/services/ContentTeamsService.d.ts

@@ -0,0 +1,67 @@
+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 { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class ContentTeamsService {
+    readonly httpRequest: BaseHttpRequest;
+    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
+     * @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;
+    })>;
+    /**
+     * Get team squad
+     * Retrieve current squad/roster for a team including all players
+     * @param team Team ID
+     * @param season Season year (e.g., '2024')
+     * @returns any Squad data retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsSquad(team: string, season?: string): CancelablePromise<(ApiResponseDTO & {
+        data?: Array<PlayerDTO>;
+    })>;
+    /**
+     * Get team coach
+     * Retrieve information about the team's current coach/manager
+     * @param team Team ID
+     * @returns any Coach 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;
+        };
+    })>;
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsStatistics(team: string, league: string, season: string, date?: string): CancelablePromise<(ApiResponseDTO & {
+        data?: TeamStatisticsDTO;
+    })>;
+}

package/dist/services/ContentTeamsService.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentTeamsService = void 0;
+class ContentTeamsService {
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * 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
+     * @returns any Team data retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeams(id, name, league, season, country, search) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/teams',
+            query: {
+                'id': id,
+                'name': name,
+                'league': league,
+                'season': season,
+                'country': country,
+                'search': search,
+            },
+            errors: {
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get team squad
+     * Retrieve current squad/roster for a team including all players
+     * @param team Team ID
+     * @param season Season year (e.g., '2024')
+     * @returns any Squad data retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsSquad(team, season) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/teams/squad',
+            query: {
+                'team': team,
+                'season': season,
+            },
+            errors: {
+                400: `Missing team ID`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * Get team coach
+     * Retrieve information about the team's current coach/manager
+     * @param team Team ID
+     * @returns any Coach data retrieved successfully
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsCoach(team) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/teams/coach',
+            query: {
+                'team': team,
+            },
+            errors: {
+                400: `Missing team ID`,
+                500: `Internal server error`,
+            },
+        });
+    }
+    /**
+     * 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
+     * @throws ApiError
+     */
+    getApiV1ContentTeamsStatistics(team, league, season, date) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/content/teams/statistics',
+            query: {
+                'team': team,
+                'league': league,
+                'season': season,
+                'date': date,
+            },
+            errors: {
+                400: `Missing required parameters`,
+                500: `Internal server error`,
+            },
+        });
+    }
+}
+exports.ContentTeamsService = ContentTeamsService;