iracing-data-sdk/dist/index.d.mts

A comprehensive TypeScript SDK for the iRacing Data API with support for all documented endpoints

import { z } from 'zod';

declare const AuthRequestSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>;
type AuthRequest = z.infer<typeof AuthRequestSchema>;
declare const AuthResponseSchema: z.ZodObject<{
    authcode: z.ZodString;
    ssoCookieValue: z.ZodString;
    custId: z.ZodNumber;
    email: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    authcode: string;
    ssoCookieValue: string;
    custId: number;
}, {
    email: string;
    authcode: string;
    ssoCookieValue: string;
    custId: number;
}>;
type AuthResponse = z.infer<typeof AuthResponseSchema>;
declare const HostedCombinedSessionsParamsSchema: z.ZodObject<{
    package_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    package_id?: number | undefined;
}, {
    package_id?: number | undefined;
}>;
type HostedCombinedSessionsParams = z.infer<typeof HostedCombinedSessionsParamsSchema>;
declare const LeagueCustLeagueSessionsParamsSchema: z.ZodObject<{
    mine: z.ZodOptional<z.ZodBoolean>;
    package_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    package_id?: number | undefined;
    mine?: boolean | undefined;
}, {
    package_id?: number | undefined;
    mine?: boolean | undefined;
}>;
type LeagueCustLeagueSessionsParams = z.infer<typeof LeagueCustLeagueSessionsParamsSchema>;
declare const LeagueDirectoryParamsSchema: z.ZodObject<{
    search: z.ZodOptional<z.ZodString>;
    tag: z.ZodOptional<z.ZodString>;
    restrict_to_member: z.ZodOptional<z.ZodBoolean>;
    restrict_to_recruiting: z.ZodOptional<z.ZodBoolean>;
    restrict_to_friends: z.ZodOptional<z.ZodBoolean>;
    restrict_to_watched: z.ZodOptional<z.ZodBoolean>;
    minimum_roster_count: z.ZodOptional<z.ZodNumber>;
    maximum_roster_count: z.ZodOptional<z.ZodNumber>;
    lowerbound: z.ZodOptional<z.ZodNumber>;
    upperbound: z.ZodOptional<z.ZodNumber>;
    sort: z.ZodOptional<z.ZodString>;
    order: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    sort?: string | undefined;
    search?: string | undefined;
    tag?: string | undefined;
    restrict_to_member?: boolean | undefined;
    restrict_to_recruiting?: boolean | undefined;
    restrict_to_friends?: boolean | undefined;
    restrict_to_watched?: boolean | undefined;
    minimum_roster_count?: number | undefined;
    maximum_roster_count?: number | undefined;
    lowerbound?: number | undefined;
    upperbound?: number | undefined;
    order?: string | undefined;
}, {
    sort?: string | undefined;
    search?: string | undefined;
    tag?: string | undefined;
    restrict_to_member?: boolean | undefined;
    restrict_to_recruiting?: boolean | undefined;
    restrict_to_friends?: boolean | undefined;
    restrict_to_watched?: boolean | undefined;
    minimum_roster_count?: number | undefined;
    maximum_roster_count?: number | undefined;
    lowerbound?: number | undefined;
    upperbound?: number | undefined;
    order?: string | undefined;
}>;
type LeagueDirectoryParams = z.infer<typeof LeagueDirectoryParamsSchema>;
declare const LeagueGetParamsSchema: z.ZodObject<{
    league_id: z.ZodNumber;
    include_licenses: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    league_id: number;
    include_licenses?: boolean | undefined;
}, {
    league_id: number;
    include_licenses?: boolean | undefined;
}>;
type LeagueGetParams = z.infer<typeof LeagueGetParamsSchema>;
declare const LeaguePointsSystemsParamsSchema: z.ZodObject<{
    league_id: z.ZodNumber;
    season_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    league_id: number;
    season_id?: number | undefined;
}, {
    league_id: number;
    season_id?: number | undefined;
}>;
type LeaguePointsSystemsParams = z.infer<typeof LeaguePointsSystemsParamsSchema>;
declare const LeagueMembershipParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
    include_league: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
    include_league?: boolean | undefined;
}, {
    cust_id?: number | undefined;
    include_league?: boolean | undefined;
}>;
type LeagueMembershipParams = z.infer<typeof LeagueMembershipParamsSchema>;
declare const LeagueRosterParamsSchema: z.ZodObject<{
    league_id: z.ZodNumber;
    include_licenses: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    league_id: number;
    include_licenses?: boolean | undefined;
}, {
    league_id: number;
    include_licenses?: boolean | undefined;
}>;
type LeagueRosterParams = z.infer<typeof LeagueRosterParamsSchema>;
declare const LeagueSeasonsParamsSchema: z.ZodObject<{
    league_id: z.ZodNumber;
    retired: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    league_id: number;
    retired?: boolean | undefined;
}, {
    league_id: number;
    retired?: boolean | undefined;
}>;
type LeagueSeasonsParams = z.infer<typeof LeagueSeasonsParamsSchema>;
declare const LeagueSeasonStandingsParamsSchema: z.ZodObject<{
    league_id: z.ZodNumber;
    season_id: z.ZodNumber;
    car_class_id: z.ZodOptional<z.ZodNumber>;
    car_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    league_id: number;
    season_id: number;
    car_class_id?: number | undefined;
    car_id?: number | undefined;
}, {
    league_id: number;
    season_id: number;
    car_class_id?: number | undefined;
    car_id?: number | undefined;
}>;
type LeagueSeasonStandingsParams = z.infer<typeof LeagueSeasonStandingsParamsSchema>;
declare const LeagueSeasonSessionsParamsSchema: z.ZodObject<{
    league_id: z.ZodNumber;
    season_id: z.ZodNumber;
    results_only: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    league_id: number;
    season_id: number;
    results_only?: boolean | undefined;
}, {
    league_id: number;
    season_id: number;
    results_only?: boolean | undefined;
}>;
type LeagueSeasonSessionsParams = z.infer<typeof LeagueSeasonSessionsParamsSchema>;
declare const LookupDriversParamsSchema: z.ZodObject<{
    search_term: z.ZodString;
    league_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    search_term: string;
    league_id?: number | undefined;
}, {
    search_term: string;
    league_id?: number | undefined;
}>;
type LookupDriversParams = z.infer<typeof LookupDriversParamsSchema>;
declare const MemberGetParamsSchema: z.ZodObject<{
    cust_ids: z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>;
    include_licenses: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    cust_ids: string;
    include_licenses?: boolean | undefined;
}, {
    cust_ids: number[];
    include_licenses?: boolean | undefined;
}>;
interface MemberGetParams {
    cust_ids: number[];
    include_licenses?: boolean;
}
declare const MemberAwardsParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
}, {
    cust_id?: number | undefined;
}>;
type MemberAwardsParams = z.infer<typeof MemberAwardsParamsSchema>;
declare const MemberAwardInstancesParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
    award_id: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    award_id: number;
    cust_id?: number | undefined;
}, {
    award_id: number;
    cust_id?: number | undefined;
}>;
type MemberAwardInstancesParams = z.infer<typeof MemberAwardInstancesParamsSchema>;
declare const MemberChartDataParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
    category_id: z.ZodNumber;
    chart_type: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    category_id: number;
    chart_type: number;
    cust_id?: number | undefined;
}, {
    category_id: number;
    chart_type: number;
    cust_id?: number | undefined;
}>;
type MemberChartDataParams = z.infer<typeof MemberChartDataParamsSchema>;
declare const MemberProfileParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
}, {
    cust_id?: number | undefined;
}>;
type MemberProfileParams = z.infer<typeof MemberProfileParamsSchema>;
declare const ResultsGetParamsSchema: z.ZodObject<{
    subsession_id: z.ZodNumber;
    include_licenses: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    subsession_id: number;
    include_licenses?: boolean | undefined;
}, {
    subsession_id: number;
    include_licenses?: boolean | undefined;
}>;
type ResultsGetParams = z.infer<typeof ResultsGetParamsSchema>;
declare const EventLogParamsSchema: z.ZodObject<{
    subsession_id: z.ZodNumber;
    simsession_number: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    subsession_id: number;
    simsession_number: number;
}, {
    subsession_id: number;
    simsession_number: number;
}>;
type EventLogParams = z.infer<typeof EventLogParamsSchema>;
declare const LapChartDataParamsSchema: z.ZodObject<{
    subsession_id: z.ZodNumber;
    simsession_number: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    subsession_id: number;
    simsession_number: number;
}, {
    subsession_id: number;
    simsession_number: number;
}>;
type LapChartDataParams = z.infer<typeof LapChartDataParamsSchema>;
declare const LapDataParamsSchema: z.ZodObject<{
    subsession_id: z.ZodNumber;
    simsession_number: z.ZodNumber;
    cust_id: z.ZodOptional<z.ZodNumber>;
    team_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    subsession_id: number;
    simsession_number: number;
    cust_id?: number | undefined;
    team_id?: number | undefined;
}, {
    subsession_id: number;
    simsession_number: number;
    cust_id?: number | undefined;
    team_id?: number | undefined;
}>;
type LapDataParams = z.infer<typeof LapDataParamsSchema>;
declare const ResultsSearchHostedParamsSchema: z.ZodObject<{
    start_range_begin: z.ZodOptional<z.ZodString>;
    start_range_end: z.ZodOptional<z.ZodString>;
    finish_range_begin: z.ZodOptional<z.ZodString>;
    finish_range_end: z.ZodOptional<z.ZodString>;
    cust_id: z.ZodOptional<z.ZodNumber>;
    team_id: z.ZodOptional<z.ZodNumber>;
    host_cust_id: z.ZodOptional<z.ZodNumber>;
    session_name: z.ZodOptional<z.ZodString>;
    league_id: z.ZodOptional<z.ZodNumber>;
    league_season_id: z.ZodOptional<z.ZodNumber>;
    car_id: z.ZodOptional<z.ZodNumber>;
    track_id: z.ZodOptional<z.ZodNumber>;
    category_ids: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>>;
}, "strip", z.ZodTypeAny, {
    league_id?: number | undefined;
    cust_id?: number | undefined;
    car_id?: number | undefined;
    team_id?: number | undefined;
    start_range_begin?: string | undefined;
    start_range_end?: string | undefined;
    finish_range_begin?: string | undefined;
    finish_range_end?: string | undefined;
    host_cust_id?: number | undefined;
    session_name?: string | undefined;
    league_season_id?: number | undefined;
    track_id?: number | undefined;
    category_ids?: string | undefined;
}, {
    league_id?: number | undefined;
    cust_id?: number | undefined;
    car_id?: number | undefined;
    team_id?: number | undefined;
    start_range_begin?: string | undefined;
    start_range_end?: string | undefined;
    finish_range_begin?: string | undefined;
    finish_range_end?: string | undefined;
    host_cust_id?: number | undefined;
    session_name?: string | undefined;
    league_season_id?: number | undefined;
    track_id?: number | undefined;
    category_ids?: number[] | undefined;
}>;
interface ResultsSearchHostedParams {
    start_range_begin?: string;
    start_range_end?: string;
    finish_range_begin?: string;
    finish_range_end?: string;
    cust_id?: number;
    team_id?: number;
    host_cust_id?: number;
    session_name?: string;
    league_id?: number;
    league_season_id?: number;
    car_id?: number;
    track_id?: number;
    category_ids?: number[];
}
declare const ResultsSearchSeriesParamsSchema: z.ZodObject<{
    season_year: z.ZodOptional<z.ZodNumber>;
    season_quarter: z.ZodOptional<z.ZodNumber>;
    start_range_begin: z.ZodOptional<z.ZodString>;
    start_range_end: z.ZodOptional<z.ZodString>;
    finish_range_begin: z.ZodOptional<z.ZodString>;
    finish_range_end: z.ZodOptional<z.ZodString>;
    cust_id: z.ZodOptional<z.ZodNumber>;
    team_id: z.ZodOptional<z.ZodNumber>;
    series_id: z.ZodOptional<z.ZodNumber>;
    race_week_num: z.ZodOptional<z.ZodNumber>;
    official_only: z.ZodOptional<z.ZodBoolean>;
    event_types: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>>;
    category_ids: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
    team_id?: number | undefined;
    start_range_begin?: string | undefined;
    start_range_end?: string | undefined;
    finish_range_begin?: string | undefined;
    finish_range_end?: string | undefined;
    category_ids?: string | undefined;
    season_year?: number | undefined;
    season_quarter?: number | undefined;
    series_id?: number | undefined;
    race_week_num?: number | undefined;
    official_only?: boolean | undefined;
    event_types?: string | undefined;
}, {
    cust_id?: number | undefined;
    team_id?: number | undefined;
    start_range_begin?: string | undefined;
    start_range_end?: string | undefined;
    finish_range_begin?: string | undefined;
    finish_range_end?: string | undefined;
    category_ids?: number[] | undefined;
    season_year?: number | undefined;
    season_quarter?: number | undefined;
    series_id?: number | undefined;
    race_week_num?: number | undefined;
    official_only?: boolean | undefined;
    event_types?: number[] | undefined;
}>;
interface ResultsSearchSeriesParams {
    season_year?: number;
    season_quarter?: number;
    start_range_begin?: string;
    start_range_end?: string;
    finish_range_begin?: string;
    finish_range_end?: string;
    cust_id?: number;
    team_id?: number;
    series_id?: number;
    race_week_num?: number;
    official_only?: boolean;
    event_types?: number[];
    category_ids?: number[];
}
declare const SeasonResultsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    event_type: z.ZodOptional<z.ZodNumber>;
    race_week_num: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    race_week_num?: number | undefined;
    event_type?: number | undefined;
}, {
    season_id: number;
    race_week_num?: number | undefined;
    event_type?: number | undefined;
}>;
type SeasonResultsParams = z.infer<typeof SeasonResultsParamsSchema>;
declare const SeasonListParamsSchema: z.ZodObject<{
    season_year: z.ZodNumber;
    season_quarter: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    season_year: number;
    season_quarter: number;
}, {
    season_year: number;
    season_quarter: number;
}>;
type SeasonListParams = z.infer<typeof SeasonListParamsSchema>;
declare const SeasonRaceGuideParamsSchema: z.ZodObject<{
    from: z.ZodOptional<z.ZodString>;
    include_end_after_from: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    from?: string | undefined;
    include_end_after_from?: boolean | undefined;
}, {
    from?: string | undefined;
    include_end_after_from?: boolean | undefined;
}>;
type SeasonRaceGuideParams = z.infer<typeof SeasonRaceGuideParamsSchema>;
declare const SeasonSpectatorSubsessionIdsParamsSchema: z.ZodObject<{
    event_types: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>>;
}, "strip", z.ZodTypeAny, {
    event_types?: string | undefined;
}, {
    event_types?: number[] | undefined;
}>;
interface SeasonSpectatorSubsessionIdsParams {
    event_types?: number[];
}
declare const SeasonSpectatorSubsessionIdsDetailParamsSchema: z.ZodObject<{
    event_types: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>>;
    season_ids: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, string, number[]>>;
}, "strip", z.ZodTypeAny, {
    event_types?: string | undefined;
    season_ids?: string | undefined;
}, {
    event_types?: number[] | undefined;
    season_ids?: number[] | undefined;
}>;
interface SeasonSpectatorSubsessionIdsDetailParams {
    event_types?: number[];
    season_ids?: number[];
}
declare const SeriesPastSeasonsParamsSchema: z.ZodObject<{
    series_id: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    series_id: number;
}, {
    series_id: number;
}>;
type SeriesPastSeasonsParams = z.infer<typeof SeriesPastSeasonsParamsSchema>;
declare const SeriesSeasonsParamsSchema: z.ZodObject<{
    include_series: z.ZodOptional<z.ZodBoolean>;
    season_year: z.ZodOptional<z.ZodNumber>;
    season_quarter: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_year?: number | undefined;
    season_quarter?: number | undefined;
    include_series?: boolean | undefined;
}, {
    season_year?: number | undefined;
    season_quarter?: number | undefined;
    include_series?: boolean | undefined;
}>;
type SeriesSeasonsParams = z.infer<typeof SeriesSeasonsParamsSchema>;
declare const SeriesSeasonListParamsSchema: z.ZodObject<{
    include_series: z.ZodOptional<z.ZodBoolean>;
    season_year: z.ZodOptional<z.ZodNumber>;
    season_quarter: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_year?: number | undefined;
    season_quarter?: number | undefined;
    include_series?: boolean | undefined;
}, {
    season_year?: number | undefined;
    season_quarter?: number | undefined;
    include_series?: boolean | undefined;
}>;
type SeriesSeasonListParams = z.infer<typeof SeriesSeasonListParamsSchema>;
declare const SeriesSeasonScheduleParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    season_id: number;
}, {
    season_id: number;
}>;
type SeriesSeasonScheduleParams = z.infer<typeof SeriesSeasonScheduleParamsSchema>;
declare const StatsMemberBestsParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
    car_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
    car_id?: number | undefined;
}, {
    cust_id?: number | undefined;
    car_id?: number | undefined;
}>;
type StatsMemberBestsParams = z.infer<typeof StatsMemberBestsParamsSchema>;
declare const StatsMemberCareerParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
}, {
    cust_id?: number | undefined;
}>;
type StatsMemberCareerParams = z.infer<typeof StatsMemberCareerParamsSchema>;
declare const StatsMemberDivisionParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    event_type: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    event_type: number;
}, {
    season_id: number;
    event_type: number;
}>;
type StatsMemberDivisionParams = z.infer<typeof StatsMemberDivisionParamsSchema>;
declare const StatsMemberRecapParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
    year: z.ZodOptional<z.ZodNumber>;
    season: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
    year?: number | undefined;
    season?: number | undefined;
}, {
    cust_id?: number | undefined;
    year?: number | undefined;
    season?: number | undefined;
}>;
type StatsMemberRecapParams = z.infer<typeof StatsMemberRecapParamsSchema>;
declare const StatsMemberRecentRacesParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
}, {
    cust_id?: number | undefined;
}>;
type StatsMemberRecentRacesParams = z.infer<typeof StatsMemberRecentRacesParamsSchema>;
declare const StatsMemberSummaryParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
}, {
    cust_id?: number | undefined;
}>;
type StatsMemberSummaryParams = z.infer<typeof StatsMemberSummaryParamsSchema>;
declare const StatsMemberYearlyParamsSchema: z.ZodObject<{
    cust_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    cust_id?: number | undefined;
}, {
    cust_id?: number | undefined;
}>;
type StatsMemberYearlyParams = z.infer<typeof StatsMemberYearlyParamsSchema>;
declare const StatsSeasonDriverStandingsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    car_class_id: z.ZodNumber;
    division: z.ZodOptional<z.ZodNumber>;
    race_week_num: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
    division?: number | undefined;
}, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
    division?: number | undefined;
}>;
type StatsSeasonDriverStandingsParams = z.infer<typeof StatsSeasonDriverStandingsParamsSchema>;
declare const StatsSeasonSupersessionStandingsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    car_class_id: z.ZodNumber;
    division: z.ZodOptional<z.ZodNumber>;
    race_week_num: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
    division?: number | undefined;
}, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
    division?: number | undefined;
}>;
type StatsSeasonSupersessionStandingsParams = z.infer<typeof StatsSeasonSupersessionStandingsParamsSchema>;
declare const StatsSeasonTeamStandingsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    car_class_id: z.ZodNumber;
    race_week_num: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
}, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
}>;
type StatsSeasonTeamStandingsParams = z.infer<typeof StatsSeasonTeamStandingsParamsSchema>;
declare const StatsSeasonTTStandingsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    car_class_id: z.ZodNumber;
    division: z.ZodOptional<z.ZodNumber>;
    race_week_num: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
    division?: number | undefined;
}, {
    season_id: number;
    car_class_id: number;
    race_week_num?: number | undefined;
    division?: number | undefined;
}>;
type StatsSeasonTTStandingsParams = z.infer<typeof StatsSeasonTTStandingsParamsSchema>;
declare const StatsSeasonTTResultsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    car_class_id: z.ZodNumber;
    race_week_num: z.ZodNumber;
    division: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    car_class_id: number;
    race_week_num: number;
    division?: number | undefined;
}, {
    season_id: number;
    car_class_id: number;
    race_week_num: number;
    division?: number | undefined;
}>;
type StatsSeasonTTResultsParams = z.infer<typeof StatsSeasonTTResultsParamsSchema>;
declare const StatsSeasonQualifyResultsParamsSchema: z.ZodObject<{
    season_id: z.ZodNumber;
    car_class_id: z.ZodNumber;
    race_week_num: z.ZodNumber;
    division: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    season_id: number;
    car_class_id: number;
    race_week_num: number;
    division?: number | undefined;
}, {
    season_id: number;
    car_class_id: number;
    race_week_num: number;
    division?: number | undefined;
}>;
type StatsSeasonQualifyResultsParams = z.infer<typeof StatsSeasonQualifyResultsParamsSchema>;
declare const StatsWorldRecordsParamsSchema: z.ZodObject<{
    car_id: z.ZodNumber;
    track_id: z.ZodNumber;
    season_year: z.ZodOptional<z.ZodNumber>;
    season_quarter: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    car_id: number;
    track_id: number;
    season_year?: number | undefined;
    season_quarter?: number | undefined;
}, {
    car_id: number;
    track_id: number;
    season_year?: number | undefined;
    season_quarter?: number | undefined;
}>;
type StatsWorldRecordsParams = z.infer<typeof StatsWorldRecordsParamsSchema>;
declare const TeamGetParamsSchema: z.ZodObject<{
    team_id: z.ZodNumber;
    include_licenses: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    team_id: number;
    include_licenses?: boolean | undefined;
}, {
    team_id: number;
    include_licenses?: boolean | undefined;
}>;
type TeamGetParams = z.infer<typeof TeamGetParamsSchema>;
declare const TimeAttackMemberSeasonResultsParamsSchema: z.ZodObject<{
    ta_comp_season_id: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    ta_comp_season_id: number;
}, {
    ta_comp_season_id: number;
}>;
type TimeAttackMemberSeasonResultsParams = z.infer<typeof TimeAttackMemberSeasonResultsParamsSchema>;
/**
 * License information structure used across multiple endpoints
 */
