iracing-data-api/dist/index.d.ts

Javascript client for iracing API

import humps from 'humps';

type Options = {
    logger?: boolean;
    manageRateLimit?: boolean;
    rateLimitPadding?: number;
};
type FetchCookie = {
    (input: RequestInfo | URL, init?: RequestInit | undefined): Promise<Response>;
};

interface RateLimit {
    limit: number;
    remaining: number;
    reset: Date;
}
declare class RateLimiter {
    isActive: boolean;
    rateLimit: RateLimit | undefined;
    limitPadding: number;
    logger: (...args: unknown[]) => void;
    constructor(options: Options);
    updateRateLimit: (response: Response) => void;
    checkRateLimit: () => boolean;
    waitForReset: () => Promise<void>;
    _getRateLimit: (response: Response) => RateLimit;
}

declare class API {
    fetchCookie: FetchCookie;
    options: Options;
    rateLimiter: RateLimiter;
    logger: (...args: unknown[]) => void;
    constructor(fetchCookie: FetchCookie, options: Options, rateLimiter: RateLimiter);
    _getData: <Data = Record<string, unknown>, Parameters_1 = void>(endpoint: string, params?: Parameters_1 | Record<string, unknown>) => Promise<Data>;
    _getLinkData: (link: string) => Promise<humps.Camelized<any>>;
    _getUrl: <Parameters_1 = Record<string, unknown>>(endpoint: string, params?: Parameters_1) => string;
    _getChunks: (chunks: Record<string, any>) => Promise<any[]>;
}

declare class CarAPI extends API {
    assets: () => Promise<any>;
    get: () => Promise<any>;
}

declare class CarclassAPI extends API {
    get: () => Promise<any>;
}

declare class ConstantsAPI extends API {
    categories: () => Promise<any>;
    divisions: () => Promise<any>;
    eventTypes: () => Promise<any>;
}

declare class DriverStatsByCategoryAPI extends API {
    oval: () => Promise<any>;
    sportsCar: () => Promise<any>;
    formulaCar: () => Promise<any>;
    road: () => Promise<any>;
    dirtOval: () => Promise<any>;
    dirtRoad: () => Promise<any>;
}

type HostedCombinedSessionsParams = {
    packageId?: number;
};

declare class HostedAPI extends API {
    combinedSessions: (params: HostedCombinedSessionsParams) => Promise<any>;
    sessions: () => Promise<any>;
}

type LeagueCustLeagueSessionsParams = {
    mine?: boolean;
    packageId?: number;
};
type LeagueDirectoryParams = {
    search?: string;
    tag?: string;
    restrictToMember?: boolean;
    restrictToRecruiting?: boolean;
    restrictToFriends?: boolean;
    restrictToWatched?: boolean;
    minimumRosterCount?: number;
    maximumRosterCount?: number;
    lowerbound?: number;
    upperbound?: number;
    sort?: string;
    order?: string;
};
type LeagueGetParams = {
    leagueId: number;
    includeLicenses?: boolean;
};
type LeagueGetPointsSystemsParams = {
    leagueId: number;
    seasonId?: number;
};
type LeagueMembershipParams = {
    custId?: number;
    includeLeague?: boolean;
};
type LeagueRosterParams = {
    leagueId: number;
    includeLicenses?: boolean;
};
type LeagueSeasonsParams = {
    leagueId: number;
    retired?: boolean;
};
type LeagueSeasonStandingsParams = {
    leagueId: number;
    seasonId: number;
    carClassId?: number;
    carId?: number;
};
type LeagueSeasonSessionsParams = {
    leagueId: number;
    seasonId: number;
    resultsOnly?: boolean;
};

declare class LeagueAPI extends API {
    custLeagueSessions: (params: LeagueCustLeagueSessionsParams) => Promise<any>;
    directory: (params: LeagueDirectoryParams) => Promise<any>;
    get: (params: LeagueGetParams) => Promise<any>;
    getPointsSystems: (params: LeagueGetPointsSystemsParams) => Promise<any>;
    membership: (params: LeagueMembershipParams) => Promise<any>;
    roster: (params: LeagueRosterParams) => Promise<any>;
    seasons: (params: LeagueSeasonsParams) => Promise<any>;
    seasonStandings: (params: LeagueSeasonStandingsParams) => Promise<any>;
    seasonSessions: (params: LeagueSeasonSessionsParams) => Promise<any>;
}

type LookupClubHistoryParams = {
    seasonYear: number;
    seasonQuarter: number;
};
type LookupDriversParams = {
    searchTerm: string;
    leagueId?: number;
};

declare class LookupAPI extends API {
    clubHistory: (params: LookupClubHistoryParams) => Promise<any>;
    countries: () => Promise<any>;
    drivers: (params: LookupDriversParams) => Promise<any>;
    get: () => Promise<any>;
    licenses: () => Promise<any>;
}

