def parse_award(self, html: str, *, award: str) -> Dict[str, Any]:
    """Parse an award history page and return a dict for model validation.

    Returns:
        A dict with keys ``award``, ``winners``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="awards")
    if table is None:
        return {"award": award, "winners": []}

    winners = self._parse_award_rows(table)
    return {"award": award, "winners": winners}

def parse_hof(self, html: str) -> Dict[str, Any]:
    """Parse the Hall of Fame page and return a dict for model validation.

    Returns:
        A dict with key ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="hof_players")
    if table is None:
        return {"players": []}

    players = self._parse_hof_rows(table)
    return {"players": players}

def parse_probowl(self, html: str, *, year: int) -> Dict[str, Any]:
    """Parse a Pro Bowl roster page and return a dict for model validation.

    Returns:
        A dict with keys ``year``, ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="pro_bowl")
    if table is None:
        return {"year": year, "players": []}

    players = self._parse_probowl_rows(table)
    return {"year": year, "players": players}

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the birthdays page.

    Args:
        html: Raw HTML of the PFR birthdays page.

    Returns:
        A dict ready for ``Birthdays.model_validate()``.

    Raises:
        ParsingError: If the birthdays table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)
    month, day = self._extract_month_day(title)

    table = soup.find("table", id="birthdays")
    if table is None:
        raise ParsingError(
            "Could not find birthdays table in the HTML.",
            selector="birthdays",
            html_sample=html[:500],
        )

    players = self._parse_table(table)

    return {
        "title": title,
        "month": month,
        "day": day,
        "players": players,
    }

def parse_landing(self, html: str) -> Dict[str, Any]:
    """Parse the birthplaces landing page.

    Args:
        html: Raw HTML of the PFR birthplaces landing page.

    Returns:
        A dict ready for ``BirthplaceLanding.model_validate()``.

    Raises:
        ParsingError: If the birthplaces table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_landing_title(soup)

    table = soup.find("table", id="birthplaces")
    if table is None:
        raise ParsingError(
            "Could not find birthplaces table in the HTML.",
            selector="birthplaces",
            html_sample=html[:500],
        )

    locations = self._parse_landing_table(table)

    return {
        "title": title,
        "locations": locations,
    }

def parse_filtered(self, html: str) -> Dict[str, Any]:
    """Parse the birthplaces filtered (by location) page.

    Args:
        html: Raw HTML of the PFR birthplaces filtered page.

    Returns:
        A dict ready for ``BirthplaceFiltered.model_validate()``.

    Raises:
        ParsingError: If the birthplaces table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_filtered_title(soup)
    country, state = self._extract_country_state(title)

    table = soup.find("table", id="birthplaces")
    if table is None:
        raise ParsingError(
            "Could not find birthplaces table in the HTML.",
            selector="birthplaces",
            html_sample=html[:500],
        )

    players = self._parse_filtered_table(table)

    return {
        "title": title,
        "country": country,
        "state": state,
        "players": players,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse a PFR coach profile page into a JSON-serializable dict.

    Args:
        html: Raw HTML string of a PFR coach profile page.

    Returns:
        A dict with keys: bio, coaching_results, coaching_results_totals,
        coaching_ranks, coaching_history, challenge_results, worked_for,
        employed.
    """
    cleaned = re.sub(r"<!--(.*?)-->", r"\1", html, flags=re.DOTALL)
    soup = BeautifulSoup(cleaned, "html.parser")

    result: Dict[str, Any] = {}
    result["bio"] = self._parse_bio(soup)

    results, totals = self._parse_coaching_results(soup)
    result["coaching_results"] = results
    result["coaching_results_totals"] = totals

    result["coaching_ranks"] = self._parse_coaching_ranks(soup)
    result["coaching_history"] = self._parse_coaching_history(soup)
    result["challenge_results"] = self._parse_challenge_results(soup)
    result["worked_for"] = self._parse_coaching_tree_table(soup, "worked_for")
    result["employed"] = self._parse_coaching_tree_table(soup, "employed")

    return result

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the cups of coffee page.

    Args:
        html: Raw HTML of the PFR cups of coffee page.

    Returns:
        A dict ready for ``CupsOfCoffee.model_validate()``.

    Raises:
        ParsingError: If the coffee table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="coffee")
    if table is None:
        raise ParsingError(
            "Could not find coffee table in the HTML.",
            selector="coffee",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse_year_draft(self, html: str, *, year: int) -> Dict[str, Any]:
    """Parse a year draft page and return a dict for model validation.

    Returns:
        A dict with keys ``year``, ``picks``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="drafts")
    if table is None:
        return {"year": year, "picks": []}

    picks = self._parse_year_draft_rows(table)
    return {"year": year, "picks": picks}

def parse_combine(self, html: str, *, year: int) -> Dict[str, Any]:
    """Parse a combine page and return a dict for model validation.

    Returns:
        A dict with keys ``year``, ``entries``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="combine")
    if table is None:
        return {"year": year, "entries": []}

    entries = self._parse_combine_rows(table)
    return {"year": year, "entries": entries}