interface License {
    category_id: number;
    category: string;
    license_level: number;
    safety_rating: number;
    cpi: number;
    irating: number;
    tt_rating: number;
    mpr_num_races: number;
}
/**
 * Track configuration information
 */
interface TrackConfig {
    track_id: number;
    config_name: string;
    track_name: string;
    category_id: number;
    category: string;
    config_length_km: number;
    pkg_id: number;
    recently_added: boolean;
}
/**
 * Car information structure
 */
interface Car {
    car_id: number;
    car_name: string;
    car_name_abbreviated: string;
    car_dirpath: string;
    car_rules_category: string;
    car_weight: number;
    car_power: number;
    car_max_fuel_pct: number;
    car_types: CarType[];
    pkg_id: number;
    sku: number;
    recently_added: boolean;
    car_make: string;
    car_model: string;
    hp: number;
    price: number;
    price_display: string;
    free_with_subscription: boolean;
}
interface CarType {
    car_type: string;
}
/**
 * Standard pagination response wrapper
 */
interface PaginatedResponse<T> {
    data: T;
    success: boolean;
    chunk_info?: ChunkInfo;
    rate_limit_remaining?: number;
    rate_limit_reset?: number;
}
interface ChunkInfo {
    chunk_size: number;
    total_chunks: number;
    chunk_file_name: string;
    rows: number;
    base_download_url: string;
    chunk_file_names?: string[];
}
/**
 * Response containing car asset information including images and logos
 * Image paths are relative to https://images-static.iracing.com/
 */
