CricketScript · Bonus — 12th Man ← Course

Bonus — Reserved for Full Side

The 12th man comes in for the side that's already eleven strong.

Bonus content is reserved for cricketers who've played every over. A few are still to face.

0 of 11 lessons read

Still to face

Open the course outline →

Bonus · 12th Man

Real IPL data modelling.

The 12th man comes in for the big innings. You've learned eleven concepts — here they all are, in one real match.

The eleven lessons used toy data — one batter, a tiny lineup, a single delivery. The shape of real IPL data is bigger. A T20 match has 240 balls, two innings, ten players a side, and a hundred edge cases. But it's modelled with the same eleven concepts you already know.

Below is a real-shape T20 match — its scorecard, the raw delivery data, and the TypeScript that models it from the top down. On the right of each TS line is a tag telling you which lesson that concept came from.

1. The match.

A T20 evening at Eden Gardens. CricketScript XI batting first against the Mumbai Tigers. The data is fictional; the shape mirrors what Cricsheet and ESPNCricinfo actually publish.

T20 · Eden Gardens · 13 Apr 2026 1st innings · 20 overs

CricketScript XI vs Mumbai Tigers

CricketScript XISharma 64* (42) · Iyer 38 (28) · Pretorius 29* (12) 162 / 4 (20)

Mumbai TigersMehta 49 (38) · Verma 34 (26) · Singh 3/24 (4) 158 / 9 (20)

CricketScript XI won by 4 runs · Player of the Match: Singh

2. The data.

The match arrives as JSON — one record per delivery, plus headers for the match itself. Here's the third over: Mehta to Sharma and Iyer, ending in a caught dismissal.

{
  "match": {
    "format": "T20",
    "date": "2026-04-13",
    "venue": "Eden Gardens, Kolkata",
    "teams": ["CricketScript XI", "Mumbai Tigers"]
  },
  "innings": [{
    "team": "CricketScript XI",
    "over": 3,
    "deliveries": [
      { "ball":1, "bowler":"Mehta", "batter":"Sharma", "runs":1 },
      { "ball":2, "bowler":"Mehta", "batter":"Iyer",   "runs":4 },
      { "ball":3, "bowler":"Mehta", "batter":"Iyer",   "runs":0 },
      { "ball":4, "bowler":"Mehta", "batter":"Iyer",   "runs":1 },
      { "ball":5, "bowler":"Mehta", "batter":"Sharma", "runs":6 },
      { "ball":6, "bowler":"Mehta", "batter":"Sharma", "runs":0,
        "dismissal": { "kind":"Caught", "fielder":"Verma" } }
    ]
  }]
}

3. The types.

And now the TypeScript that models it. Read top-to-bottom. Each tag on the right tells you which lesson that line came from.

// Format of the match.
 
type Format = 'Test' | 'ODI' | 'T20';
L05 unions
// The batting lineup is a list of names.
 
type Lineup = string[];
L02 arrays · L08 aliases
// A partnership at the wicket: two batters, exact order.
 
type Partnership = [string, string];
L03 tuples · L08
// Runs off a single ball — only six legal values.
 
type Run = 0 | 1 | 2 | 3 | 4 | 6;
L08 aliases · L05
// Five ways a batter can be dismissed.
 
enum Dismissal {
L09 enums
  Bowled, Caught, LBW, RunOut, Stumped
 
}
 
// Bowling style — only three options in this XI.
 
type BowlingStyle = 'fast' | 'spin' | 'medium';
L05 unions · L08
// A player record.
 
interface Player {
L04 interfaces
  name:      string;
L01 primitives
  role:      string;
 
  jersey:    number;
 
  isCaptain: boolean;
 
  bowlingStyle?: BowlingStyle;
L07 optional
}
 
// A single delivery — the atom of the game.
 
interface Delivery {
L04 interfaces
  over:    number;
 
  ball:    number;
 
  bowler:  Player;
 
  batter:  Player;
 
  runs:    Run;
 
  extras?: number;
L07 optional
  dismissal?: {
L07 optional
    kind:       Dismissal;
L09
    batterOut:  Player;
 
    fielder?:   Player;
L07
  };
 
}
 
// One innings — generic on the match format.
 
interface Innings<T extends Format> {
L10 generics
  format:       T;
 
  team:         string;
 
  lineup:       Lineup;
L02
  deliveries:   Delivery[];
L02
  score:        number;
 
  wickets:      number;
 
  partnerships: Partnership[];
L03
}
 
// The whole match.
 
interface Match {
L04 interfaces
  format:         Format;
 
  date:           string;
 
  venue:          string;
 
  home:           Innings<'T20'>;
L10
  away:           Innings<'T20'>;
L10
  manOfTheMatch?: Player;
L07
  winner:         string;
 
  margin:         number;
 
}
 
// A function that totals an innings.
 
function score(deliveries: Delivery[]): number {
L06 functions
  return deliveries.reduce((acc, d) => acc + d.runs, 0);
 
}
 
// A type guard — narrows Player to a centurion in scope.
 
function isCenturion(
L11 narrowing
  p: Player & { runs: number }
 
): p is Player & { runs: number; isCenturion: true } {
 
  return p.runs >= 100;
 
}
 

You've used every tool.

From a primitive string for the venue all the way up to a generic Innings<T> for the format-aware innings, you've now read a production-grade TypeScript model — using only the eleven concepts you learned in the course.

Real-world IPL data shapes are almost identical to this. Cricsheet's public JSON, ESPNCricinfo's match feeds, the IPL's own API — all of them are versions of this. You're ready to write code against any of them.

The 12th man can step in for any spot. Your eleven concepts can model any data shape that comes their way.

Bowl the next over → The Honours Board Course outline