type MemberAwardsParams = {
    custId?: number;
};
type MemberChartDataParams = {
    custId?: number;
    categoryId: number;
    chartType: number;
};
type MemberGetParams = {
    custIds: number[];
    includeLicenses?: boolean;
};
type MemberProfileParams = {
    custId?: number;
};

declare class MemberAPI extends API {
    awards: (params: MemberAwardsParams) => Promise<any>;
    chartData: (params: MemberChartDataParams) => Promise<any>;
    get: (params: MemberGetParams) => Promise<any>;
    info: () => Promise<any>;
    participationCredits: () => Promise<any>;
    profile: (params: MemberProfileParams) => Promise<any>;
}

type ResultsGetParams = {
    subsessionId: number;
    includeLicenses?: boolean;
};
type ResultsEventLogParams = {
    subsessionId: number;
    simsessionNumber: number;
};
type ResultsLapChartDataParams = {
    subsessionId: number;
    simsessionNumber: number;
};
type ResultsLapDataParams = {
    subsessionId: number;
    simsessionNumber: number;
    custId?: number;
    teamId?: number;
};
type ResultsSearchHostedParams = {
    startRangeBegin?: string;
    startRangeEnd?: string;
    finishRangeBegin?: string;
    finishRangeEnd?: string;
    custId?: number;
    teamId?: number;
    hostCustId?: number;
    sessionName?: string;
    leagueId?: number;
    leagueSeasonId?: number;
    carId?: number;
    trackId?: number;
    categoryIds?: number[];
};
type ResultsSearchSeriesParams = {
    seasonYear?: number;
    seasonQuarter?: number;
    startRangeBegin?: string;
    startRangeEnd?: string;
    finishRangeBegin?: string;
    finishRangeEnd?: string;
    custId?: number;
    teamId?: number;
    seriesId?: number;
    raceWeekNum?: number;
    officialOnly?: boolean;
    eventTypes?: number[];
    categoryIds?: number[];
};
type ResultsSeasonResultsParams = {
    seasonId: number;
    eventType?: number;
    raceWeekNum?: number;
};

declare class ResultsAPI extends API {
    get: (params: ResultsGetParams) => Promise<any>;
    eventLog: (params: ResultsEventLogParams) => Promise<any>;
    lapChartData: (params: ResultsLapChartDataParams) => Promise<any>;
    lapData: (params: ResultsLapDataParams) => Promise<any>;
    searchHosted: (params: ResultsSearchHostedParams) => Promise<any>;
    searchSeries: (params: ResultsSearchSeriesParams) => Promise<any>;
    seasonResults: (params: ResultsSeasonResultsParams) => Promise<any>;
}

type SeasonListParams = {
    seasonYear: number;
    seasonQuarter: number;
};
type SeasonRaceGuideParams = {
    from?: string;
    includeEndAfterFrom?: boolean;
};
type SeasonSpectatorSubsessionidsParams = {
    eventTypes?: number[];
};
type SeasonSpectatorSubsessionidsDetailParams = {
    eventTypes?: number[];
    seasonIds?: number[];
};

declare class SeasonAPI extends API {
    list: (params: SeasonListParams) => Promise<any>;
    raceGuide: (params: SeasonRaceGuideParams) => Promise<any>;
    spectatorSubsessionids: (params: SeasonSpectatorSubsessionidsParams) => Promise<any>;
    spectatorSubsessionidsDetail: (params: SeasonSpectatorSubsessionidsDetailParams) => Promise<any>;
}

type SeriesPastSeasonsParams = {
    seriesId: number;
};
type SeriesSeasonsParams = {
    includeSeries?: boolean;
};

declare class SeriesAPI extends API {
    assets: () => Promise<any>;
    get: () => Promise<any>;
    pastSeasons: (params: SeriesPastSeasonsParams) => Promise<any>;
    seasons: (params: SeriesSeasonsParams) => Promise<any>;
    statsSeries: () => Promise<any>;
}

type StatsMemberBestsParams = {
    custId?: number;
    carId?: number;
};
type StatsMemberCareerParams = {
    custId?: number;
};
type StatsMemberDivisionParams = {
    seasonId: number;
    eventType: number;
};
type StatsMemberRecapParams = {
    custId?: number;
    year?: number;
    season?: number;
};
type StatsMemberRecentRacesParams = {
    custId?: number;
};
type StatsMemberSummaryParams = {
    custId?: number;
};
type StatsMemberYearlyParams = {
    custId?: number;
};
type StatsSeasonDriverStandingsParams = {
    seasonId: number;
    carClassId: number;
    clubId?: number;
    division?: number;
    raceWeekNum?: number;
};
type StatsSeasonSupersessionStandingsParams = {
    seasonId: number;
    carClassId: number;
    clubId?: number;
    division?: number;
    raceWeekNum?: number;
};
type StatsSeasonTeamStandingsParams = {
    seasonId: number;
    carClassId: number;
    raceWeekNum?: number;
};
type StatsSeasonTtStandingsParams = {
    seasonId: number;
    carClassId: number;
    clubId?: number;
    division?: number;
    raceWeekNum?: number;
};
type StatsSeasonTtResultsParams = {
    seasonId: number;
    carClassId: number;
    raceWeekNum: number;
    clubId?: number;
    division?: number;
};
type StatsSeasonQualifyResultsParams = {
    seasonId: number;
    carClassId: number;
    raceWeekNum: number;
    clubId?: number;
    division?: number;
};
type StatsWorldRecordsParams = {
    carId: number;
    trackId: number;
    seasonYear?: number;
    seasonQuarter?: number;
};

