cfbd 5.0.0-alpha.0

package/dist/types.gen.d.ts

@@ -0,0 +1,2323 @@
+export type Venue = {
+    id: (number) | null;
+    name: (string) | null;
+    city: (string) | null;
+    state: (string) | null;
+    zip: (string) | null;
+    countryCode: (string) | null;
+    timezone: (string) | null;
+    latitude: (number) | null;
+    longitude: (number) | null;
+    elevation: (string) | null;
+    capacity: (number) | null;
+    constructionYear: (number) | null;
+    grass?: (boolean) | null;
+    dome?: (boolean) | null;
+};
+export type Team = {
+    id: number;
+    school: string;
+    mascot: (string) | null;
+    abbreviation: (string) | null;
+    alternateNames: Array<(string)> | null;
+    conference: (string) | null;
+    division: (string) | null;
+    classification: (string) | null;
+    color: (string) | null;
+    alternateColor: (string) | null;
+    logos: Array<(string)> | null;
+    twitter: (string) | null;
+    location: ((Venue) | null);
+};
+export type MatchupGame = {
+    season: number;
+    week: number;
+    seasonType: string;
+    date: string;
+    neutralSite: boolean;
+    venue: string;
+    homeTeam: string;
+    homeScore: number;
+    awayTeam: string;
+    awayScore: number;
+    winner: (string) | null;
+};
+export type Matchup = {
+    team1: string;
+    team2: string;
+    startYear?: number;
+    endYear?: number;
+    team1Wins: number;
+    team2Wins: number;
+    ties: number;
+    games: Array<MatchupGame>;
+};
+export type RosterPlayer = {
+    id: string;
+    firstName: string;
+    lastName: string;
+    team: string;
+    height: (number) | null;
+    weight: (number) | null;
+    jersey: (number) | null;
+    year: number;
+    position: (string) | null;
+    homeCity: (string) | null;
+    homeState: (string) | null;
+    homeCountry: (string) | null;
+    homeLatitude: (number) | null;
+    homeLongitude: (number) | null;
+    homeCountyFIPS: (string) | null;
+    recruitIds: Array<(string)> | null;
+};
+export type DivisionClassification = 'fbs' | 'fcs' | 'ii' | 'iii';
+export type Conference = {
+    id: number;
+    name: string;
+    shortName: (string) | null;
+    abbreviation: (string) | null;
+    classification: ((DivisionClassification) | null);
+};
+export type TeamTalent = {
+    year: number;
+    team: string;
+    talent: number;
+};
+export type PlayerStat = {
+    season: number;
+    playerId: string;
+    player: string;
+    team: string;
+    conference: string;
+    category: string;
+    statType: string;
+    stat: number;
+};
+export type SeasonType = 'regular' | 'postseason' | 'both' | 'allstar' | 'spring_regular' | 'spring_postseason';
+export type TeamStat = {
+    season: number;
+    team: string;
+    conference: string;
+    statName: string;
+    statValue: (string | number);
+};
+export type AdvancedSeasonStat = {
+    season: number;
+    team: string;
+    conference: string;
+    offense: {
+        passingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+            rate: number;
+        };
+        rushingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+            rate: number;
+        };
+        passingDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+            rate: number;
+        };
+        standardDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+            rate: number;
+        };
+        havoc: {
+            db: (number) | null;
+            frontSeven: (number) | null;
+            total: (number) | null;
+        };
+        fieldPosition: {
+            averagePredictedPoints: (number) | null;
+            averageStart: (number) | null;
+        };
+        pointsPerOpportunity: number;
+        totalOpportunies: number;
+        openFieldYardsTotal: number;
+        openFieldYards: number;
+        secondLevelYardsTotal: number;
+        secondLevelYards: number;
+        lineYardsTotal: number;
+        lineYards: number;
+        stuffRate: number;
+        powerSuccess: number;
+        explosiveness: number;
+        successRate: number;
+        totalPPA: number;
+        ppa: number;
+        drives: number;
+        plays: number;
+    };
+    defense: {
+        passingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+            rate: number;
+        };
+        rushingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+            rate: number;
+        };
+        passingDowns: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+            rate: number;
+        };
+        standardDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+            rate: number;
+        };
+        havoc: {
+            db: (number) | null;
+            frontSeven: (number) | null;
+            total: (number) | null;
+        };
+        fieldPosition: {
+            averagePredictedPoints: (number) | null;
+            averageStart: (number) | null;
+        };
+        pointsPerOpportunity: number;
+        totalOpportunies: number;
+        openFieldYardsTotal: number;
+        openFieldYards: number;
+        secondLevelYardsTotal: number;
+        secondLevelYards: number;
+        lineYardsTotal: number;
+        lineYards: number;
+        stuffRate: number;
+        powerSuccess: number;
+        explosiveness: number;
+        successRate: number;
+        totalPPA: number;
+        ppa: number;
+        drives: number;
+        plays: number;
+    };
+};
+export type AdvancedGameStat = {
+    gameId: number;
+    season: number;
+    week: number;
+    team: string;
+    opponent: string;
+    offense: {
+        passingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+        };
+        rushingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+        };
+        passingDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+        };
+        standardDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+        };
+        openFieldYardsTotal: number;
+        openFieldYards: number;
+        secondLevelYardsTotal: number;
+        secondLevelYards: number;
+        lineYardsTotal: number;
+        lineYards: number;
+        stuffRate: number;
+        powerSuccess: number;
+        explosiveness: number;
+        successRate: number;
+        totalPPA: number;
+        ppa: number;
+        drives: number;
+        plays: number;
+    };
+    defense: {
+        passingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+        };
+        rushingPlays: {
+            explosiveness: number;
+            successRate: number;
+            totalPPA: number;
+            ppa: number;
+        };
+        passingDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+        };
+        standardDowns: {
+            explosiveness: number;
+            successRate: number;
+            ppa: number;
+        };
+        openFieldYardsTotal: number;
+        openFieldYards: number;
+        secondLevelYardsTotal: number;
+        secondLevelYards: number;
+        lineYardsTotal: number;
+        lineYards: number;
+        stuffRate: number;
+        powerSuccess: number;
+        explosiveness: number;
+        successRate: number;
+        totalPPA: number;
+        ppa: number;
+        drives: number;
+        plays: number;
+    };
+};
+export type RecruitClassification = 'JUCO' | 'PrepSchool' | 'HighSchool';
+export type Recruit = {
+    id: string;
+    athleteId: (string) | null;
+    recruitType: RecruitClassification;
+    year: number;
+    ranking: (number) | null;
+    name: string;
+    school: (string) | null;
+    committedTo: (string) | null;
+    position: (string) | null;
+    height: (number) | null;
+    weight: (number) | null;
+    stars: number;
+    rating: number;
+    city: (string) | null;
+    stateProvince: (string) | null;
+    country: (string) | null;
+    hometownInfo: {
+        fipsCode: (string) | null;
+        longitude: (number) | null;
+        latitude: (number) | null;
+    };
+};
+export type TeamRecruitingRanking = {
+    year: number;
+    rank: number;
+    team: string;
+    points: number;
+};
+export type AggregatedTeamRecruiting = {
+    team: string;
+    conference: string;
+    positionGroup: (string) | null;
+    averageRating: number;
+    totalRating: number;
+    commits: number;
+    averageStars: number;
+};
+export type TeamSP = {
+    year: number;
+    team: string;
+    conference: string;
+    rating: number;
+    ranking: number;
+    secondOrderWins: (number) | null;
+    sos: (number) | null;
+    offense: {
+        pace: (number) | null;
+        runRate: (number) | null;
+        passingDowns: (number) | null;
+        standardDowns: (number) | null;
+        passing: (number) | null;
+        rushing: (number) | null;
+        explosiveness: (number) | null;
+        success: (number) | null;
+        rating: number;
+        ranking: number;
+    };
+    defense: {
+        havoc: {
+            db: (number) | null;
+            frontSeven: (number) | null;
+            total: (number) | null;
+        };
+        passingDowns: (number) | null;
+        standardDowns: (number) | null;
+        passing: (number) | null;
+        rushing: (number) | null;
+        explosiveness: (number) | null;
+        success: (number) | null;
+        rating: number;
+        ranking: number;
+    };
+    specialTeams: {
+        rating: (number) | null;
+    };
+};
+export type ConferenceSP = {
+    year: number;
+    conference: string;
+    rating: number;
+    secondOrderWins: (number) | null;
+    sos: (number) | null;
+    offense: {
+        pace: (number) | null;
+        runRate: (number) | null;
+        passingDowns: (number) | null;
+        standardDowns: (number) | null;
+        passing: (number) | null;
+        rushing: (number) | null;
+        explosiveness: (number) | null;
+        success: (number) | null;
+        rating: number;
+    };
+    defense: {
+        havoc: {
+            db: (number) | null;
+            frontSeven: (number) | null;
+            total: (number) | null;
+        };
+        passingDowns: (number) | null;
+        standardDowns: (number) | null;
+        passing: (number) | null;
+        rushing: (number) | null;
+        explosiveness: (number) | null;
+        success: (number) | null;
+        rating: number;
+    };
+    specialTeams: {
+        rating: (number) | null;
+    };
+};
+export type TeamSRS = {
+    year: number;
+    team: string;
+    conference: (string) | null;
+    division: (string) | null;
+    rating: number;
+    ranking: number;
+};
+export type TeamElo = {
+    year: number;
+    team: string;
+    conference: string;
+    elo: (number) | null;
+};
+export type TeamFPI = {
+    year: number;
+    team: string;
+    conference: (string) | null;
+    fpi: (number) | null;
+    resumeRanks: {
+        gameControl: (number) | null;
+        remainingStrengthOfSchedule: (number) | null;
+        strengthOfSchedule: (number) | null;
+        averageWinProbability: (number) | null;
+        fpi: (number) | null;
+        strengthOfRecord: (number) | null;
+    };
+    efficiencies: {
+        specialTeams: (number) | null;
+        defense: (number) | null;
+        offense: (number) | null;
+        overall: (number) | null;
+    };
+};
+export type PollRank = {
+    rank: (number) | null;
+    school: string;
+    conference: (string) | null;
+    firstPlaceVotes: (number) | null;
+    points: (number) | null;
+};
+export type Poll = {
+    poll: string;
+    ranks: Array<PollRank>;
+};
+export type PollWeek = {
+    season: number;
+    seasonType: SeasonType;
+    week: number;
+    polls: Array<Poll>;
+};
+export type Play = {
+    id: string;
+    driveId: string;
+    gameId: number;
+    driveNumber: (number) | null;
+    playNumber: (number) | null;
+    offense: string;
+    offenseConference: (string) | null;
+    offenseScore: number;
+    defense: string;
+    home: string;
+    away: string;
+    defenseConference: (string) | null;
+    defenseScore: number;
+    period: number;
+    clock: {
+        seconds: (number) | null;
+        minutes: (number) | null;
+    };
+    offenseTimeouts: (number) | null;
+    defenseTimeouts: (number) | null;
+    yardline: number;
+    yardsToGoal: number;
+    down: number;
+    distance: number;
+    yardsGained: number;
+    scoring: boolean;
+    playType: string;
+    playText: (string) | null;
+    ppa: (number) | null;
+    wallclock: (string) | null;
+};
+export type PlayType = {
+    id: number;
+    text: string;
+    abbreviation: (string) | null;
+};
+export type PlayStat = {
+    gameId: number;
+    season: number;
+    week: number;
+    team: string;
+    conference: string;
+    opponent: string;
+    teamScore: number;
+    opponentScore: number;
+    driveId: string;
+    playId: string;
+    period: number;
+    clock: {
+        seconds: (number) | null;
+        minutes: (number) | null;
+    };
+    yardsToGoal: number;
+    down: number;
+    distance: number;
+    athleteId: string;
+    athleteName: string;
+    statType: string;
+    stat: number;
+};
+export type PlayStatType = {
+    id: number;
+    name: string;
+};
+export type PlayerSearchResult = {
+    id: string;
+    team: string;
+    name: string;
+    firstName: (string) | null;
+    lastName: (string) | null;
+    weight: (number) | null;
+    height: (number) | null;
+    jersey: (number) | null;
+    position: string;
+    hometown: string;
+    teamColor: string;
+    teamColorSecondary: string;
+};
+export type PlayerPPAChartItem = {
+    playNumber: number;
+    avgPPA: number;
+};
+export type PlayerUsage = {
+    season: number;
+    id: string;
+    name: string;
+    position: string;
+    team: string;
+    conference: string;
+    usage: {
+        passingDowns: number;
+        standardDowns: number;
+        thirdDown: number;
+        secondDown: number;
+        firstDown: number;
+        rush: number;
+        pass: number;
+        overall: number;
+    };
+};
+export type ReturningProduction = {
+    season: number;
+    team: string;
+    conference: string;
+    totalPPA: number;
+    totalPassingPPA: number;
+    totalReceivingPPA: number;
+    totalRushingPPA: number;
+    percentPPA: number;
+    percentPassingPPA: number;
+    percentReceivingPPA: number;
+    percentRushingPPA: number;
+    usage: number;
+    passingUsage: number;
+    receivingUsage: number;
+    rushingUsage: number;
+};
+export type TransferEligibility = 'Withdrawn' | 'TBD' | 'PendingAppeal' | 'SittingOne' | 'Immediate';
+export type PlayerTransfer = {
+    season: number;
+    firstName: string;
+    lastName: string;
+    position: string;
+    origin: string;
+    destination: (string) | null;
+    transferDate: (string) | null;
+    rating: (number) | null;
+    stars: (number) | null;
+    eligibility: ((TransferEligibility) | null);
+};
+export type PredictedPointsValue = {
+    yardLine: number;
+    predictedPoints: number;
+};
+export type TeamSeasonPredictedPointsAdded = {
+    season: number;
+    conference: string;
+    team: string;
+    offense: {
+        cumulative: {
+            rushing: number;
+            passing: number;
+            total: number;
+        };
+        thirdDown: number;
+        secondDown: number;
+        firstDown: number;
+        rushing: number;
+        passing: number;
+        overall: number;
+    };
+    defense: {
+        cumulative: {
+            rushing: number;
+            passing: number;
+            total: number;
+        };
+        thirdDown: number;
+        secondDown: number;
+        firstDown: number;
+        rushing: number;
+        passing: number;
+        overall: number;
+    };
+};
+export type TeamGamePredictedPointsAdded = {
+    gameId: number;
+    season: number;
+    week: number;
+    seasonType: SeasonType;
+    team: string;
+    conference: string;
+    opponent: string;
+    offense: {
+        thirdDown: number;
+        secondDown: number;
+        firstDown: number;
+        rushing: number;
+        passing: number;
+        overall: number;
+    };
+    defense: {
+        thirdDown: number;
+        secondDown: number;
+        firstDown: number;
+        rushing: number;
+        passing: number;
+        overall: number;
+    };
+};
+export type PlayerGamePredictedPointsAdded = {
+    season: number;
+    week: number;
+    seasonType: SeasonType;
+    id: string;
+    name: string;
+    position: string;
+    team: string;
+    opponent: string;
+    averagePPA: {
+        rush?: number;
+        pass?: number;
+        all: number;
+    };
+};
+export type PlayerSeasonPredictedPointsAdded = {
+    season: number;
+    id: string;
+    name: string;
+    position: string;
+    team: string;
+    conference: string;
+    averagePPA: {
+        passingDowns?: number;
+        standardDowns?: number;
+        thirdDown?: number;
+        secondDown?: number;
+        firstDown?: number;
+        rush?: number;
+        pass?: number;
+        all: number;
+    };
+    totalPPA: {
+        passingDowns?: number;
+        standardDowns?: number;
+        thirdDown?: number;
+        secondDown?: number;
+        firstDown?: number;
+        rush?: number;
+        pass?: number;
+        all: number;
+    };
+};
+export type PlayWinProbability = {
+    gameId: number;
+    playId: string;
+    playText: string;
+    homeId: number;
+    home: string;
+    awayId: number;
+    away: string;
+    spread: number;
+    homeBall: boolean;
+    homeScore: number;
+    awayScore: number;
+    yardLine: number;
+    down: number;
+    distance: number;
+    homeWinProbability: number;
+    playNumber: number;
+};
+export type PregameWinProbability = {
+    season: number;
+    seasonType: SeasonType;
+    week: number;
+    gameId: number;
+    homeTeam: string;
+    awayTeam: string;
+    spread: number;
+    homeWinProbability: number;
+};
+export type FieldGoalEP = {
+    yardsToGoal: number;
+    distance: number;
+    expectedPoints: number;
+};
+export type LiveGameTeam = {
+    teamId: number;
+    team: string;
+    homeAway: 'home' | 'away';
+    lineScores: Array<(number)>;
+    points: number;
+    drives: number;
+    scoringOpportunities: number;
+    pointsPerOpportunity: number;
+    plays: number;
+    lineYards: number;
+    lineYardsPerRush: number;
+    secondLevelYards: number;
+    secondLevelYardsPerRush: number;
+    openFieldYards: number;
+    openFieldYardsPerRush: number;
+    epaPerPlay: number;
+    totalEpa: number;
+    passingEpa: number;
+    epaPerPass: number;
+    rushingEpa: number;
+    epaPerRush: number;
+    successRate: number;
+    standardDownSuccessRate: number;
+    passingDownSuccessRate: number;
+    explosiveness: number;
+};
+export type homeAway = 'home' | 'away';
+export type LiveGamePlay = {
+    id: string;
+    homeScore: number;
+    awayScore: number;
+    period: number;
+    clock: string;
+    wallClock: string;
+    teamId: number;
+    team: string;
+    down: number;
+    distance: number;
+    yardsToGoal: number;
+    yardsGained: number;
+    playTypeId: number;
+    playType: string;
+    epa: (number) | null;
+    garbageTime: boolean;
+    success: boolean;
+    rushPash: 'rush' | 'pass' | 'other';
+    downType: 'passing' | 'standard';
+    playText: string;
+};
+export type rushPash = 'rush' | 'pass' | 'other';
+export type downType = 'passing' | 'standard';
+export type LiveGameDrive = {
+    id: string;
+    offenseId: number;
+    offense: string;
+    defenseId: number;
+    defense: string;
+    playCount: number;
+    yards: number;
+    startPeriod: number;
+    startClock: (string) | null;
+    startYardsToGoal: number;
+    endPeriod: (number) | null;
+    endClock: (string) | null;
+    endYardsToGoal: (number) | null;
+    duration: (string) | null;
+    scoringOpportunity: boolean;
+    result: string;
+    pointsGained: number;
+    plays: Array<LiveGamePlay>;
+};
+export type LiveGame = {
+    id: number;
+    status: string;
+    period: (number) | null;
+    clock: string;
+    possession: string;
+    down: (number) | null;
+    distance: (number) | null;
+    yardsToGoal: (number) | null;
+    teams: Array<LiveGameTeam>;
+    drives: Array<LiveGameDrive>;
+};
+export type GameLine = {
+    provider: string;
+    spread: (number) | null;
+    formattedSpread: string;
+    spreadOpen: (number) | null;
+    overUnder: (number) | null;
+    overUnderOpen: (number) | null;
+    homeMoneyline: (number) | null;
+    awayMoneyline: (number) | null;
+};
+export type BettingGame = {
+    id: number;
+    season: number;
+    seasonType: SeasonType;
+    week: number;
+    startDate: string;
+    homeTeam: string;
+    homeConference: (string) | null;
+    homeClassification: ((DivisionClassification) | null);
+    homeScore: (number) | null;
+    awayTeam: string;
+    awayConference: (string) | null;
+    awayClassification: ((DivisionClassification) | null);
+    awayScore: (number) | null;
+    lines: Array<GameLine>;
+};
+export type Game = {
+    id: number;
+    season: number;
+    week: number;
+    seasonType: SeasonType;
+    startDate: string;
+    startTimeTBD: boolean;
+    completed: boolean;
+    neutralSite: boolean;
+    conferenceGame: boolean;
+    attendance: (number) | null;
+    venueId: (number) | null;
+    venue: (string) | null;
+    homeId: number;
+    homeTeam: string;
+    homeConference: (string) | null;
+    homeClassification: ((DivisionClassification) | null);
+    homePoints: (number) | null;
+    homeLineScores: Array<(number)> | null;
+    homePostgameWinProbability: (number) | null;
+    homePregameElo: (number) | null;
+    homePostgameElo: (number) | null;
+    awayId: number;
+    awayTeam: string;
+    awayConference: (string) | null;
+    awayClassification: ((DivisionClassification) | null);
+    awayPoints: (number) | null;
+    awayLineScores: Array<(number)> | null;
+    awayPostgameWinProbability: (number) | null;
+    awayPregameElo: (number) | null;
+    awayPostgameElo: (number) | null;
+    excitementIndex: (number) | null;
+    highlights: (string) | null;
+    notes: (string) | null;
+};
+export type GameTeamStatsTeamStat = {
+    category: string;
+    stat: string;
+};
+export type GameTeamStatsTeam = {
+    teamId: number;
+    team: string;
+    conference: (string) | null;
+    homeAway: 'home' | 'away';
+    points: (number) | null;
+    stats: Array<GameTeamStatsTeamStat>;
+};
+export type GameTeamStats = {
+    id: number;
+    teams: Array<GameTeamStatsTeam>;
+};
+export type GamePlayerStatPlayer = {
+    id: string;
+    name: string;
+    stat: string;
+};
+export type GamePlayerStatTypes = {
+    name: string;
+    athletes: Array<GamePlayerStatPlayer>;
+};
+export type GamePlayerStatCategories = {
+    name: string;
+    types: Array<GamePlayerStatTypes>;
+};
+export type GamePlayerStatsTeam = {
+    team: string;
+    conference: (string) | null;
+    homeAway: 'home' | 'away';
+    points: (number) | null;
+    categories: Array<GamePlayerStatCategories>;
+};
+export type GamePlayerStats = {
+    id: number;
+    teams: Array<GamePlayerStatsTeam>;
+};
+export type MediaType = 'tv' | 'radio' | 'web' | 'ppv' | 'mobile';
+export type GameMedia = {
+    id: number;
+    season: number;
+    week: number;
+    seasonType: SeasonType;
+    startTime: string;
+    isStartTimeTBD: boolean;
+    homeTeam: string;
+    homeConference: (string) | null;
+    awayTeam: string;
+    awayConference: (string) | null;
+    mediaType: MediaType;
+    outlet: string;
+};
+export type GameWeather = {
+    id: number;
+    season: number;
+    week: number;
+    seasonType: SeasonType;
+    startTime: string;
+    gameIndoors: boolean;
+    homeTeam: string;
+    homeConference: (string) | null;
+    awayTeam: string;
+    awayConference: (string) | null;
+    venueId: number;
+    venue: string;
+    temperature: (number) | null;
+    dewPoint: (number) | null;
+    humidity: (number) | null;
+    precipitation: (number) | null;
+    snowfall: (number) | null;
+    windDirection: (number) | null;
+    windSpeed: (number) | null;
+    pressure: (number) | null;
+    weatherConditionCode: (number) | null;
+    weatherCondition: (string) | null;
+};
+export type TeamRecord = {
+    games: number;
+    wins: number;
+    losses: number;
+    ties: number;
+};
+export type TeamRecords = {
+    year: number;
+    teamId: number;
+    team: string;
+    classification: ((DivisionClassification) | null);
+    conference: string;
+    division: string;
+    expectedWins: number;
+    total: TeamRecord;
+    conferenceGames: TeamRecord;
+    homeGames: TeamRecord;
+    awayGames: TeamRecord;
+    neutralSiteGames: TeamRecord;
+};
+export type CalendarWeek = {
+    season: number;
+    week: number;
+    seasonType: SeasonType;
+    firstGameStart: string;
+    lastGameStart: string;
+};
+export type GameStatus = 'scheduled' | 'in_progress' | 'completed';
+export type ScoreboardGame = {
+    id: number;
+    startDate: string;
+    startTimeTBD: boolean;
+    tv: (string) | null;
+    neutralSite: boolean;
+    conferenceGame: boolean;
+    status: GameStatus;
+    period: (number) | null;
+    clock: (string) | null;
+    situation: (string) | null;
+    possession: (string) | null;
+    venue: {
+        state: (string) | null;
+        city: (string) | null;
+        name: string;
+    };
+    homeTeam: {
+        points: (number) | null;
+        classification: ((DivisionClassification) | null);
+        conference: (string) | null;
+        name: string;
+        id: number;
+    };
+    awayTeam: {
+        points: (number) | null;
+        classification: ((DivisionClassification) | null);
+        conference: (string) | null;
+        name: string;
+        id: number;
+    };
+    weather: {
+        windDirection: (number) | null;
+        windSpeed: (number) | null;
+        description: (string) | null;
+        temperature: (number) | null;
+    };
+    betting: {
+        awayMoneyline: (number) | null;
+        homeMoneyline: (number) | null;
+        overUnder: (number) | null;
+        spread: (number) | null;
+    };
+};
+export type Drive = {
+    offense: string;
+    offenseConference: (string) | null;
+    defense: string;
+    defenseConference: (string) | null;
+    gameId: number;
+    id: string;
+    driveNumber: (number) | null;
+    scoring: boolean;
+    startPeriod: number;
+    startYardline: number;
+    startYardsToGoal: number;
+    startTime: {
+        seconds: (number) | null;
+        minutes: (number) | null;
+    };
+    endPeriod: number;
+    endYardline: number;
+    endYardsToGoal: number;
+    endTime: {
+        seconds: (number) | null;
+        minutes: (number) | null;
+    };
+    plays: number;
+    yards: number;
+    driveResult: string;
+    isHomeOffense: boolean;
+    startOffenseScore: number;
+    startDefenseScore: number;
+    endOffenseScore: number;
+    endDefenseScore: number;
+};
+export type DraftTeam = {
+    location: string;
+    nickname: (string) | null;
+    displayName: (string) | null;
+    logo: (string) | null;
+};
+export type DraftPosition = {
+    name: string;
+    abbreviation: string;
+};
+export type DraftPick = {
+    collegeAthleteId: (number) | null;
+    nflAthleteId: number;
+    collegeId: number;
+    collegeTeam: string;
+    collegeConference: (string) | null;
+    nflTeamId: number;
+    nflTeam: string;
+    year: number;
+    overall: number;
+    round: number;
+    pick: number;
+    name: string;
+    position: string;
+    height: (number) | null;
+    weight: (number) | null;
+    preDraftRanking: (number) | null;
+    preDraftPositionRanking: (number) | null;
+    preDraftGrade: (number) | null;
+    hometownInfo: {
+        countyFips: (string) | null;
+        longitude: (string) | null;
+        latitude: (string) | null;
+        country: (string) | null;
+        state: (string) | null;
+        city: (string) | null;
+    };
+};
+export type CoachSeason = {
+    school: string;
+    year: number;
+    games: number;
+    wins: number;
+    losses: number;
+    ties: number;
+    preseasonRank: (number) | null;
+    postseasonRank: (number) | null;
+    srs: (number) | null;
+    spOverall: (number) | null;
+    spOffense: (number) | null;
+    spDefense: (number) | null;
+};
+export type Coach = {
+    firstName: string;
+    lastName: string;
+    hireDate: (string) | null;
+    seasons: Array<CoachSeason>;
+};
+export type StatsByQuarter = {
+    total: number;
+    quarter1: number;
+    quarter2: number;
+    quarter3: number;
+    quarter4: number;
+};
+export type TeamPPA = {
+    team: string;
+    plays: number;
+    overall: StatsByQuarter;
+    passing: StatsByQuarter;
+    rushing: StatsByQuarter;
+};
+export type TeamSuccessRates = {
+    team: string;
+    overall: StatsByQuarter;
+    standardDowns: StatsByQuarter;
+    passingDowns: StatsByQuarter;
+};
+export type TeamExplosiveness = {
+    team: string;
+    overall: StatsByQuarter;
+};
+export type TeamRushingStats = {
+    team: string;
+    powerSuccess: number;
+    stuffRate: number;
+    lineYards: number;
+    lineYardsAverage: number;
+    secondLevelYards: number;
+    secondLevelYardsAverage: number;
+    openFieldYards: number;
+    openFieldYardsAverage: number;
+};
+export type TeamHavoc = {
+    team: string;
+    total: number;
+    frontSeven: number;
+    db: number;
+};
+export type TeamScoringOpportunities = {
+    team: string;
+    opportunities: number;
+    points: number;
+    pointsPerOpportunity: number;
+};
+export type TeamFieldPosition = {
+    team: string;
+    averageStart: number;
+    averageStartingPredictedPoints: number;
+};
+export type PlayerGameUsage = {
+    total: number;
+    quarter1: number;
+    quarter2: number;
+    quarter3: number;
+    quarter4: number;
+    rushing: number;
+    passing: number;
+    player: string;
+    team: string;
+    position: string;
+};
+export type PlayerStatsByQuarter = {
+    total: number;
+    quarter1: number;
+    quarter2: number;
+    quarter3: number;
+    quarter4: number;
+    rushing: number;
+    passing: number;
+};
+export type PlayerPPA = {
+    player: string;
+    team: string;
+    position: string;
+    average: PlayerStatsByQuarter;
+    cumulative: PlayerStatsByQuarter;
+};
+export type AdvancedBoxScore = {
+    gameInfo: {
+        excitement: number;
+        homeWinner: boolean;
+        awayWinProb: number;
+        awayPoints: number;
+        awayTeam: string;
+        homeWinProb: number;
+        homePoints: number;
+        homeTeam: string;
+    };
+    teams: {
+        fieldPosition: Array<TeamFieldPosition>;
+        scoringOpportunities: Array<TeamScoringOpportunities>;
+        havoc: Array<TeamHavoc>;
+        rushing: Array<TeamRushingStats>;
+        explosiveness: Array<TeamExplosiveness>;
+        successRates: Array<TeamSuccessRates>;
+        cumulativePpa: Array<TeamPPA>;
+        ppa: Array<TeamPPA>;
+    };
+    players: {
+        ppa: Array<PlayerPPA>;
+        usage: Array<PlayerGameUsage>;
+    };
+};
+export type GetTeamsData = {
+    query?: {
+        /**
+         * Optional conference abbreviation filter
+         */
+        conference?: string;
+        /**
+         * Optional year filter to get historical conference affiliations
+         */
+        year?: number;
+    };
+};
+export type GetTeamsResponse = (Array<Team>);
+export type GetTeamsError = unknown;
+export type GetFbsTeamsData = {
+    query?: {
+        /**
+         * Year or season
+         */
+        year?: number;
+    };
+};
+export type GetFbsTeamsResponse = (Array<Team>);
+export type GetFbsTeamsError = unknown;
+export type GetMatchupData = {
+    query: {
+        /**
+         * Optional ending year
+         */
+        maxYear?: number;
+        /**
+         * Optional starting year
+         */
+        minYear?: number;
+        /**
+         * First team to compare
+         */
+        team1: string;
+        /**
+         * Second team to compare
+         */
+        team2: string;
+    };
+};
+export type GetMatchupResponse = (Matchup);
+export type GetMatchupError = unknown;
+export type GetRosterData = {
+    query?: {
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional year filter, defaults to 2023
+         */
+        year?: number;
+    };
+};
+export type GetRosterResponse = (Array<RosterPlayer>);
+export type GetRosterError = unknown;
+export type GetConferencesResponse = (Array<Conference>);
+export type GetConferencesError = unknown;
+export type GetTalentData = {
+    query: {
+        /**
+         * Year filter
+         */
+        year: number;
+    };
+};
+export type GetTalentResponse = (Array<TeamTalent>);
+export type GetTalentError = unknown;
+export type GetVenuesResponse = (Array<Venue>);
+export type GetVenuesError = unknown;
+export type GetPlayerSeasonStatsData = {
+    query: {
+        /**
+         * Optional category filter
+         */
+        category?: string;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional ending week range
+         */
+        endWeek?: number;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional starting week range
+         */
+        startWeek?: number;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetPlayerSeasonStatsResponse = (Array<PlayerStat>);
+export type GetPlayerSeasonStatsError = unknown;
+export type GetTeamStatsData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional week end range filter
+         */
+        endWeek?: number;
+        /**
+         * Optional week start range filter
+         */
+        startWeek?: number;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetTeamStatsResponse = (Array<TeamStat>);
+export type GetTeamStatsError = unknown;
+export type GetCategoriesResponse = (Array<(string)>);
+export type GetCategoriesError = unknown;
+export type GetAdvancedSeasonStatsData = {
+    query?: {
+        /**
+         * Optional end week range filter
+         */
+        endWeek?: number;
+        /**
+         * Garbage time exclusion filter, defaults to false
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Optional start week range filter
+         */
+        startWeek?: number;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetAdvancedSeasonStatsResponse = (Array<AdvancedSeasonStat>);
+export type GetAdvancedSeasonStatsError = unknown;
+export type GetAdvancedGameStatsData = {
+    query?: {
+        /**
+         * Garbage time exclusion filter, defaults to false
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Optional opponent filter
+         */
+        opponent?: string;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetAdvancedGameStatsResponse = (Array<AdvancedGameStat>);
+export type GetAdvancedGameStatsError = unknown;
+export type GetRecruitsData = {
+    query?: {
+        /**
+         * Optional recruit type classification filter, defaults to HighSchool
+         */
+        classification?: RecruitClassification;
+        /**
+         * Optional position categorization filter
+         */
+        position?: string;
+        /**
+         * Optional state/province filter
+         */
+        state?: string;
+        /**
+         * Team filter, required when no team specified
+         */
+        team?: string;
+        /**
+         * Year filter, required when no team specified
+         */
+        year?: number;
+    };
+};
+export type GetRecruitsResponse = (Array<Recruit>);
+export type GetRecruitsError = unknown;
+export type GetTeamRecruitingRankingsData = {
+    query?: {
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetTeamRecruitingRankingsResponse = (Array<TeamRecruitingRanking>);
+export type GetTeamRecruitingRankingsError = unknown;
+export type GetAggregatedTeamRecruitingRatingsData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional end year range, defaults to current year
+         */
+        endYear?: number;
+        /**
+         * Optional recruit type filter, defaults to HighSchool
+         */
+        recruitType?: RecruitClassification;
+        /**
+         * Optional start year range, defaults to 2000
+         */
+        startYear?: number;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+    };
+};
+export type GetAggregatedTeamRecruitingRatingsResponse = (Array<AggregatedTeamRecruiting>);
+export type GetAggregatedTeamRecruitingRatingsError = unknown;
+export type GetSpData = {
+    query?: {
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetSpResponse = (Array<TeamSP>);
+export type GetSpError = unknown;
+export type GetConferenceSpData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetConferenceSpResponse = (Array<ConferenceSP>);
+export type GetConferenceSpError = unknown;
+export type GetSrsData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetSrsResponse = (Array<TeamSRS>);
+export type GetSrsError = unknown;
+export type GetEloData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter, defaults to last available week in the season
+         */
+        week?: number;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetEloResponse = (Array<TeamElo>);
+export type GetEloError = unknown;
+export type GetFpiData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetFpiResponse = (Array<TeamFPI>);
+export type GetFpiError = unknown;
+export type GetRankingsData = {
+    query: {
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetRankingsResponse = (Array<PollWeek>);
+export type GetRankingsError = unknown;
+export type GetPlaysData = {
+    query: {
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional defensive team filter
+         */
+        defense?: string;
+        /**
+         * Optional defensive conference filter
+         */
+        defenseConference?: string;
+        /**
+         * Optional offensive team filter
+         */
+        offense?: string;
+        /**
+         * Optional offensive conference filter
+         */
+        offenseConference?: string;
+        /**
+         * Optoinal play type abbreviation filter
+         */
+        playType?: string;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Required week filter
+         */
+        week: number;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetPlaysResponse = (Array<Play>);
+export type GetPlaysError = unknown;
+export type GetPlayTypesResponse = (Array<PlayType>);
+export type GetPlayTypesError = unknown;
+export type GetPlayStatsData = {
+    query?: {
+        /**
+         * Optional athleteId filter
+         */
+        athleteId?: number;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional gameId filter
+         */
+        gameId?: number;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional statTypeId filter
+         */
+        statTypeId?: number;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetPlayStatsResponse = (Array<PlayStat>);
+export type GetPlayStatsError = unknown;
+export type GetPlayStatTypesResponse = (Array<PlayStatType>);
+export type GetPlayStatTypesError = unknown;
+export type SearchPlayersData = {
+    query: {
+        /**
+         * Optional position abbreviation filter
+         */
+        position?: string;
+        /**
+         * Search term for matching player name
+         */
+        searchTerm: string;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type SearchPlayersResponse = (Array<PlayerSearchResult>);
+export type SearchPlayersError = unknown;
+export type GetPlayerUsageData = {
+    query: {
+        /**
+         * Optional conference abbreviation filter
+         */
+        conference?: string;
+        /**
+         * Optional exclude garbage time flag, defaults to false
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Optional player id filter
+         */
+        playerId?: number;
+        /**
+         * Optional position abbreivation filter
+         */
+        position?: string;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetPlayerUsageResponse = (Array<PlayerUsage>);
+export type GetPlayerUsageError = unknown;
+export type GetReturningProductionData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetReturningProductionResponse = (Array<ReturningProduction>);
+export type GetReturningProductionError = unknown;
+export type GetTransferPortalData = {
+    query: {
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetTransferPortalResponse = (Array<PlayerTransfer>);
+export type GetTransferPortalError = unknown;
+export type GetPredictedPointsData = {
+    query: {
+        /**
+         * Distance value
+         */
+        distance: number;
+        /**
+         * Down value
+         */
+        down: number;
+    };
+};
+export type GetPredictedPointsResponse = (Array<PredictedPointsValue>);
+export type GetPredictedPointsError = unknown;
+export type GetPredictedPointsAddedByTeamData = {
+    query?: {
+        /**
+         * Conference abbreviation filter
+         */
+        conference?: string;
+        /**
+         * Exclude garbage time plays
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetPredictedPointsAddedByTeamResponse = (Array<TeamSeasonPredictedPointsAdded>);
+export type GetPredictedPointsAddedByTeamError = unknown;
+export type GetPredictedPointsAddedByGameData = {
+    query: {
+        /**
+         * Optional conference abbreviation filter
+         */
+        conference?: string;
+        /**
+         * Optional flag to exclude garbage time plays
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetPredictedPointsAddedByGameResponse = (Array<TeamGamePredictedPointsAdded>);
+export type GetPredictedPointsAddedByGameError = unknown;
+export type GetPredictedPointsAddedByPlayerGameData = {
+    query: {
+        /**
+         * Optional flag to exclude garbage time plays
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Optional player ID filter
+         */
+        playerId?: string;
+        /**
+         * Optional player position abbreviation filter
+         */
+        position?: string;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Team filter, required if week not specified
+         */
+        team?: string;
+        /**
+         * Threshold value for minimum number of plays
+         */
+        threshold?: number;
+        /**
+         * Week filter, required if team not specified
+         */
+        week?: number;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetPredictedPointsAddedByPlayerGameResponse = (Array<PlayerGamePredictedPointsAdded>);
+export type GetPredictedPointsAddedByPlayerGameError = unknown;
+export type GetPredictedPointsAddedByPlayerSeasonData = {
+    query?: {
+        /**
+         * Optional conference abbreviation filter
+         */
+        conference?: string;
+        /**
+         * Optional flag to exclude garbage time plays
+         */
+        excludeGarbageTime?: boolean;
+        /**
+         * Player ID filter, required if year not specified
+         */
+        playerId?: string;
+        /**
+         * Optional position abbreviation filter
+         */
+        position?: string;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Threshold value for minimum number of plays
+         */
+        threshold?: number;
+        /**
+         * Year filter, required if playerId not specified
+         */
+        year?: number;
+    };
+};
+export type GetPredictedPointsAddedByPlayerSeasonResponse = (Array<PlayerSeasonPredictedPointsAdded>);
+export type GetPredictedPointsAddedByPlayerSeasonError = unknown;
+export type GetWinProbabilityData = {
+    query: {
+        /**
+         * Required game ID filter
+         */
+        gameId: number;
+    };
+};
+export type GetWinProbabilityResponse = (Array<PlayWinProbability>);
+export type GetWinProbabilityError = unknown;
+export type GetPregameWinProbabilitiesData = {
+    query?: {
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetPregameWinProbabilitiesResponse = (Array<PregameWinProbability>);
+export type GetPregameWinProbabilitiesError = unknown;
+export type GetFieldGoalExpectedPointsResponse = (Array<FieldGoalEP>);
+export type GetFieldGoalExpectedPointsError = unknown;
+export type GetLivePlaysData = {
+    query: {
+        /**
+         * Game Id filter
+         */
+        gameId: number;
+    };
+};
+export type GetLivePlaysResponse = (LiveGame);
+export type GetLivePlaysError = unknown;
+export type GetLinesData = {
+    query?: {
+        /**
+         * Optional away team filter
+         */
+        away?: string;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional gameId filter
+         */
+        gameId?: number;
+        /**
+         * Optional home team filter
+         */
+        home?: string;
+        /**
+         * Optional provider name filter
+         */
+        provider?: string;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Year filter, required if game id not specified
+         */
+        year?: number;
+    };
+};
+export type GetLinesResponse = (Array<BettingGame>);
+export type GetLinesError = unknown;
+export type GetGamesData = {
+    query?: {
+        /**
+         * Optional away team filter
+         */
+        away?: string;
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional home team filter
+         */
+        home?: string;
+        /**
+         * Game id filter to retrieve a single game
+         */
+        id?: number;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Required year filter (except when id is specified)
+         */
+        year?: number;
+    };
+};
+export type GetGamesResponse = (Array<Game>);
+export type GetGamesError = unknown;
+export type GetGameTeamStatsData = {
+    query?: {
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter, required if week and team not specified
+         */
+        conference?: string;
+        /**
+         * Optional id filter to retrieve a single game
+         */
+        id?: number;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter, required if week and conference not specified
+         */
+        team?: string;
+        /**
+         * Optional week filter, required if team and conference not specified
+         */
+        week?: number;
+        /**
+         * Required year filter (along with one of week, team, or conference), unless id is specified
+         */
+        year?: number;
+    };
+};
+export type GetGameTeamStatsResponse = (Array<GameTeamStats>);
+export type GetGameTeamStatsError = unknown;
+export type GetGamePlayerStatsData = {
+    query?: {
+        /**
+         * Optional player statistical category filter
+         */
+        category?: string;
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter, required if week and team not specified
+         */
+        conference?: string;
+        /**
+         * Optional id filter to retrieve a single game
+         */
+        id?: number;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter, required if week and conference not specified
+         */
+        team?: string;
+        /**
+         * Optional week filter, required if team and conference not specified
+         */
+        week?: number;
+        /**
+         * Required year filter (along with one of week, team, or conference), unless id is specified
+         */
+        year?: number;
+    };
+};
+export type GetGamePlayerStatsResponse = (Array<GamePlayerStats>);
+export type GetGamePlayerStatsError = unknown;
+export type GetMediaData = {
+    query: {
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional media type filter
+         */
+        mediaType?: MediaType;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetMediaResponse = (Array<GameMedia>);
+export type GetMediaError = unknown;
+export type GetWeatherData = {
+    query?: {
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Filter for retrieving a single game
+         */
+        gameId?: number;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Year filter, required if game id not specified
+         */
+        year?: number;
+    };
+};
+export type GetWeatherResponse = (Array<GameWeather>);
+export type GetWeatherError = unknown;
+export type GetRecordsData = {
+    query?: {
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Team filter, required if year not specified
+         */
+        team?: string;
+        /**
+         * Year filter, required if team not specified
+         */
+        year?: number;
+    };
+};
+export type GetRecordsResponse = (Array<TeamRecords>);
+export type GetRecordsError = unknown;
+export type GetCalendarData = {
+    query: {
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetCalendarResponse = (Array<CalendarWeek>);
+export type GetCalendarError = unknown;
+export type GetScoreboardData = {
+    query?: {
+        /**
+         * Optional division classification filter, defaults to fbs
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+    };
+};
+export type GetScoreboardResponse = (Array<ScoreboardGame>);
+export type GetScoreboardError = unknown;
+export type GetDrivesData = {
+    query: {
+        /**
+         * Optional division classification filter
+         */
+        classification?: DivisionClassification;
+        /**
+         * Optional conference filter
+         */
+        conference?: string;
+        /**
+         * Optional defensive team filter
+         */
+        defense?: string;
+        /**
+         * Optional defensive team conference filter
+         */
+        defenseConference?: string;
+        /**
+         * Optional offensive team filter
+         */
+        offense?: string;
+        /**
+         * Optional offensive team conference filter
+         */
+        offenseConference?: string;
+        /**
+         * Optional season type filter
+         */
+        seasonType?: SeasonType;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional week filter
+         */
+        week?: number;
+        /**
+         * Required year filter
+         */
+        year: number;
+    };
+};
+export type GetDrivesResponse = (Array<Drive>);
+export type GetDrivesError = unknown;
+export type GetDraftTeamsResponse = (Array<DraftTeam>);
+export type GetDraftTeamsError = unknown;
+export type GetDraftPositionsResponse = (Array<DraftPosition>);
+export type GetDraftPositionsError = unknown;
+export type GetDraftPicksData = {
+    query?: {
+        /**
+         * Optional college conference filter
+         */
+        conference?: string;
+        /**
+         * Optional position classification filter
+         */
+        position?: string;
+        /**
+         * Optional college team filter
+         */
+        school?: string;
+        /**
+         * Optional NFL team filter
+         */
+        team?: string;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetDraftPicksResponse = (Array<DraftPick>);
+export type GetDraftPicksError = unknown;
+export type GetCoachesData = {
+    query?: {
+        /**
+         * Optional first name filter
+         */
+        firstName?: string;
+        /**
+         * Optional last name filter
+         */
+        lastName?: string;
+        /**
+         * Optional end year range filter
+         */
+        maxYear?: number;
+        /**
+         * Optional start year range filter
+         */
+        minYear?: number;
+        /**
+         * Optional team filter
+         */
+        team?: string;
+        /**
+         * Optional year filter
+         */
+        year?: number;
+    };
+};
+export type GetCoachesResponse = (Array<Coach>);
+export type GetCoachesError = unknown;
+export type GetAdvancedBoxScoreData = {
+    query: {
+        /**
+         * Required game id filter
+         */
+        id: number;
+    };
+};
+export type GetAdvancedBoxScoreResponse = (AdvancedBoxScore);
+export type GetAdvancedBoxScoreError = unknown;