def parse_team_draft(self, html: str, *, team: str) -> Dict[str, Any]:
    """Parse a team draft page and return a dict for model validation.

    Returns:
        A dict with keys ``team``, ``picks``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="draft")
    if table is None:
        return {"team": team, "picks": []}

    picks = self._parse_team_draft_rows(table)
    return {"team": team, "picks": picks}

def parse(self, html: str) -> Dict[str, Any]:
    """Parse a full executive profile page.

    Returns:
        A dict with keys ``bio``, ``exec_results``, and
        ``exec_results_totals``.
    """
    soup = BeautifulSoup(html, "html.parser")

    bio = self._parse_bio(soup)

    table = soup.find("table", id="exec_results")
    if table is None:
        return {
            "bio": bio,
            "exec_results": [],
            "exec_results_totals": [],
        }

    results = self._parse_results(table)
    totals = self._parse_totals(table)

    return {
        "bio": bio,
        "exec_results": results,
        "exec_results_totals": totals,
    }

def parse_top_players(self, html: str) -> Dict[str, Any]:
    """Parse the top fantasy players page.

    Returns:
        A dict with key ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="fantasy")
    if table is None:
        return {"players": []}

    players = self._parse_player_rows(table)
    return {"players": players}

def parse_matchups(self, html: str) -> Dict[str, Any]:
    """Parse a fantasy matchups page.

    Works for any position (QB, WR, RB, TE) since the parser reads
    whichever ``data-stat`` columns are present in the table.

    Returns:
        A dict with key ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="fantasy_stats")
    if table is None:
        return {"players": []}

    players = self._parse_matchup_rows(table)
    return {"players": players}

def parse_points_allowed(self, html: str) -> Dict[str, Any]:
    """Parse a fantasy points allowed page.

    Works for any position (QB, WR, RB, TE) since the parser reads
    whichever ``data-stat`` columns are present in the table.

    Returns:
        A dict with key ``teams``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="fantasy_def")
    if table is None:
        return {"teams": []}

    teams = self._parse_points_allowed_rows(table)
    return {"teams": teams}

def parse_redzone_passing(self, html: str) -> Dict[str, Any]:
    """Parse the red zone passing page.

    Returns:
        A dict with key ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="fantasy_rz")
    if table is None:
        return {"players": []}

    players = self._parse_rz_passing_rows(table)
    return {"players": players}

def parse_redzone_receiving(self, html: str) -> Dict[str, Any]:
    """Parse the red zone receiving page.

    Returns:
        A dict with key ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="fantasy_rz")
    if table is None:
        return {"players": []}

    players = self._parse_rz_receiving_rows(table)
    return {"players": players}

def parse_redzone_rushing(self, html: str) -> Dict[str, Any]:
    """Parse the red zone rushing page.

    Returns:
        A dict with key ``players``.
    """
    soup = BeautifulSoup(html, "html.parser")

    table = soup.find("table", id="fantasy_rz")
    if table is None:
        return {"players": []}

    players = self._parse_rz_rushing_rows(table)
    return {"players": players}

