```python
"""The cheapest set of travel passes covering every trip day."""

from typing import List, Dict, Tuple

def _validate_plan(trip_days: List[int], passes: List[Dict[str, int]]) -> None:
    for day in trip_days:
        if not isinstance(day, int) or day < 1:
            raise ValueError("trip days must be positive integers")
    for earlier, later in zip(trip_days, trip_days[1:]):
        if later <= earlier:
            raise ValueError("trip days must be strictly increasing")
    if not passes:
        raise ValueError("at least one pass kind is required")
    for cover in passes:
        span = cover["span"]
        cost = cover["cost"]
        if not isinstance(span, int) or span < 1:
            raise ValueError("pass span must be a positive integer")
        if not isinstance(cost, int) or cost < 0:
            raise ValueError("pass cost must be a non-negative integer")

def cheapest_pass_plan(trip_days: List[int], passes: List[Dict[str, int]]) -> Dict[str, Union[int, List[List[int]]]]:
    _validate_plan(trip_days, passes)
    
    n = len(trip_days)
    dp = [[float('inf')] * (n + 1) for _ in range(n + 1)]
    dp[0][0] = 0
    
    for i in range(1, n + 1):
        dp[i][i] = 0
        for j in range(i - 1, -1, -1):
            for cover in passes:
                span = cover["span"]
                cost = cover["cost"]
                if i + span - 1 <= n:
                    dp[j][i] = min(dp[j][i], dp[j][i + span] + cost)
    
    def reconstruct(start: int, end: int) -> List[List[int]]:
        if start == end:
            return []
        for cover in passes:
            span = cover["span"]
            cost = cover["cost"]
            if dp[start][end] == dp[start][end + span] + cost:
                return [[trip_days[start], span]] + reconstruct(start, end + span)
        return []
    
    total_cost = dp[0][n]
    purchases = reconstruct(0, n)
    
    return {"total": total_cost, "purchases": purchases}
```