PlayerFixture

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/datasportsapi/json-schema/datasportsapi-player-fixture-schema.json",
  "title": "PlayerFixture",
  "description": "An entry in a player’s fixture list: a Fixture plus the player’s personal involvement (`playerMatch`).",
  "x-generated": "2026-11-12",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/datasportsapi-openapi.json#/components/schemas/PlayerFixture",
  "type": "object",
  "properties": {
    "id": {
      "type": "integer",
      "description": "The fixture’s id."
    },
    "sport": {
      "type": "string",
      "description": "Slug of the sport, matching /v2/sports."
    },
    "status": {
      "$ref": "#/$defs/Status",
      "description": "Current state of the match."
    },
    "startTime": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "description": "When the match starts: initially the planned time, swapped for the actual kick-off once our data source logs it (its live feed delivers this a few minutes after the start). Every endpoint and every WebSocket delta carries the same value."
    },
    "league": {
      "anyOf": [
        {
          "$ref": "#/$defs/LeagueRef"
        },
        {
          "type": "null"
        }
      ],
      "description": "Competition the fixture belongs to. Null if our data source places the fixture in a competition without a matching league — seen on 2026-10-23 in minor regional football, e.g. South Africa’s National Second Division; in that case season and round are null as well."
    },
    "season": {
      "anyOf": [
        {
          "$ref": "#/$defs/Season"
        },
        {
          "type": "null"
        }
      ],
      "description": "Season the fixture is part of."
    },
    "round": {
      "anyOf": [
        {
          "$ref": "#/$defs/Round"
        },
        {
          "type": "null"
        }
      ],
      "description": "Round of the fixture, for competitions organised in rounds."
    },
    "home": {
      "anyOf": [
        {
          "$ref": "#/$defs/TeamRef"
        },
        {
          "type": "null"
        }
      ],
      "description": "The home side; null until it is known (our data source shows a placeholder such as \"WQF1\", the winner of quarter-final 1)."
    },
    "away": {
      "anyOf": [
        {
          "$ref": "#/$defs/TeamRef"
        },
        {
          "type": "null"
        }
      ],
      "description": "The away side; null until it is known (our data source shows a placeholder such as \"WQF1\")."
    },
    "homeScore": {
      "$ref": "#/$defs/ScoreSide",
      "description": "The home side’s score."
    },
    "awayScore": {
      "$ref": "#/$defs/ScoreSide",
      "description": "The away side’s score."
    },
    "winner": {
      "anyOf": [
        {
          "$ref": "#/$defs/Winner"
        },
        {
          "type": "null"
        }
      ],
      "description": "Remains null until status.type is finished, and stays null for a fight declared a no contest (`fightResult.method` noContest). If a match was settled on penalties, this is always the shoot-out winner, regardless of our data source (which, on a second leg, names whoever won the 90 minutes). When the source omits a winner, or reports a draw in a sport where draws are impossible, we derive it from the score (matches ending in regular time or overtime; cricket excluded)."
    },
    "venue": {
      "anyOf": [
        {
          "$ref": "#/$defs/Venue"
        },
        {
          "type": "null"
        }
      ],
      "description": "Where the match is played, if known (lower tiers often have none). Populated on /fixtures/{id} and, when our data source provides it, in date lists. Round, team, player and live lists never include a venue, so null there means \"not included\" rather than \"unknown\"; fetch /fixtures/{id} to get it."
    },
    "clock": {
      "anyOf": [
        {
          "$ref": "#/$defs/Clock"
        },
        {
          "type": "null"
        }
      ],
      "description": "Running match clock; null if our data source has no clock for the fixture, and after the match ends."
    },
    "firstToServe": {
      "anyOf": [
        {
          "$ref": "#/$defs/Side"
        },
        {
          "type": "null"
        }
      ],
      "description": "Deprecated since 2026-10-23 — mirrors `serving`. Because our data source refreshes it every game / leg, it reflects the side serving (throwing) at present, not the one that served first; use `serving` instead."
    },
    "serving": {
      "anyOf": [
        {
          "$ref": "#/$defs/Side"
        },
        {
          "type": "null"
        }
      ],
      "description": "Tennis, darts and other sports with a serve: which side is serving (throwing) at the moment, refreshed by our data source each game / leg. Null if the source does not report it."
    },
    "servedFirst": {
      "anyOf": [
        {
          "$ref": "#/$defs/Side"
        },
        {
          "type": "null"
        }
      ],
      "description": "Darts: which side threw first in the match (`serving` tells you who is throwing at present). Set when play starts and unchanged afterwards; null before the start, when the source is silent, and for every sport other than darts. Since 2026-11-11."
    },
    "homeSeed": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "In seeded events — tennis draws, or playoff seeding in basketball and other sports — the seed of the home side (\"1\", \"12\") or its entry status (\"WC\" wild card, \"Q\" qualifier, \"LL\" lucky loser, \"PR\" protected ranking, …) as printed on the draw. Unseeded sides get null."
    },
    "awaySeed": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "Seed or entry status of the away side, following the same rules as homeSeed."
    },
    "note": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "Cricket only: our data source’s match note, which becomes the result line after the finish (\"Pakistan beat Sri Lanka by 37 runs\"). Intended for display only."
    },
    "battingSide": {
      "anyOf": [
        {
          "$ref": "#/$defs/Side"
        },
        {
          "type": "null"
        }
      ],
      "description": "Cricket only: the side currently batting. Null when no innings is under way, and for all other sports."
    },
    "fightResult": {
      "anyOf": [
        {
          "$ref": "#/$defs/FightResult"
        },
        {
          "type": "null"
        }
      ],
      "description": "MMA and boxing: how, in which round and at what time the fight ended. Null until status.type is finished, or when our data source gives no method."
    },
    "fightDiscipline": {
      "anyOf": [
        {
          "$ref": "#/$defs/FightDiscipline"
        },
        {
          "type": "null"
        }
      ],
      "description": "Combat sports: the discipline of this bout when our data source tags one (the `mma` sport includes boxing, kickboxing and Muay Thai cards too). Only some cards get a tag — ONE, Queensbury and some OKTAGON fights, but never UFC or PFL — so null tells you nothing about whether the bout is MMA."
    },
    "referee": {
      "anyOf": [
        {
          "$ref": "#/$defs/Referee"
        },
        {
          "type": "null"
        }
      ],
      "description": "Named only if our data source has one (football and some other sports; in cricket, the match referee). You get it on /fixtures/{id}; list endpoints return null since it is not included there."
    },
    "homeManager": {
      "anyOf": [
        {
          "$ref": "#/$defs/ManagerRef"
        },
        {
          "type": "null"
        }
      ],
      "description": "Manager or head coach of the home side for this fixture, if our data source names one. Populated on /fixtures/{id}; null in lists."
    },
    "awayManager": {
      "anyOf": [
        {
          "$ref": "#/$defs/ManagerRef"
        },
        {
          "type": "null"
        }
      ],
      "description": "Manager or head coach of the away side; same behaviour as homeManager."
    },
    "surface": {
      "anyOf": [
        {
          "$ref": "#/$defs/Surface"
        },
        {
          "type": "null"
        }
      ],
      "description": "Court surface for tennis matches, returned on /fixtures/{id} and in live lists; other sports get null."
    },
    "discipline": {
      "anyOf": [
        {
          "$ref": "#/$defs/MatchDiscipline"
        },
        {
          "type": "null"
        }
      ],
      "description": "Tennis: whether the match is singles or doubles, given on all fixture endpoints, lists and WebSocket snapshots; other sports, and matches the source does not label, get null. Since 2026-11-11."
    },
    "toss": {
      "anyOf": [
        {
          "$ref": "#/$defs/CricketToss"
        },
        {
          "type": "null"
        }
      ],
      "description": "Cricket only: the toss result, once it has taken place. Populated on /fixtures/{id}; null for every other sport."
    },
    "umpires": {
      "anyOf": [
        {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        {
          "type": "null"
        }
      ],
      "description": "Cricket only: the on-field umpires in our data source’s wording (frequently with a country code, e.g. \"Asif Yaqoob (PAK)\"); null if none are listed, and for every other sport."
    },
    "tvUmpire": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "Cricket only: the TV (third) umpire, handled the same way as umpires."
    },
    "previousLegFixtureId": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "description": "For two-legged ties and playoff series: the fixture id of the tie’s preceding leg / game, if our data source links it. Look it up via /fixtures/{id} to get the first-leg score."
    },
    "aggregateWinner": {
      "anyOf": [
        {
          "$ref": "#/$defs/Side"
        },
        {
          "type": "null"
        }
      ],
      "description": "Set only once a two-legged tie’s return leg has finished: the team that progressed. We take our data source’s verdict; failing that, we use `aggregated` (the higher total goes through) or, when the aggregate is level, the shoot-out. Null in all other cases, including a level aggregate the source leaves unresolved (an away-goals rule). Compare `winner`, which is this match’s winner: after a second leg settled on penalties both point to the shoot-out winner, but otherwise they can disagree (a team can win the second leg yet be eliminated). Only /fixtures/{id} fills it; lists and live snapshots leave it out and may show null."
    },
    "fightCard": {
      "anyOf": [
        {
          "$ref": "#/$defs/FightCard"
        },
        {
          "type": "null"
        }
      ],
      "description": "MMA and boxing: the bout’s card section, position on the card and weight class, if our data source lists them."
    },
    "attendance": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "description": "Crowd size, if our data source reports one (observed for NBA and MLB games, often appearing only after the game has started). Populated on /fixtures/{id}; lists return null because it is not included."
    },
    "matchFormat": {
      "anyOf": [
        {
          "$ref": "#/$defs/MatchFormat"
        },
        {
          "type": "null"
        }
      ],
      "description": "Match format for darts and esports — best of N sets / legs / games — when our data source provides it. Other sports get null."
    },
    "inningState": {
      "anyOf": [
        {
          "$ref": "#/$defs/InningState"
        },
        {
          "type": "null"
        }
      ],
      "description": "Baseball only: the game situation right now — inning, half, balls, strikes, outs and runners on base. It is null while the game is not in progress or interrupted, and in every other sport. WebSocket deltas carry it live."
    },
    "timeouts": {
      "anyOf": [
        {
          "$ref": "#/$defs/Timeouts"
        },
        {
          "type": "null"
        }
      ],
      "description": "Basketball: timeouts left for each side, filled only during an in-progress or interrupted game and only if our data source tracks them; null otherwise. WebSocket deltas carry live updates."
    },
    "downAndDistance": {
      "anyOf": [
        {
          "$ref": "#/$defs/DownAndDistance"
        },
        {
          "type": "null"
        }
      ],
      "description": "American football only: down, distance and field position at this moment. It is null while the game is not in progress or interrupted, and in every other sport. Delivered live through WebSocket deltas. Available since 2026-11-09."
    },
    "varCheck": {
      "anyOf": [
        {
          "$ref": "#/$defs/VarCheck"
        },
        {
          "type": "null"
        }
      ],
      "description": "Football only: an ongoing VAR review; null when there is none, outside play, and for every other sport. Delivered live through WebSocket deltas. Available since 2026-11-09."
    },
    "bonus": {
      "anyOf": [
        {
          "$ref": "#/$defs/BasketballBonus"
        },
        {
          "type": "null"
        }
      ],
      "description": "Basketball only: the side or sides in the bonus. It is null while the game is not in progress or interrupted, and when our data source gives no value; the source’s live feed lacks it, so you only get it over REST and in lists. Available since 2026-11-09."
    },
    "finalResultOnly": {
      "type": "boolean",
      "description": "`true` if our data source covers only the final result of this fixture, with no live score, clock or events during play (since 2026-11-09)."
    },
    "durations": {
      "anyOf": [
        {
          "$ref": "#/$defs/Durations"
        },
        {
          "type": "null"
        }
      ],
      "description": "Sports played in sets or rounds: the length of every finished period (since 2026-11-04). Null for sports our data source does not time by period (football, basketball, …) and until the first period is over. Delivered live through WebSocket deltas."
    },
    "lineupsAvailable": {
      "anyOf": [
        {
          "type": "boolean"
        },
        {
          "type": "null"
        }
      ],
      "description": "`true` once our data source has published lineups for the fixture, whether predicted or official (`confirmed` on /v2/fixtures/{id}/lineups tells you which); `false` if they were withdrawn. We set it the moment the source’s live feed announces lineups, or when a lineup we fetch contains players. Null means we have no information (no announcement observed, nothing fetched). WebSocket deltas carry it live — on fixture:{id} from before kick-off, and on the list channels once play starts. Available since 2026-11-04."
    },
    "lineupsConfirmed": {
      "anyOf": [
        {
          "type": "boolean"
        },
        {
          "type": "null"
        }
      ],
      "description": "`true` once official lineups have been released (`confirmed` on /v2/fixtures/{id}/lineups), set in the same way as lineupsAvailable; null means we have no information. Delivered live through WebSocket deltas. Available since 2026-11-04."
    },
    "playerMatch": {
      "anyOf": [
        {
          "$ref": "#/$defs/PlayerMatch"
        },
        {
          "type": "null"
        }
      ],
      "description": "The player’s own involvement in this fixture, or null when our data source has nothing listed."
    }
  },
  "required": [
    "id",
    "sport",
    "status",
    "startTime",
    "league",
    "season",
    "round",
    "home",
    "away",
    "homeScore",
    "awayScore",
    "winner",
    "venue",
    "clock",
    "firstToServe",
    "serving",
    "servedFirst",
    "homeSeed",
    "awaySeed",
    "note",
    "battingSide",
    "fightResult",
    "fightDiscipline",
    "referee",
    "homeManager",
    "awayManager",
    "surface",
    "discipline",
    "toss",
    "umpires",
    "tvUmpire",
    "previousLegFixtureId",
    "aggregateWinner",
    "fightCard",
    "attendance",
    "matchFormat",
    "inningState",
    "timeouts",
    "downAndDistance",
    "varCheck",
    "bonus",
    "finalResultOnly",
    "durations",
    "lineupsAvailable",
    "lineupsConfirmed",
    "playerMatch"
  ],
  "$defs": {
    "Bases": {
      "type": "object",
      "description": "Baseball: occupancy of each base.",
      "properties": {
        "first": {
          "type": "boolean",
          "description": "True when first base is occupied."
        },
        "second": {
          "type": "boolean",
          "description": "True when second base is occupied."
        },
        "third": {
          "type": "boolean",
          "description": "True when third base is occupied."
        }
      },
      "required": [
        "first",
        "second",
        "third"
      ]
    },
    "BasketballBonus": {
      "type": "object",
      "description": "Basketball: bonus (penalty situation) status for each side, as reported by the source (available since 2026-11-09).",
      "properties": {
        "home": {
          "type": "boolean",
          "description": "True when the home side is in the bonus, so the away side’s next team foul awards it free throws."
        },
        "away": {
          "type": "boolean",
          "description": "True when the away side is in the bonus."
        }
      },
      "required": [
        "home",
        "away"
      ]
    },
    "Clock": {
      "type": "object",
      "description": "Timing data for a match. Running clocks (football, rugby, …): compute elapsed = periodOffsetSeconds + (now − periodStartedAt) and minute = floor(elapsed / 60) + 1; once periodEndSeconds is passed, display periodEndSeconds / 60 followed by \"+\" and the extra minutes. This applies only while status.phase is inprogress. Stop clocks (basketball, handball, ice hockey, …): playedSeconds is the value at playedAt and advances only while `running` is true. Tennis, table tennis, badminton and esports (set / map sports) carry only `periodStartedAt` (start of the current set or map), and only if the source sends it — the clock as a whole is frequently null. A field is null whenever the source does not provide it for that sport; the entire clock is null when no clock exists and after the match ends. Lists other than /fixtures/{id} may include fewer clock fields (static values such as periodLengthSeconds can be null there).",
      "properties": {
        "periodStartedAt": {
          "anyOf": [
            {
              "type": "string",
              "format": "date-time"
            },
            {
              "type": "null"
            }
          ],
          "description": "Moment the clock for the current period was started."
        },
        "periodOffsetSeconds": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Running clock: seconds already on the clock at the start of the period (2700 for the second half in football). Unit: seconds."
        },
        "periodEndSeconds": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Running clock: clock reading, in seconds, at which regulation time for the period runs out (2700 for the first half in football). Unit: seconds."
        },
        "maxExtraSeconds": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Running clock: upper bound on the added time the source’s display permits after periodEndSeconds. Unit: seconds."
        },
        "injuryTimeMinutes": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Stoppage time announced for the current period. Unit: minutes."
        },
        "playedSeconds": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Stop clock: time played in seconds, valid at `playedAt`. Unit: seconds."
        },
        "playedAt": {
          "anyOf": [
            {
              "type": "string",
              "format": "date-time"
            },
            {
              "type": "null"
            }
          ],
          "description": "Timestamp at which `playedSeconds` was captured."
        },
        "running": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ],
          "description": "Stop clock: true while the game clock is ticking."
        },
        "runningUpdatedAt": {
          "anyOf": [
            {
              "type": "string",
              "format": "date-time"
            },
            {
              "type": "null"
            }
          ],
          "description": "Time of the most recent change to `running`."
        },
        "periodLengthSeconds": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Stop clock: duration of a single regulation period. Unit: seconds."
        },
        "overtimeLengthSeconds": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Duration of a single overtime period. Unit: seconds."
        },
        "periodCount": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "How many regulation periods the match has (in combat sports, the scheduled rounds)."
        },
        "lastPeriodEndedAt": {
          "anyOf": [
            {
              "type": "string",
              "format": "date-time"
            },
            {
              "type": "null"
            }
          ],
          "description": "End time of the latest completed period. During a break (half-time, between periods) this marks when the break started, so the break has lasted now − lastPeriodEndedAt. Used with football-style running clocks; null if the source sends nothing (before the first break, in other sports, or for data stored before 2026-11-04). Available since 2026-11-04."
        }
      },
      "required": [
        "periodStartedAt",
        "periodOffsetSeconds",
        "periodEndSeconds",
        "maxExtraSeconds",
        "injuryTimeMinutes",
        "playedSeconds",
        "playedAt",
        "running",
        "runningUpdatedAt",
        "periodLengthSeconds",
        "overtimeLengthSeconds",
        "periodCount",
        "lastPeriodEndedAt"
      ]
    },
    "Country": {
      "type": "object",
      "description": "A country record.",
      "properties": {
        "code": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "Two-letter code supplied by the source. ISO 3166-1 alpha-2, apart from XK for Kosovo and four codes for the UK home nations (England EN, Scotland SX, Wales WA, Northern Ireland NX). Null if unknown."
        },
        "name": {
          "type": "string",
          "description": "Country name in English."
        },
        "flag": {
          "anyOf": [
            {
              "type": "string",
              "format": "uri"
            },
            {
              "type": "null"
            }
          ],
          "description": "Flag image (PNG) hosted on our CDN. Null when there is no code or the image has not been uploaded yet. Available since 2026-11-04."
        }
      },
      "required": [
        "code",
        "name",
        "flag"
      ]
    },
    "CricketInnings": {
      "type": "object",
      "description": "A single cricket innings played by one side.",
      "properties": {
        "runs": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "Total runs made."
        },
        "wickets": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "Number of wickets that have fallen."
        },
        "overs": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Overs delivered, in cricket notation (49.5 means 49 overs plus 5 balls)."
        },
        "runRate": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Average runs scored per over."
        },
        "targetRunRate": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "description": "Run rate the chasing side needs to reach its target."
        }
      },
      "required": [
        "runs",
        "wickets",
        "overs",
        "runRate",
        "targetRunRate"
      ]
    },
    "CricketToss": {
      "type": "object",
      "description": "Cricket: outcome of the coin toss.",
      "properties": {
        "winner": {
          "anyOf": [
            {
              "$ref": "#/$defs/Side"
            },
            {
              "type": "null"
            }
          ],
          "description": "Toss winner; null if the team the source names matches neither participant."
        },
        "decision": {
          "anyOf": [
            {
              "$ref": "#/$defs/TossDecision"
            },
            {
              "type": "null"
            }
          ],
          "description": "The choice the toss winner made."
        }
      },
      "required": [
        "winner",
        "decision"
      ]
    },
    "DownAndDistance": {
      "type": "object",
      "description": "American football: current down, distance and field position as tracked by the source (available since 2026-11-09). The live feed pushes an update after every play; fields not included in an update keep their previous value.",
      "properties": {
        "down": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "The down in play (1–4); null on a kickoff and on the try that follows a touchdown."
        },
        "yardsToGo": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "Yards needed for a first down (or to the goal line when goalToGo); null when there is no down."
        },
        "possession": {
          "anyOf": [
            {
              "$ref": "#/$defs/Side"
            },
            {
              "type": "null"
            }
          ],
          "description": "Side in possession of the ball."
        },
        "ballOn": {
          "anyOf": [
            {
              "$ref": "#/$defs/Side"
            },
            {
              "type": "null"
            }
          ],
          "description": "Half of the field the ball is in; combined with yardLine, \"home 35\" means the home side’s 35-yard line."
        },
        "yardLine": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "Yard line within that half (50 is midfield)."
        },
        "goalToGo": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ],
          "description": "True if the goal line is the line to gain (the source calls it isGoalPossession)."
        },
        "playType": {
          "anyOf": [
            {
              "$ref": "#/$defs/DownPlayType"
            },
            {
              "type": "null"
            }
          ],
          "description": "Kind of play the ball is set up for: scrimmage play, kickoff or try."
        }
      },
      "required": [
        "down",
        "yardsToGo",
        "possession",
        "ballOn",
        "yardLine",
        "goalToGo",
        "playType"
      ]
    },
    "DownPlayType": {
      "type": "string",
      "enum": [
        "scrimmage",
        "kickoff",
        "conversion",
        "other"
      ],
      "description": "American football: what type of play the ball is spotted for.",
      "x-enumDescriptions": {
        "scrimmage": "A scrimmage play, for which downs count.",
        "kickoff": "A kickoff, which uses no down.",
        "conversion": "The try after a touchdown — a kick for the extra point or a two-point attempt — with no down in play.",
        "other": "Any play type missing from this list."
      }
    },
    "Durations": {
      "type": "object",
      "description": "Period lengths for sports played in sets or rounds (tennis, table tennis, badminton, volleyball, MMA, …), as timed by our data source.",
      "properties": {
        "periods": {
          "type": "object",
          "propertyNames": {
            "$ref": "#/$defs/PeriodKey"
          },
          "additionalProperties": {
            "type": "number"
          },
          "description": "Duration in seconds of every COMPLETED period, using the same keys as ScoreSide.periods (in tennis period1 is the first set; in MMA / boxing the keys are the rounds). The period under way is excluded; its start is clock.periodStartedAt."
        },
        "totalSeconds": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "Adds up `periods`: once the match has ended this is its playing time, not counting breaks between periods. Null when `periods` is empty. Unit: seconds."
        }
      },
      "required": [
        "periods",
        "totalSeconds"
      ]
    },
    "FightCard": {
      "type": "object",
      "description": "MMA / boxing: a bout’s placement on the event card.",
      "properties": {
        "section": {
          "anyOf": [
            {
              "$ref": "#/$defs/FightCardSection"
            },
            {
              "type": "null"
            }
          ],
          "description": "The part of the card (main card, prelims, …), if the source specifies it."
        },
        "order": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "description": "Position of the bout in the source’s numbering of the card; larger numbers come later, and the main event carries the largest."
        },
        "weightClass": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "Weight class of the bout, using the source’s naming (\"light\", \"bantam\", \"feather\", …)."
        }
      },
      "required": [
        "section",
        "order

# --- truncated at 32 KB (70 KB total) ---
# Full source: https://artifacts.apis.io/datasportsapi/json-schema/datasportsapi-player-fixture-schema.json