@bp1222/stats-api/dist/index.d.mts

Library for Typescript Client to query MLB StatsAPI

declare const BASE_PATH: string;
interface ConfigurationParameters {
    basePath?: string;
    fetchApi?: FetchAPI;
    middleware?: Middleware[];
    queryParamsStringify?: (params: HTTPQuery) => string;
    username?: string;
    password?: string;
    apiKey?: string | Promise<string> | ((name: string) => string | Promise<string>);
    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<string>);
    headers?: HTTPHeaders;
    credentials?: RequestCredentials;
}
declare class Configuration {
    private configuration;
    constructor(configuration?: ConfigurationParameters);
    set config(configuration: Configuration);
    get basePath(): string;
    get fetchApi(): FetchAPI | undefined;
    get middleware(): Middleware[];
    get queryParamsStringify(): (params: HTTPQuery) => string;
    get username(): string | undefined;
    get password(): string | undefined;
    get apiKey(): ((name: string) => string | Promise<string>) | undefined;
    get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined;
    get headers(): HTTPHeaders | undefined;
    get credentials(): RequestCredentials | undefined;
}
declare const DefaultConfig: Configuration;
declare class BaseAPI {
    protected configuration: Configuration;
    private static readonly jsonRegex;
    private middleware;
    constructor(configuration?: Configuration);
    withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]): T;
    withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware['pre']>): T;
    withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>): T;
    protected isJsonMime(mime: string | null | undefined): boolean;
    protected request(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction): Promise<Response>;
    private createFetchParams;
    private fetchApi;
    private clone;
}
declare class ResponseError extends Error {
    response: Response;
    name: "ResponseError";
    constructor(response: Response, msg?: string);
}
declare class FetchError extends Error {
    cause: Error;
    name: "FetchError";
    constructor(cause: Error, msg?: string);
}
declare class RequiredError extends Error {
    field: string;
    name: "RequiredError";
    constructor(field: string, msg?: string);
}
declare const COLLECTION_FORMATS: {
    csv: string;
    ssv: string;
    tsv: string;
    pipes: string;
};
type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
type Json = any;
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
type HTTPHeaders = {
    [key: string]: string;
};
type HTTPQuery = {
    [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery;
};
type HTTPBody = Json | FormData | URLSearchParams;
type HTTPRequestInit = {
    headers?: HTTPHeaders;
    method: HTTPMethod;
    credentials?: RequestCredentials;
    body?: HTTPBody;
};
type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
type InitOverrideFunction = (requestContext: {
    init: HTTPRequestInit;
    context: RequestOpts;
}) => Promise<RequestInit>;
interface FetchParams {
    url: string;
    init: RequestInit;
}
interface RequestOpts {
    path: string;
    method: HTTPMethod;
    headers: HTTPHeaders;
    query?: HTTPQuery;
    body?: HTTPBody;
}
declare function querystring(params: HTTPQuery, prefix?: string): string;
declare function mapValues(data: any, fn: (item: any) => any): {};
declare function canConsumeForm(consumes: Consume[]): boolean;
interface Consume {
    contentType: string;
}
interface RequestContext {
    fetch: FetchAPI;
    url: string;
    init: RequestInit;
}
interface ResponseContext {
    fetch: FetchAPI;
    url: string;
    init: RequestInit;
    response: Response;
}
interface ErrorContext {
    fetch: FetchAPI;
    url: string;
    init: RequestInit;
    error: unknown;
    response?: Response;
}
interface Middleware {
    pre?(context: RequestContext): Promise<FetchParams | void>;
    post?(context: ResponseContext): Promise<Response | void>;
    onError?(context: ErrorContext): Promise<Response | void>;
}
interface ApiResponse<T> {
    raw: Response;
    value(): Promise<T>;
}
interface ResponseTransformer<T> {
    (json: any): T;
}
declare class JSONApiResponse<T> {
    raw: Response;
    private transformer;
    constructor(raw: Response, transformer?: ResponseTransformer<T>);
    value(): Promise<T>;
}
declare class VoidApiResponse {
    raw: Response;
    constructor(raw: Response);
    value(): Promise<void>;
}
declare class BlobApiResponse {
    raw: Response;
    constructor(raw: Response);
    value(): Promise<Blob>;
}
declare class TextApiResponse {
    raw: Response;
    constructor(raw: Response);
    value(): Promise<string>;
}

interface Official {
    id?: number;
    fullName?: string;
    link?: string;
}
declare function instanceOfOfficial(value: object): value is Official;
declare function OfficialFromJSON(json: any): Official;
declare function OfficialFromJSONTyped(json: any, ignoreDiscriminator: boolean): Official;
declare function OfficialToJSON(json: any): Official;
declare function OfficialToJSONTyped(value?: Official | null, ignoreDiscriminator?: boolean): any;

interface GameOfficial {
    official?: Official;
    officialType?: string;
}
declare function instanceOfGameOfficial(value: object): value is GameOfficial;
declare function GameOfficialFromJSON(json: any): GameOfficial;
declare function GameOfficialFromJSONTyped(json: any, ignoreDiscriminator: boolean): GameOfficial;
declare function GameOfficialToJSON(json: any): GameOfficial;
declare function GameOfficialToJSONTyped(value?: GameOfficial | null, ignoreDiscriminator?: boolean): any;

interface LeagueDates {
    seasonId?: string;
    preSeasonStartDate?: string;
    preSeasonEndDate?: string;
    seasonStartDate?: string;
    springStartDate?: string;
    springEndDate?: string;
    offseasonStartDate?: string;
    offseasonEndDate?: string;
    seasonLevelGamedayType?: string;
    gameLevelGamedayType?: string;
}
declare function instanceOfLeagueDates(value: object): value is LeagueDates;
declare function LeagueDatesFromJSON(json: any): LeagueDates;
declare function LeagueDatesFromJSONTyped(json: any, ignoreDiscriminator: boolean): LeagueDates;
declare function LeagueDatesToJSON(json: any): LeagueDates;
declare function LeagueDatesToJSONTyped(value?: LeagueDates | null, ignoreDiscriminator?: boolean): any;

interface League {
    id: number;
    name: string;
    link?: string;
    abbreviation?: string;
    nameShort?: string;
    seasonState?: string;
    hasWildCard?: boolean;
    hasSplitSeason?: boolean;
    hasPlayoffPoints?: boolean;
    seasonDateInfo?: LeagueDates;
    season?: string;
    orgCode?: string;
    conferencesInUse?: boolean;
    divisionsInUse?: boolean;
    sortOrder?: number;
    active?: boolean;
}
declare function instanceOfLeague(value: object): value is League;
declare function LeagueFromJSON(json: any): League;
declare function LeagueFromJSONTyped(json: any, ignoreDiscriminator: boolean): League;
declare function LeagueToJSON(json: any): League;
declare function LeagueToJSONTyped(value?: League | null, ignoreDiscriminator?: boolean): any;

interface Sport {
    id: number;
    code?: string;
    link?: string;
    name?: string;
    abbreviation?: string;
    sortOrder?: number;
    activeStatus?: boolean;
}
declare function instanceOfSport(value: object): value is Sport;
declare function SportFromJSON(json: any): Sport;
declare function SportFromJSONTyped(json: any, ignoreDiscriminator: boolean): Sport;
declare function SportToJSON(json: any): Sport;
declare function SportToJSONTyped(value?: Sport | null, ignoreDiscriminator?: boolean): any;

interface Venue {
    id: number;
    name: string;
    link?: string;
    active?: boolean;
    season?: string;
}
declare function instanceOfVenue(value: object): value is Venue;
declare function VenueFromJSON(json: any): Venue;
declare function VenueFromJSONTyped(json: any, ignoreDiscriminator: boolean): Venue;
declare function VenueToJSON(json: any): Venue;
declare function VenueToJSONTyped(value?: Venue | null, ignoreDiscriminator?: boolean): any;

interface Division {
    id: number;
    name: string;
    season?: string;
    nameShort?: string;
    link?: string;
    abbreviation?: string;
    league?: League;
    sport?: Sport;
    hasWildcard?: boolean;
    sortOrder?: number;
    numPlayoffTeams?: number;
    active?: boolean;
}
declare function instanceOfDivision(value: object): value is Division;
declare function DivisionFromJSON(json: any): Division;
declare function DivisionFromJSONTyped(json: any, ignoreDiscriminator: boolean): Division;
declare function DivisionToJSON(json: any): Division;
declare function DivisionToJSONTyped(value?: Division | null, ignoreDiscriminator?: boolean): any;

interface Streak {
    streakType?: StreakStreakTypeEnum;
}
declare enum StreakStreakTypeEnum {
    Losing = "losses",
    Winning = "wins"
}
declare function instanceOfStreak(value: object): value is Streak;
declare function StreakFromJSON(json: any): Streak;
declare function StreakFromJSONTyped(json: any, ignoreDiscriminator: boolean): Streak;
declare function StreakToJSON(json: any): Streak;
declare function StreakToJSONTyped(value?: Streak | null, ignoreDiscriminator?: boolean): any;

interface LeagueRecord {
    wins: number;
    losses: number;
    ties?: number;
    pct: string;
}
declare function instanceOfLeagueRecord(value: object): value is LeagueRecord;
declare function LeagueRecordFromJSON(json: any): LeagueRecord;
declare function LeagueRecordFromJSONTyped(json: any, ignoreDiscriminator: boolean): LeagueRecord;
declare function LeagueRecordToJSON(json: any): LeagueRecord;
declare function LeagueRecordToJSONTyped(value?: LeagueRecord | null, ignoreDiscriminator?: boolean): any;

interface Record {
    team: Team;
    season: string;
    streak: Streak;
    divisionRank: string;
    leagueRank: string;
    sportRank?: string;
    gamesPlayed?: number;
    gamesBack: string;
    wildCardGamesBack?: string;
    leagueGamesBack?: string;
    sportGamesBack?: string;
    divisionGamesBack?: string;
    conferenceGamesBack?: string;
    leagueRecord: LeagueRecord;
    lastUpdated?: string;
    runsAllowed?: number;
    runsScored?: number;
    divisionChamp?: boolean;
    divisionLeader?: boolean;
    hasWildcard?: boolean;
    clinched?: boolean;
    eliminationNumber?: string;
    eliminationNumberSport?: string;
    eliminationNumberLeague?: string;
    eliminationNumberDivision?: string;
    eliminationNumberConference?: string;
    wildCardEliminationNumber?: string;
    magicNumber?: string;
    wins: number;
    losses: number;
    runDifferential?: number;
    winningPercentage?: string;
}
declare function instanceOfRecord(value: object): value is Record;
declare function RecordFromJSON(json: any): Record;
declare function RecordFromJSONTyped(json: any, ignoreDiscriminator: boolean): Record;
declare function RecordToJSON(json: any): Record;
declare function RecordToJSONTyped(value?: Record | null, ignoreDiscriminator?: boolean): any;

interface Team {
    id: number;
    name: string;
    link?: string;
    allStarStatus?: string;
    season?: number;
    venue?: Venue;
    springVenue?: Venue;
    teamCode?: string;
    fileCode?: string;
    abbreviation?: string;
    teamName?: string;
    locationName?: string;
    firstYearOfPlay?: string;
    league?: League;
    springLeague?: League;
    division?: Division;
    sport?: Sport;
    record?: Record;
    shortName?: string;
    franchiseName?: string;
    clubName?: string;
    active?: boolean;
}
declare function instanceOfTeam(value: object): value is Team;
declare function TeamFromJSON(json: any): Team;
declare function TeamFromJSONTyped(json: any, ignoreDiscriminator: boolean): Team;
declare function TeamToJSON(json: any): Team;
declare function TeamToJSONTyped(value?: Team | null, ignoreDiscriminator?: boolean): any;

interface BoxscoreTeams {
    away?: Team;
    home?: Team;
}
declare function instanceOfBoxscoreTeams(value: object): value is BoxscoreTeams;
declare function BoxscoreTeamsFromJSON(json: any): BoxscoreTeams;
declare function BoxscoreTeamsFromJSONTyped(json: any, ignoreDiscriminator: boolean): BoxscoreTeams;
declare function BoxscoreTeamsToJSON(json: any): BoxscoreTeams;
declare function BoxscoreTeamsToJSONTyped(value?: BoxscoreTeams | null, ignoreDiscriminator?: boolean): any;

interface Boxscore {
    teams?: BoxscoreTeams;
    officials?: Array<GameOfficial>;
}
declare function instanceOfBoxscore(value: object): value is Boxscore;
declare function BoxscoreFromJSON(json: any): Boxscore;
declare function BoxscoreFromJSONTyped(json: any, ignoreDiscriminator: boolean): Boxscore;
declare function BoxscoreToJSON(json: any): Boxscore;
declare function BoxscoreToJSONTyped(value?: Boxscore | null, ignoreDiscriminator?: boolean): any;

interface DivisionStandings {
    standingsType?: string;
    league: League;
    division: Division;
    sport: Sport;
    lastUpdated?: string;
    teamRecords: Array<Record>;
}
declare function instanceOfDivisionStandings(value: object): value is DivisionStandings;
declare function DivisionStandingsFromJSON(json: any): DivisionStandings;
declare function DivisionStandingsFromJSONTyped(json: any, ignoreDiscriminator: boolean): DivisionStandings;
declare function DivisionStandingsToJSON(json: any): DivisionStandings;
declare function DivisionStandingsToJSONTyped(value?: DivisionStandings | null, ignoreDiscriminator?: boolean): any;

interface DivisionStandingsList {
    records?: Array<DivisionStandings>;
}
declare function instanceOfDivisionStandingsList(value: object): value is DivisionStandingsList;
declare function DivisionStandingsListFromJSON(json: any): DivisionStandingsList;
declare function DivisionStandingsListFromJSONTyped(json: any, ignoreDiscriminator: boolean): DivisionStandingsList;
declare function DivisionStandingsListToJSON(json: any): DivisionStandingsList;
declare function DivisionStandingsListToJSONTyped(value?: DivisionStandingsList | null, ignoreDiscriminator?: boolean): any;

declare enum GameStatusCode {
    Final = "F",
    Postponed = "D",
    Scheduled = "S",
    InProgress = "I",
    Pregame = "P",
    GameOver = "O",
    Canceled = "C"
}
declare function instanceOfGameStatusCode(value: any): boolean;
declare function GameStatusCodeFromJSON(json: any): GameStatusCode;
declare function GameStatusCodeFromJSONTyped(json: any, ignoreDiscriminator: boolean): GameStatusCode;
declare function GameStatusCodeToJSON(value?: GameStatusCode | null): any;
declare function GameStatusCodeToJSONTyped(value: any, ignoreDiscriminator: boolean): GameStatusCode;

interface GameStatus {
    abstractGameState?: string;
    codedGameState?: GameStatusCode;
    detailedState?: string;
    statusCode?: string;
    startTimeTBD?: boolean;
    abstractGameCode?: string;
}
declare function instanceOfGameStatus(value: object): value is GameStatus;
declare function GameStatusFromJSON(json: any): GameStatus;
declare function GameStatusFromJSONTyped(json: any, ignoreDiscriminator: boolean): GameStatus;
declare function GameStatusToJSON(json: any): GameStatus;
declare function GameStatusToJSONTyped(value?: GameStatus | null, ignoreDiscriminator?: boolean): any;

interface GameTeam {
    leagueRecord?: LeagueRecord;
    score: number;
    team: Team;
    isWinner: boolean;
    splitSquad?: boolean;
    seriesNumber?: number;
}
declare function instanceOfGameTeam(value: object): value is GameTeam;
declare function GameTeamFromJSON(json: any): GameTeam;
declare function GameTeamFromJSONTyped(json: any, ignoreDiscriminator: boolean): GameTeam;
declare function GameTeamToJSON(json: any): GameTeam;
declare function GameTeamToJSONTyped(value?: GameTeam | null, ignoreDiscriminator?: boolean): any;

interface GameTeams {
    away: GameTeam;
    home: GameTeam;
}
declare function instanceOfGameTeams(value: object): value is GameTeams;
declare function GameTeamsFromJSON(json: any): GameTeams;
declare function GameTeamsFromJSONTyped(json: any, ignoreDiscriminator: boolean): GameTeams;
declare function GameTeamsToJSON(json: any): GameTeams;
declare function GameTeamsToJSONTyped(value?: GameTeams | null, ignoreDiscriminator?: boolean): any;

declare enum GameType {
    Exhibition = "E",
    SpringTraining = "S",
    Regular = "R",
    WildCardSeries = "F",
    DivisionSeries = "D",
    LeagueChampionshipSeries = "L",
    WorldSeries = "W"
}
declare function instanceOfGameType(value: any): boolean;
declare function GameTypeFromJSON(json: any): GameType;
declare function GameTypeFromJSONTyped(json: any, ignoreDiscriminator: boolean): GameType;
declare function GameTypeToJSON(value?: GameType | null): any;
declare function GameTypeToJSONTyped(value: any, ignoreDiscriminator: boolean): GameType;

interface Game {
    gamePk: number;
    gameGuid: string;
    link?: string;
    gameType: GameType;
    season: number;
    gameDate: string;
    officialDate: string;
    rescheduledTo?: number;
    rescheduledToDate?: string;
    rescheduledFrom?: number;
    rescheduledFromDate?: string;
    status: GameStatus;
    teams: GameTeams;
    venue?: Venue;
    isTie?: boolean;
    gameNumber: number;
    publicFacing?: boolean;
    doubleHeader?: string;
    gamedayType?: string;
    tiebreaker?: string;
    calendarEventID?: string;
    seasonDisplay?: string;
    dayNight?: string;
    description?: string;
    scheduledInnings?: number;
    reverseHomeAwayStatus?: boolean;
    inningBreakLength?: number;
    gamesInSeries: number;
    seriesGameNumber: number;
    seriesDescription?: string;
    recordSource?: string;
    ifNecessary?: string;
    ifNecessaryDescription?: string;
}
declare function instanceOfGame(value: object): value is Game;
declare function GameFromJSON(json: any): Game;
declare function GameFromJSONTyped(json: any, ignoreDiscriminator: boolean): Game;
declare function GameToJSON(json: any): Game;
declare function GameToJSONTyped(value?: Game | null, ignoreDiscriminator?: boolean): any;

interface LinescoreTeam {
    runs?: number;
    hits?: number;
    errors?: number;
    leftOnBase?: number;
}
declare function instanceOfLinescoreTeam(value: object): value is LinescoreTeam;
declare function LinescoreTeamFromJSON(json: any): LinescoreTeam;
declare function LinescoreTeamFromJSONTyped(json: any, ignoreDiscriminator: boolean): LinescoreTeam;
declare function LinescoreTeamToJSON(json: any): LinescoreTeam;
declare function LinescoreTeamToJSONTyped(value?: LinescoreTeam | null, ignoreDiscriminator?: boolean): any;

interface Inning {
    num?: number;
    ordinalNum?: string;
    home?: LinescoreTeam;
    away?: LinescoreTeam;
}
declare function instanceOfInning(value: object): value is Inning;
declare function InningFromJSON(json: any): Inning;
declare function InningFromJSONTyped(json: any, ignoreDiscriminator: boolean): Inning;
declare function InningToJSON(json: any): Inning;
declare function InningToJSONTyped(value?: Inning | null, ignoreDiscriminator?: boolean): any;

interface LinescoreTeams {
    away?: LinescoreTeam;
    home?: LinescoreTeam;
}
declare function instanceOfLinescoreTeams(value: object): value is LinescoreTeams;
declare function LinescoreTeamsFromJSON(json: any): LinescoreTeams;
declare function LinescoreTeamsFromJSONTyped(json: any, ignoreDiscriminator: boolean): LinescoreTeams;
declare function LinescoreTeamsToJSON(json: any): LinescoreTeams;
declare function LinescoreTeamsToJSONTyped(value?: LinescoreTeams | null, ignoreDiscriminator?: boolean): any;

interface Linescore {
    currentInning?: number;
    currentInningOrdinal?: string;
    inningState?: string;
    inningHalf?: string;
    isTopInning?: boolean;
    scheduledInnings?: number;
    innings?: Array<Inning>;
    teams?: LinescoreTeams;
    balls?: number;
    strikes?: number;
    outs?: number;
}
declare function instanceOfLinescore(value: object): value is Linescore;
declare function LinescoreFromJSON(json: any): Linescore;
declare function LinescoreFromJSONTyped(json: any, ignoreDiscriminator: boolean): Linescore;
declare function LinescoreToJSON(json: any): Linescore;
declare function LinescoreToJSONTyped(value?: Linescore | null, ignoreDiscriminator?: boolean): any;

interface ScheduleDay {
    date?: string;
    totalItems?: number;
    totalEvents?: number;
    totalGames?: number;
    totalGamesInProgress?: number;
    games: Array<Game>;
}
declare function instanceOfScheduleDay(value: object): value is ScheduleDay;
declare function ScheduleDayFromJSON(json: any): ScheduleDay;
declare function ScheduleDayFromJSONTyped(json: any, ignoreDiscriminator: boolean): ScheduleDay;
declare function ScheduleDayToJSON(json: any): ScheduleDay;
declare function ScheduleDayToJSONTyped(value?: ScheduleDay | null, ignoreDiscriminator?: boolean): any;

interface Schedule {
    totalItems: number;
    totalEvents: number;
    totalGames: number;
    totalGamesInProgress: number;
    dates: Array<ScheduleDay>;
}
declare function instanceOfSchedule(value: object): value is Schedule;
declare function ScheduleFromJSON(json: any): Schedule;
declare function ScheduleFromJSONTyped(json: any, ignoreDiscriminator: boolean): Schedule;
declare function ScheduleToJSON(json: any): Schedule;
declare function ScheduleToJSONTyped(value?: Schedule | null, ignoreDiscriminator?: boolean): any;

interface Season {
    seasonId: string;
    hasWildcard?: boolean;
    preSeasonStartDate?: string;
    preSeasonEndDate?: string;
    seasonStartDate: string;
    seasonEndDate: string;
    springStartDate?: string;
    springEndDate?: string;
    regularSeasonStartDate: string;
    lastDate1stHalf?: string;
    allStartDate?: string;
    firstDate2ndHalf?: string;
    regularSeasonEndDate: string;
    postSeasonStartDate?: string;
    postSeasonEndDate?: string;
    offSeasonStartDate?: string;
    offSeasonEndDate?: string;
    seasonLevelGamedayType?: string;
    gameLevelGamedayType?: string;
    qualifierPlateAppearances?: number;
    qualifierOutsPitched?: number;
}
declare function instanceOfSeason(value: object): value is Season;
declare function SeasonFromJSON(json: any): Season;
declare function SeasonFromJSONTyped(json: any, ignoreDiscriminator: boolean): Season;
declare function SeasonToJSON(json: any): Season;
declare function SeasonToJSONTyped(value?: Season | null, ignoreDiscriminator?: boolean): any;

interface Seasons {
    seasons?: Array<Season>;
}
declare function instanceOfSeasons(value: object): value is Seasons;
declare function SeasonsFromJSON(json: any): Seasons;
declare function SeasonsFromJSONTyped(json: any, ignoreDiscriminator: boolean): Seasons;
declare function SeasonsToJSON(json: any): Seasons;
declare function SeasonsToJSONTyped(value?: Seasons | null, ignoreDiscriminator?: boolean): any;

interface Teams {
    teams?: Array<Team>;
}
declare function instanceOfTeams(value: object): value is Teams;
declare function TeamsFromJSON(json: any): Teams;
declare function TeamsFromJSONTyped(json: any, ignoreDiscriminator: boolean): Teams;
declare function TeamsToJSON(json: any): Teams;
declare function TeamsToJSONTyped(value?: Teams | null, ignoreDiscriminator?: boolean): any;

interface GetAllSeasonsRequest {
    sportId: number;
}
interface GetBoxscoreRequest {
    gamePk: number;
    fields?: Array<string>;
}
interface GetLinescoreRequest {
    gamePk: number;
    fields?: Array<string>;
}
interface GetScheduleRequest {
    sportId: number;
    teamId?: number;
    gameTypes?: Array<GameType>;
    startDate?: string;
    endDate?: string;
    fields?: Array<string>;
    hydrate?: string;
}
interface GetSeasonRequest {
    sportId: number;
    season: string;
}
interface GetStandingsRequest {
    leagueId: number;
    season: string;
    date?: string;
    fields?: Array<string>;
    hydrate?: string;
}
interface GetTeamsRequest {
    sportId: number;
    season: string;
    leagueIds?: Array<number>;
}
declare class MlbApi extends BaseAPI {
    getAllSeasonsRaw(requestParameters: GetAllSeasonsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<Seasons>>;
    getAllSeasons(requestParameters: GetAllSeasonsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<Seasons>;
    getBoxscoreRaw(requestParameters: GetBoxscoreRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<Boxscore>>;
    getBoxscore(requestParameters: GetBoxscoreRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<Boxscore>;
    getLinescoreRaw(requestParameters: GetLinescoreRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<Linescore>>;
    getLinescore(requestParameters: GetLinescoreRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<Linescore>;
    getScheduleRaw(requestParameters: GetScheduleRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<Schedule>>;
    getSchedule(requestParameters: GetScheduleRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<Schedule>;
    getSeasonRaw(requestParameters: GetSeasonRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<Seasons>>;
    getSeason(requestParameters: GetSeasonRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<Seasons>;
    getStandingsRaw(requestParameters: GetStandingsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<DivisionStandingsList>>;
    getStandings(requestParameters: GetStandingsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<DivisionStandingsList>;
    getTeamsRaw(requestParameters: GetTeamsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<Teams>>;
    getTeams(requestParameters: GetTeamsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<Teams>;
}

export { type ApiResponse, BASE_PATH, BaseAPI, BlobApiResponse, type Boxscore, BoxscoreFromJSON, BoxscoreFromJSONTyped, type BoxscoreTeams, BoxscoreTeamsFromJSON, BoxscoreTeamsFromJSONTyped, BoxscoreTeamsToJSON, BoxscoreTeamsToJSONTyped, BoxscoreToJSON, BoxscoreToJSONTyped, COLLECTION_FORMATS, Configuration, type ConfigurationParameters, type Consume, DefaultConfig, type Division, DivisionFromJSON, DivisionFromJSONTyped, type DivisionStandings, DivisionStandingsFromJSON, DivisionStandingsFromJSONTyped, type DivisionStandingsList, DivisionStandingsListFromJSON, DivisionStandingsListFromJSONTyped, DivisionStandingsListToJSON, DivisionStandingsListToJSONTyped, DivisionStandingsToJSON, DivisionStandingsToJSONTyped, DivisionToJSON, DivisionToJSONTyped, type ErrorContext, type FetchAPI, FetchError, type FetchParams, type Game, GameFromJSON, GameFromJSONTyped, type GameOfficial, GameOfficialFromJSON, GameOfficialFromJSONTyped, GameOfficialToJSON, GameOfficialToJSONTyped, type GameStatus, GameStatusCode, GameStatusCodeFromJSON, GameStatusCodeFromJSONTyped, GameStatusCodeToJSON, GameStatusCodeToJSONTyped, GameStatusFromJSON, GameStatusFromJSONTyped, GameStatusToJSON, GameStatusToJSONTyped, type GameTeam, GameTeamFromJSON, GameTeamFromJSONTyped, GameTeamToJSON, GameTeamToJSONTyped, type GameTeams, GameTeamsFromJSON, GameTeamsFromJSONTyped, GameTeamsToJSON, GameTeamsToJSONTyped, GameToJSON, GameToJSONTyped, GameType, GameTypeFromJSON, GameTypeFromJSONTyped, GameTypeToJSON, GameTypeToJSONTyped, type GetAllSeasonsRequest, type GetBoxscoreRequest, type GetLinescoreRequest, type GetScheduleRequest, type GetSeasonRequest, type GetStandingsRequest, type GetTeamsRequest, type HTTPBody, type HTTPHeaders, type HTTPMethod, type HTTPQuery, type HTTPRequestInit, type InitOverrideFunction, type Inning, InningFromJSON, InningFromJSONTyped, InningToJSON, InningToJSONTyped, JSONApiResponse, type Json, type League, type LeagueDates, LeagueDatesFromJSON, LeagueDatesFromJSONTyped, LeagueDatesToJSON, LeagueDatesToJSONTyped, LeagueFromJSON, LeagueFromJSONTyped, type LeagueRecord, LeagueRecordFromJSON, LeagueRecordFromJSONTyped, LeagueRecordToJSON, LeagueRecordToJSONTyped, LeagueToJSON, LeagueToJSONTyped, type Linescore, LinescoreFromJSON, LinescoreFromJSONTyped, type LinescoreTeam, LinescoreTeamFromJSON, LinescoreTeamFromJSONTyped, LinescoreTeamToJSON, LinescoreTeamToJSONTyped, type LinescoreTeams, LinescoreTeamsFromJSON, LinescoreTeamsFromJSONTyped, LinescoreTeamsToJSON, LinescoreTeamsToJSONTyped, LinescoreToJSON, LinescoreToJSONTyped, type Middleware, MlbApi, type ModelPropertyNaming, type Official, OfficialFromJSON, OfficialFromJSONTyped, OfficialToJSON, OfficialToJSONTyped, type Record, RecordFromJSON, RecordFromJSONTyped, RecordToJSON, RecordToJSONTyped, type RequestContext, type RequestOpts, RequiredError, type ResponseContext, ResponseError, type ResponseTransformer, type Schedule, type ScheduleDay, ScheduleDayFromJSON, ScheduleDayFromJSONTyped, ScheduleDayToJSON, ScheduleDayToJSONTyped, ScheduleFromJSON, ScheduleFromJSONTyped, ScheduleToJSON, ScheduleToJSONTyped, type Season, SeasonFromJSON, SeasonFromJSONTyped, SeasonToJSON, SeasonToJSONTyped, type Seasons, SeasonsFromJSON, SeasonsFromJSONTyped, SeasonsToJSON, SeasonsToJSONTyped, type Sport, SportFromJSON, SportFromJSONTyped, SportToJSON, SportToJSONTyped, type Streak, StreakFromJSON, StreakFromJSONTyped, StreakStreakTypeEnum, StreakToJSON, StreakToJSONTyped, type Team, TeamFromJSON, TeamFromJSONTyped, TeamToJSON, TeamToJSONTyped, type Teams, TeamsFromJSON, TeamsFromJSONTyped, TeamsToJSON, TeamsToJSONTyped, TextApiResponse, type Venue, VenueFromJSON, VenueFromJSONTyped, VenueToJSON, VenueToJSONTyped, VoidApiResponse, canConsumeForm, instanceOfBoxscore, instanceOfBoxscoreTeams, instanceOfDivision, instanceOfDivisionStandings, instanceOfDivisionStandingsList, instanceOfGame, instanceOfGameOfficial, instanceOfGameStatus, instanceOfGameStatusCode, instanceOfGameTeam, instanceOfGameTeams, instanceOfGameType, instanceOfInning, instanceOfLeague, instanceOfLeagueDates, instanceOfLeagueRecord, instanceOfLinescore, instanceOfLinescoreTeam, instanceOfLinescoreTeams, instanceOfOfficial, instanceOfRecord, instanceOfSchedule, instanceOfScheduleDay, instanceOfSeason, instanceOfSeasons, instanceOfSport, instanceOfStreak, instanceOfTeam, instanceOfTeams, instanceOfVenue, mapValues, querystring };