declare class StatsAPI extends API {
    memberBests: (params: StatsMemberBestsParams) => Promise<any>;
    memberCareer: (params: StatsMemberCareerParams) => Promise<any>;
    memberDivision: (params: StatsMemberDivisionParams) => Promise<any>;
    memberRecap: (params: StatsMemberRecapParams) => Promise<any>;
    memberRecentRaces: (params: StatsMemberRecentRacesParams) => Promise<any>;
    memberSummary: (params: StatsMemberSummaryParams) => Promise<any>;
    memberYearly: (params: StatsMemberYearlyParams) => Promise<any>;
    seasonDriverStandings: (params: StatsSeasonDriverStandingsParams) => Promise<any>;
    seasonSupersessionStandings: (params: StatsSeasonSupersessionStandingsParams) => Promise<any>;
    seasonTeamStandings: (params: StatsSeasonTeamStandingsParams) => Promise<any>;
    seasonTtStandings: (params: StatsSeasonTtStandingsParams) => Promise<any>;
    seasonTtResults: (params: StatsSeasonTtResultsParams) => Promise<any>;
    seasonQualifyResults: (params: StatsSeasonQualifyResultsParams) => Promise<any>;
    worldRecords: (params: StatsWorldRecordsParams) => Promise<any>;
}

type TeamGetParams = {
    teamId: number;
    includeLicenses?: boolean;
};

declare class TeamAPI extends API {
    get: (params: TeamGetParams) => Promise<any>;
}

type TimeAttackMemberSeasonResultsParams = {
    taCompSeasonId: number;
};

declare class TimeAttackAPI extends API {
    memberSeasonResults: (params: TimeAttackMemberSeasonResultsParams) => Promise<any>;
}

declare class TrackAPI extends API {
    assets: () => Promise<any>;
    get: () => Promise<any>;
}

declare const API_URL = "https://members-ng.iracing.com/";
declare const DEFAULT_OPTIONS: {
    logger: boolean;
    manageRateLimit: boolean;
    rateLimitPadding: number;
};

declare class IracingDataApiException extends Error {
    statusCode: number;
    endpoint: string;
    constructor(statusCode: number, endpoint: string, message: string);
}

declare class IracingAPI {
    fetchCookie: FetchCookie;
    options: Options;
    rateLimiter: RateLimiter;
    logger: (...args: unknown[]) => void;
    car: CarAPI;
    carclass: CarclassAPI;
    constants: ConstantsAPI;
    driverStatsByCategory: DriverStatsByCategoryAPI;
    hosted: HostedAPI;
    league: LeagueAPI;
    lookup: LookupAPI;
    member: MemberAPI;
    results: ResultsAPI;
    season: SeasonAPI;
    series: SeriesAPI;
    stats: StatsAPI;
    team: TeamAPI;
    timeAttack: TimeAttackAPI;
    track: TrackAPI;
    constructor(options?: Options);
    login: (email: string, password: string) => Promise<any>;
}

export { API_URL, DEFAULT_OPTIONS, type FetchCookie, type HostedCombinedSessionsParams, IracingDataApiException, type LeagueCustLeagueSessionsParams, type LeagueDirectoryParams, type LeagueGetParams, type LeagueGetPointsSystemsParams, type LeagueMembershipParams, type LeagueRosterParams, type LeagueSeasonSessionsParams, type LeagueSeasonStandingsParams, type LeagueSeasonsParams, type LookupClubHistoryParams, type LookupDriversParams, type MemberAwardsParams, type MemberChartDataParams, type MemberGetParams, type MemberProfileParams, type Options, type ResultsEventLogParams, type ResultsGetParams, type ResultsLapChartDataParams, type ResultsLapDataParams, type ResultsSearchHostedParams, type ResultsSearchSeriesParams, type ResultsSeasonResultsParams, type SeasonListParams, type SeasonRaceGuideParams, type SeasonSpectatorSubsessionidsDetailParams, type SeasonSpectatorSubsessionidsParams, type SeriesPastSeasonsParams, type SeriesSeasonsParams, type TeamGetParams, type TimeAttackMemberSeasonResultsParams, IracingAPI as default };