interface CarAssetsResponse {
    /** Car asset rules organized by category */
    car_rules: CarRule[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Car asset rule containing cars grouped by category
 */
interface CarRule {
    /** Category identifier */
    category_id: number;
    /** Category name */
    category: string;
    /** Array of car assets in this category */
    cars: CarAsset[];
}
/**
 * Car asset containing image and logo information
 */
interface CarAsset {
    /** Unique car identifier */
    car_id: number;
    /** Full car name */
    car_name: string;
    /** Abbreviated car name */
    car_name_abbreviated: string;
    /** Path to car logo image */
    logo: string;
    /** Path to small car image */
    small_image: string;
    /** Path to large car image */
    large_image: string;
    /** Car directory path */
    car_dirpath: string;
}
/**
 * Response containing all available cars
 */
interface CarsResponse {
    /** Array of all cars */
    cars: Car[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Response containing all car classes
 */
interface CarClassesResponse {
    /** Array of car classes */
    carclass: CarClass[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Car class containing multiple cars with similar performance
 */
interface CarClass {
    /** Unique car class identifier */
    car_class_id: number;
    /** Array of cars in this class */
    cars_in_class: CarInClass[];
    /** Full car class name */
    name: string;
    /** Relative speed compared to other classes */
    relative_speed: number;
    /** Short car class name */
    short_name: string;
}
/**
 * Car reference within a car class
 */
interface CarInClass {
    /** Car directory path */
    car_dirpath: string;
    /** Unique car identifier */
    car_id: number;
}
/**
 * Response containing track categories (constant data)
 */
interface CategoriesResponse {
    /** Array of track categories */
    categories: Category[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Track category definition
 */
interface Category {
    /** Unique category identifier */
    category_id: number;
    /** Category name */
    category: string;
}
/**
 * Response containing license divisions (constant data)
 */
interface DivisionsResponse {
    /** Array of license divisions */
    divisions: Division[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * License division definition
 */
interface Division {
    /** Division number */
    division: number;
    /** Division name */
    division_name: string;
}
/**
 * Response containing event types (constant data)
 */
interface EventTypesResponse {
    /** Array of event types */
    event_types: EventType[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Event type definition
 */
interface EventType {
    /** Event type identifier */
    event_type: number;
    /** Event type name */
    event_type_name: string;
}
/**
 * Response containing driver statistics by category
 */
interface DriverStatsResponse {
    /** Array of driver statistics */
    stats: DriverStats[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Driver statistics for a specific category
 */
interface DriverStats {
    /** Customer ID */
    cust_id: number;
    /** Driver display name */
    display_name: string;
    /** Driver helmet configuration */
    helmet: Helmet;
    /** Last login timestamp */
    last_login: string;
    /** Member since timestamp */
    member_since: string;
    /** Club ID */
    club_id: number;
    /** Club name */
    club_name: string;
    /** Country code */
    country_code: string;
    /** Country name */
    country: string;
    /** Array of licenses */
    licenses: License[];
}
/**
 * Driver helmet configuration
 */
interface Helmet {
    /** Helmet pattern ID */
    pattern: number;
    /** Primary color */
    color1: string;
    /** Secondary color */
    color2: string;
    /** Tertiary color */
    color3: string;
    /** Face type ID */
    face_type: number;
    /** Helmet type ID */
    helmet_type: number;
}
/**
 * Response containing hosted sessions that can be joined
 */
interface HostedSessionsResponse {
    /** Array of hosted sessions */
    sessions: HostedSession[];
    /** Whether the request was successful */
    success: boolean;
}
/**
 * Hosted session information
 */
interface HostedSession {
    /** Subsession ID */
    subsession_id: number;
    /** Session ID */
    session_id: number;
    /** Session name */
    session_name: string;
    /** Host customer ID */
    host_id: number;
    /** Host display name */
    host_name: string;
    /** Session creation timestamp */
    created_time: string;
    /** Session start time */
    start_time: string;
    /** Session end time */
    end_time: string;
    /** Launch timestamp */
    launch_at: string;
    /** Registration opens timestamp */
    registration_opens: string;
    /** Registration closes timestamp */
    registration_closes: string;
    /** Session status */
    status: number;
    /** Current number of drivers */
    num_drivers: number;
    /** Maximum number of drivers */
    max_drivers: number;
    /** Whether telemetry recording is enabled */
    telemetry_recording_enabled: boolean;
    /** Telemetry force to disk setting */
    telemetry_force_to_disk: number;
    /** Order ID */
    order_id: number;
    /** Session price */
    price: number;
    /** Whether to skip car painting */
    do_not_paint_cars: boolean;
    /** Whether session is private */
    private_session: boolean;
    /** Season ID */
    season_id: number;
    /** Series ID */
    series_id: number;
    /** Array of car class IDs */
    car_class_ids: number[];
    /** Array of car types */
    car_types: CarType[];
    /** Track configuration */
    track: TrackConfig;
    /** Weather settings */
    weather: Weather;
    /** Track state */
    track_state: TrackState;
    /** League ID (optional) */
    league_id?: number;
    /** League name (optional) */
    league_name?: string;
    /** League season ID (optional) */
    league_season_id?: number;
    /** Entry count */
    entry_count: number;
    /** Whether user can spot */
    can_spot: boolean;
    /** Whether user can watch */
    can_watch: boolean;
    /** Whether user can drive */
    can_drive: boolean;
    /** Team entry count */
    team_entry_count: number;
}
interface Weather {
    type: number;
    temp_units: number;
    temp_value: number;
    rel_humidity: number;
    fog: number;
    wind_dir: number;
    wind_units: number;
    wind_value: number;
    skies: number;
    weather_var_initial: number;
    weather_var_ongoing: number;
    time_of_day: number;
    simulated_start_time: string;
    simulated_time_multiplier: number;
    simulated_time_offsets: number[];
}
interface TrackState {
    leave_marbles: boolean;
    practice_rubber: number;
    qualify_rubber: number;
    warmup_rubber: number;
    race_rubber: number;
    practice_grip_compound: number;
    qualify_grip_compound: number;
    warmup_grip_compound: number;
    race_grip_compound: number;
}
/**
 * Response containing league information
 */
interface LeagueResponse {
    /** League data */
    league: League;
    /** Whether the request was successful */
    success: boolean;
}
interface League {
    league_id: number;
    league_name: string;
    owner_id: number;
    owner_display_name: string;
    created: string;
    url: string;
    club_id: number;
    club_name: string;
    about: string;
    logo: string;
    description: string;
    max_drivers: number;
    min_drivers: number;
    laps_for_solo_race: number;
    laps_for_team_race: number;
    max_team_drivers: number;
    min_team_drivers: number;
    max_weekly_race_entries: number;
    min_weekly_race_entries: number;
    fixed_setup: boolean;
    enable_passworded_sessions: boolean;
    private_wall_postings: boolean;
    private_roster: boolean;
    league_rules: string;
    roster_count: number;
    applicant_count: number;
    recruiting: boolean;
    is_admin: boolean;
    is_member: boolean;
    pending_application: boolean;
    pending_invitation: boolean;
    cancelled_application: boolean;
    rejected_application: boolean;
    seasons?: LeagueSeason[];
    roster?: LeagueMember[];
}
interface LeagueSeason {
    season_id: number;
    season_name: string;
    active: boolean;
    car_class_ids: number[];
    car_restrictions: CarRestriction[];
    complete: boolean;
    driver_changes: boolean;
    driver_change_rule: number;
    drops: number;
    green_flag_finish_rule: boolean;
    ignore_license_for_practice: boolean;
    invisible_reserved_setup: boolean;
    max_ai_drivers: number;
    max_team_drivers: number;
    min_team_drivers: number;
    multiclass: boolean;
    must_use_diff_tire_types_in_race: boolean;
    next_race_session: string;
    num_opt_laps: number;
    op_duration: number;
    open_practice: boolean;
    points_system_id: number;
    points_system_name: string;
    practice_length: number;
    private_qualifying: boolean;
    private_scoring: boolean;
    qualify_laps: number;
    race_laps: number;
    race_length: number;
    reg_user_count: number;
    restrict_results: boolean;
    restrict_viewing: boolean;
    schedule_description: string;
    send_to_open_practice: boolean;
    short_parade_lap: boolean;
    start_date: string;
    telemetry_force_to_disk: number;
    telemetry_recording_enabled: boolean;
    unsport_conduct_rule_mode: number;
    fixed_setup: boolean;
    hardcore_level: number;
    lucky_dog: boolean;
    max_weeks: number;
    season_quarter: number;
    season_year: number;
    series_id: number;
    track_types: TrackType[];
}
interface CarRestriction {
    car_id: number;
}
interface TrackType {
    track_type: string;
}
interface LeagueMember {
    cust_id: number;
    display_name: string;
    helmet: Helmet;
    league_member_type: number;
    league_admin: boolean;
    league_owner: boolean;
    can_spot: boolean;
    can_chat: boolean;
    can_coach: boolean;
    owner: boolean;
    admin: boolean;
    licenses?: License[];
}
interface LeagueDirectoryResponse {
    leagues: LeagueDirectoryEntry[];
    success: boolean;
}
interface LeagueDirectoryEntry {
    league_id: number;
    league_name: string;
    owner_id: number;
    owner_display_name: string;
    created: string;
    url: string;
    club_id: number;
    club_name: string;
    description: string;
    max_drivers: number;
    min_drivers: number;
    private_roster: boolean;
    roster_count: number;
    recruiting: boolean;
    tags: string[];
}
interface LeaguePointsSystemsResponse {
    points_systems: PointsSystem[];
    success: boolean;
}
interface PointsSystem {
    points_system_id: number;
    points_system_name: string;
    formula: string;
    method: number;
    rounding: number;
}
interface LeagueMembershipResponse {
    memberships: LeagueMembership[];
    success: boolean;
}
interface LeagueMembership {
    league_id: number;
    league_name: string;
    owner_id: number;
    owner_display_name: string;
    roster_count: number;
    recruiting: boolean;
    league?: League;
}
interface LeagueRosterResponse {
    roster: LeagueMember[];
    success: boolean;
}
interface LeagueSeasonsResponse {
    seasons: LeagueSeason[];
    success: boolean;
}
interface LeagueSeasonStandingsResponse {
    standings: LeagueStanding[];
    success: boolean;
    chunk_info?: ChunkInfo;
}
interface LeagueStanding {
    cust_id: number;
    display_name: string;
    division: number;
    position: number;
    points: number;
    wins: number;
    week_dropped: boolean;
    starts: number;
    helmet: Helmet;
    car_class_id: number;
    club_id: number;
    club_name: string;
    club_shortname: string;
    country_code: string;
    country: string;
    license: License;
}
interface LeagueSeasonSessionsResponse {
    sessions: LeagueSeasonSession[];
    success: boolean;
}
interface LeagueSeasonSession {
    subsession_id: number;
    session_id: number;
    session_name: string;
    created_time: string;
    start_time: string;
    end_time: string;
    num_drivers: number;
    series_name: string;
    session_results: SessionResult[];
}
interface SessionResult {
    cust_id: number;
    display_name: string;
    finish_position: number;
    laps_complete: number;
    laps_lead: number;
    points: number;
    starting_position: number;
    car_class_id: number;
    car_class_name: string;
    division: number;
}
interface LookupCountriesResponse {
    countries: Country[];
    success: boolean;
}
interface Country {
    country_code: string;
    country_name: string;
}
interface LookupDriversResponse {
    drivers: LookupDriver[];
    success: boolean;
}
interface LookupDriver {
    cust_id: number;
    display_name: string;
    helmet: Helmet;
    club_id: number;
    club_name: string;
    country_code: string;
    country: string;
    licenses: License[];
}
interface LookupFlairsResponse {
    flairs: Flair[];
    success: boolean;
}
interface Flair {
    flair_id: number;
    flair_name: string;
    image: string;
}
interface LookupGetResponse {
    lookup_groups: LookupGroup[];
    success: boolean;
}
interface LookupGroup {
    group_name: string;
    lookup_values: LookupValue[];
}
interface LookupValue {
    lookup_value: any;
    lookup_display: string;
}
interface LookupLicensesResponse {
    licenses: LicenseLevel[];
    success: boolean;
}
interface LicenseLevel {
    license_id: number;
    license_name: string;
    license_color: string;
    license_short_name: string;
    min_sr: number;
    min_races: number;
    participated_in_race: boolean;
    group: number;
}
/**
 * Response containing authenticated member information
 */
interface MemberInfoResponse {
    cust_id: number;
    email: string;
    display_name: string;
    first_name: string;
    last_name: string;
    on_car_name: string;
    member_since: string;
    last_login: string;
    read_comp_rules: string;
    read_pp: string;
    read_tos: string;
    helmet: Helmet;
    club_id: number;
    club_name: string;
    country_code: string;
    country: string;
    ai_usage: boolean;
    max_ai_roster_count: number;
    flags: number;
    twenty_four_hours: boolean;
    account_credits: number;
    success: boolean;
}
/**
 * Response containing member information by customer IDs
 */
interface MembersResponse {
    /** Array of member data */
    members: Member[];
    /** Whether the request was successful */
    success: boolean;
}
interface Member {
    cust_id: number;
    display_name: string;
    helmet: Helmet;
    last_login: string;
    member_since: string;
    club_id: number;
    club_name: string;
    country_code: string;
    country: string;
    licenses?: License[];
}
/**
 * Response containing member awards
 */
interface MemberAwardsResponse {
    /** Array of awards */
    awards: Award[];
    /** Whether the request was successful */
    success: boolean;
}
interface Award {
    award_id: number;
    award_name: string;
    award_desc: string;
    award_image: string;
    times_earned: number;
}
interface MemberAwardInstancesResponse {
    award_instances: AwardInstance[];
    success: boolean;
}
interface AwardInstance {
    award_id: number;
    award_name: string;
    award_desc: string;
    award_image: string;
    earned_date: string;
    context: string;
}
interface MemberChartDataResponse {
    category_id: number;
    chart_type: number;
    success: boolean;
    data: ChartDataPoint[];
}
interface ChartDataPoint {
    when: string;
    value: number;
}
interface MemberProfileResponse {
    cust_id: number;
    member_info: ProfileMemberInfo;
    member_stats_by_category: ProfileMemberStats[];
    recent_awards: ProfileAward[];
    favorite_car_class: string;
    favorite_track: string;
    success: boolean;
}
interface ProfileMemberInfo {
    cust_id: number;
    display_name: string;
    helmet: Helmet;
    last_login: string;
    member_since: string;
    club_id: number;
    club_name: string;
    country_code: string;
    country: string;
    occupation: string;
    about: string;
    interests: string;
    connection_type: number;
    download_server: number;
    ai_usage: boolean;
    drivable_car_count: number;
    owned_car_count: number;
    flags: number;
    annual_auto_renew: boolean;
    auto_renew_date: string;
    credits: number;
}
interface ProfileMemberStats {
    category: string;
    category_id: number;
    starts: number;
    wins: number;
    top5: number;
    poles: number;
    avg_start_position: number;
    avg_finish_position: number;
    laps: number;
    laps_led: number;
    total_club_points: number;
    year_club_points: number;
    career_wins: number;
    career_poles: number;
    career_starts: number;
    career_laps: number;
    career_laps_led: number;
}
interface ProfileAward {
    award_id: number;
    award_name: string;
    award_desc: string;
    award_image: string;
    earned_date: string;
    context: string;
}
interface MemberParticipationCreditsResponse {
    participation_credits: ParticipationCredit[];
    success: boolean;
}
interface ParticipationCredit {
    season_id: number;
    series_name: string;
    credits: number;
    credits_remaining: number;
}
interface ResultsResponse {
    session_info: SessionInfo;
    session_results: SessionResult[];
    success: boolean;
}
interface SessionInfo {
    subsession_id: number;
    session_id: number;
    series_id: number;
    series_name: string;
    series_short_name: string;
    session_name: string;
    race_week_num: number;
    event_type: number;
    event_type_name: string;
    driver_changes: boolean;
    green_flag_finish_rule: boolean;
    private_session: boolean;
    start_date: string;
    end_date: string;
    num_drivers: number;
    num_cautions: number;
    num_caution_laps: number;
    num_lead_changes: number;
    time_of_day: number;
    damage_model: number;
    can_protest: boolean;
    cooldown_minutes: number;
    limit_minutes: number;
    track: TrackConfig;
    weather: Weather;
    track_state: TrackState;
    session_results_count: number;
    series_logo: string;
    event_strength_of_field: number;
    event_average_lap: number;
    event_laps_complete: number;
    num_opt_laps: number;
    has_opt_path: boolean;
    can_protest_after_end: boolean;
    special_event_type: number;
    special_event_type_text: string;
    season_id: number;
    season_name: string;
    season_short_name: string;
    season_year: number;
    season_quarter: number;
    license_category_id: number;
    license_category: string;
    car_class_ids: number[];
}
interface EventLogResponse {
    chunk_info: ChunkInfo;
    success: boolean;
}
interface LapChartDataResponse {
    chunk_info: ChunkInfo;
    success: boolean;
}
interface LapDataResponse {
    chunk_info: ChunkInfo;
    success: boolean;
}
interface ResultsSearchResponse {
    data: SearchResult[];
    success: boolean;
    chunk_info?: ChunkInfo;
}
interface SearchResult {
    subsession_id: number;
    session_id: number;
    series_id: number;
    series_name: string;
    session_name: string;
    start_time: string;
    end_time: string;
    num_drivers: number;
    track: TrackConfig;
    winner_group_id: number;
    winner_name: string;
    winner_helmet: Helmet;
    event_type: number;
    event_type_name: string;
    license_category: string;
    license_category_id: number;
    race_week_num: number;
    season_id: number;
    season_name: string;
    season_short_name: string;
    season_quarter: number;
    season_year: number;
    event_strength_of_field: number;
    event_average_lap: number;
    event_laps_complete: number;
    caution_type: number;
    corners_per_lap: number;
    damage_model: number;
    driver_change_rule: number;
    driver_changes: boolean;
    lucky_dog: boolean;
    max_weeks: number;
    num_cautions: number;
    num_caution_laps: number;
    num_lead_changes: number;
    official_session: boolean;
    points_type: string;
    private_session: boolean;
    qual_attached: boolean;
    race_summary: RaceSummary;
    results_restricted: boolean;
    special_event_type_text: string;
    special_event_type: number;
    time_of_day: number;
    weather: Weather;
}
interface RaceSummary {
    subsession_id: number;
    average_lap: number;
    laps_complete: number;
    num_cautions: number;
    num_caution_laps: number;
    num_lead_changes: number;
    field_strength: number;
    num_drivers: number;
}
interface SeasonListResponse {
    seasons: Season[];
    success: boolean;
}
interface Season {
    season_id: number;
    season_name: string;
    series_id: number;
    series_name: string;
    official: boolean;
    season_year: number;
    season_quarter: number;
    license_category: string;
    license_category_id: number;
    rookie_season: string;
    driver_changes: boolean;
    min_license_level: number;
    max_license_level: number;
    active: boolean;
    complete: boolean;
    car_class_ids: number[];
    car_types: CarType[];
    schedule: SeasonSchedule[];
    track_types: TrackType[];
}
interface SeasonSchedule {
    race_week_num: number;
    session_id: number;
    series_id: number;
    season_id: number;
    race_week_name: string;
    track: TrackConfig;
    session_times: string[];
    special_event_type: number;
    start_date: string;
    end_date: string;
    race_lap_limit: number;
    race_time_limit: number;
    time_of_day: number;
    simsession_types: SimSessionType[];
}
interface SimSessionType {
    simsession_type: number;
    simsession_type_name: string;
}
interface SeasonRaceGuideResponse {
    races: RaceGuideEntry[];
    success: boolean;
}
interface RaceGuideEntry {
    series_id: number;
    series_name: string;
    race_week_num: number;
    session_id: number;
    season_id: number;
    license_category: string;
    license_category_id: number;
    start_time: string;
    registration_opens: string;
    registration_closes: string;
    track: TrackConfig;
    weather: Weather;
    track_state: TrackState;
    max_drivers: number;
    reg_count: number;
    entries: RaceGuideEntryDetail[];
}
interface RaceGuideEntryDetail {
    car_id: number;
    car_name: string;
    reg_count: number;
}
interface SeasonSpectatorSubsessionIdsResponse {
    subsession_ids: number[];
    success: boolean;
}
interface SeasonSpectatorSubsessionIdsDetailResponse {
    subsessions: SpectatorSubsession[];
    success: boolean;
}
interface SpectatorSubsession {
    subsession_id: number;
    session_id: number;
    series_id: number;
    series_name: string;
    season_id: number;
    season_name: string;
    license_category: string;
    license_category_id: number;
    race_week_num: number;
    session_name: string;
    start_time: string;
    track: TrackConfig;
    num_drivers: number;
    event_type: number;
    event_type_name: string;
}
interface SeriesAssetsResponse {
    series_assets: SeriesAsset[];
    success: boolean;
}
interface SeriesAsset {
    series_id: number;
    series_name: string;
    logo: string;
    small_image: string;
    large_image: string;
}
interface SeriesResponse {
    series: Series[];
    success: boolean;
}
interface Series {
    series_id: nu