def parse(self, html: str) -> Dict[str, Any]:
    """Parse a PFR boxscore page into a comprehensive JSON-serializable dict.

    Extracts all game-specific data from
    ``/boxscores/{game_id}.htm`` pages, including:

    * Scorebox metadata (teams, final scores, records, coaches)
    * Quarter-by-quarter linescore
    * Scoring plays
    * Game info (coin toss, weather, surface, vegas line, etc.)
    * Officials
    * Expected points summary
    * Team stats (first downs, yards, turnovers, etc.)
    * Player offense (passing, rushing, receiving)
    * Player defense (interceptions, tackles, sacks)
    * Kick/punt returns
    * Kicking & punting
    * Home/visitor starters
    * Home/visitor snap counts
    * Home/visitor drives

    Many tables on PFR boxscore pages are hidden inside HTML comments
    as an anti-scraping measure.  The BaseSDK pre-processes the HTML to
    uncomment these tables before this parser runs.

    Args:
        html: Raw HTML string of a PFR boxscore page.

    Returns:
        A dict with all extracted game data.
    """
    soup = BeautifulSoup(html, "html.parser")

    result: Dict[str, Any] = {}

    result["scorebox"] = self._parse_scorebox(soup)
    result["linescore"] = self._parse_linescore(soup)

    result["scoring"] = self._parse_table_rows(soup, "scoring")
    result["game_info"] = self._parse_kv_table(soup, "game_info")
    result["officials"] = self._parse_kv_table(soup, "officials")
    result["expected_points"] = self._parse_table_rows(soup, "expected_points")
    result["team_stats"] = self._parse_team_stats(soup)
    result["player_offense"] = self._parse_table_rows(soup, "player_offense")
    result["player_defense"] = self._parse_table_rows(soup, "player_defense")
    result["returns"] = self._parse_table_rows(soup, "returns")
    result["kicking"] = self._parse_table_rows(soup, "kicking")
    result["home_starters"] = self._parse_table_rows(soup, "home_starters")
    result["vis_starters"] = self._parse_table_rows(soup, "vis_starters")
    result["home_snap_counts"] = self._parse_table_rows(soup, "home_snap_counts")
    result["vis_snap_counts"] = self._parse_table_rows(soup, "vis_snap_counts")
    result["home_drives"] = self._parse_table_rows(soup, "home_drives")
    result["vis_drives"] = self._parse_table_rows(soup, "vis_drives")

    return result

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the last-undefeated-team page.

    Args:
        html: Raw HTML of the PFR last-undefeated-team page.

    Returns:
        A dict ready for ``LastUndefeated.model_validate()``.

    Raises:
        ParsingError: If the undefeated_teams table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="undefeated_teams")
    if table is None:
        raise ParsingError(
            "Could not find undefeated_teams table in the HTML.",
            selector="undefeated_teams",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse(self, html: str, *, stat: str, scope: str) -> Dict[str, Any]:
    """Parse a leaders page and return a dict ready for model validation.

    Args:
        html: Raw HTML content of the leaders page.
        stat: The stat key (e.g. ``"pass_yds"``).
        scope: The scope (e.g. ``"career"``, ``"single_season"``).

    Returns:
        A dict with keys ``stat``, ``scope``, ``title``, ``entries``.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = None
    h1 = soup.find("h1")
    if h1:
        title = h1.get_text(strip=True)

    entries = self._parse_entries(soup, stat)

    return {
        "stat": stat,
        "scope": scope,
        "title": title,
        "entries": entries,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the multisport athletes page.

    Args:
        html: Raw HTML of the PFR multisport athletes page.

    Returns:
        A dict ready for ``MultiSportPlayers.model_validate()``.

    Raises:
        ParsingError: If the multisport table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="multisport")
    if table is None:
        raise ParsingError(
            "Could not find multisport table in the HTML.",
            selector="multisport",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the multi-team players results page.

    Args:
        html: Raw HTML of the PFR multi-franchise players results page.

    Returns:
        A dict ready for ``MultiTeamPlayers.model_validate()``.

    Raises:
        ParsingError: If no stats tables are found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)
    total_players = self._extract_total_players(soup)
    teams = self._extract_teams(soup)
    top_players = self._extract_top_players(soup)

    stats_tables: List[Dict[str, Any]] = []
    idx = 0
    while True:
        table_id = f"{self._TABLE_ID_PREFIX}{idx}"
        table = soup.find("table", id=table_id)
        if table is None:
            break

        category = self._extract_table_category(soup, table_id)
        players = self._parse_table(table)

        stats_tables.append(
            {
                "category": category,
                "teams": teams,
                "players": players,
            }
        )
        idx += 1

    if not stats_tables:
        raise ParsingError(
            "Could not find any multifranchise_stats tables in the HTML.",
            selector="multi_team_stats",
            html_sample=html[:500],
        )

    return {
        "title": title,
        "total_players": total_players,
        "teams": teams,
        "top_players": top_players,
        "stats_tables": stats_tables,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the non-quarterback passers page.

    Args:
        html: Raw HTML of the PFR non-QB passers page.

    Returns:
        A dict ready for ``NonQBPassers.model_validate()``.

    Raises:
        ParsingError: If the nonqb_passers table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="nonqb_passers")
    if table is None:
        raise ParsingError(
            "Could not find nonqb_passers table in the HTML.",
            selector="nonqb_passers",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the non-skill position TD scorers page.

    Args:
        html: Raw HTML of the PFR odd TD scorers page.

    Returns:
        A dict ready for ``NonSkillPosTdScorers.model_validate()``.

    Raises:
        ParsingError: If the odd_scorers table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="odd_scorers")
    if table is None:
        raise ParsingError(
            "Could not find odd_scorers table in the HTML.",
            selector="odd_scorers",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the octopus tracker page.

    Args:
        html: Raw HTML of the PFR octopus tracker page.

    Returns:
        A dict ready for ``OctopusTracker.model_validate()``.

    Raises:
        ParsingError: If the octopus table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="octopus")
    if table is None:
        raise ParsingError(
            "Could not find octopus table in the HTML.",
            selector="octopus",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse(self, html: str) -> Dict[str, Any]:
    """Parse a PFR official profile page into a JSON-serializable dict.

    Args:
        html: Raw HTML string of a PFR official profile page.

    Returns:
        A dict with keys: bio, official_stats, games.
    """
    cleaned = re.sub(r"<!--(.*?)-->", r"\1", html, flags=re.DOTALL)
    soup = BeautifulSoup(cleaned, "html.parser")

    result: Dict[str, Any] = {}
    result["bio"] = self._parse_bio(soup)
    result["official_stats"] = self._parse_official_stats(soup)
    result["games"] = self._parse_games(soup)

    return result

def parse(self, html: str) -> Dict[str, Any]:
    """Parse the overtime ties page.

    Args:
        html: Raw HTML of the PFR overtime ties page.

    Returns:
        A dict ready for ``OvertimeTies.model_validate()``.

    Raises:
        ParsingError: If the overtime ties table is not found.
    """
    soup = BeautifulSoup(html, "html.parser")

    title = self._extract_title(soup)

    table = soup.find("table", id="ot_ties")
    if table is None:
        raise ParsingError(
            "Could not find ot_ties table in the HTML.",
            selector="ot_ties",
            html_sample=html[:500],
        )

    entries = self._parse_table(table)

    return {
        "title": title,
        "entries": entries,
    }

def parse(self, html: str) -> PlayerProfile:
    """Parse a PFR player profile page into a structured dict.

    Uncomments hidden HTML tables, then extracts bio, jersey numbers,
    summary stats, full career statistics, transactions, navigation
    links, and leaderboard data.

    Args:
        html: Raw HTML string of a PFR
            ``/players/{letter}/{player_id}.htm`` page.

    Returns:
        A dict suitable for validation into a
        :class:`~griddy.pfr.models.PlayerProfile` model.
    """
    cleaned_html = re.sub(r"<!--(.*?)-->", r"\1", html, flags=re.DOTALL)
    self.soup = BeautifulSoup(cleaned_html, features="html.parser")
    bio = self._parse_meta_panel(panel=self.soup.find(id="meta"))
    jersey_numbers = self._parse_jersey_numbers(
        tag=self.soup.find(class_="uni_holder")
    )
    summary_stats = self._parse_stats_summary(
        tag=self.soup.find(class_="stats_pullout")
    )

    stats_tables = self.soup.find_all("table", class_="stats_table")
    full_stats = self._extract_all_stats(stats_tables=stats_tables)

    transactions_div = self.soup.find(id="div_transactions")
    transactions = (
        self._parse_transactions(tag=transactions_div) if transactions_div else []
    )

    bottom_nav_div = self.soup.find(id="bottom_nav_container")
    player_links = (
        self._parse_bottom_nav(tag=bottom_nav_div) if bottom_nav_div else {}
    )

    leaderboard_div = self.soup.find(id="div_leaderboard")
    leader_boards = (
        self._parse_leader_boards(tag=leaderboard_div) if leaderboard_div else {}
    )

    return {
        "bio": bio,
        "jersey_numbers": jersey_numbers,
        "summary_stats": summary_stats,
        "statistics": full_stats,
        "transactions": transactions,
        "links": player_links,
        "leader_boards": leader_boards,
    }