Field reference

Every field in the schema, generated from the schema's own descriptions. Document is the root; every other section is a definition the root refers to. A field the format does not define is ignored by every reader and never fails a document, so it is not listed. The strict checks for each kind, registration and results, say which of these fields each kind carries.

Document

One JSON document that describes a meet, handed forward in one direction: Registration → Meet Operations → Publisher. omx.kind says which handoff it is: a registration document says who entered; a results document says what happened, one entry per athlete or relay per round. Readers ignore unknown fields. id is always the identifier of the product that wrote the document; external_ids carries the same record’s ids in other products, keyed by system id, on the meet, events, teams, and athletes.

Field	Type	Required	Meaning
`omx`	header	yes
`meet`	meet	yes
`divisions`	array of division		Competition groupings that events belong to (Varsity, Masters 40–44, U12).
`groups`	array of group		Award groups within a race: age groups in a road race, JV within a varsity cross country race. Each names an event (or all events), a gender, and an age or grade span.
`waves`	array of wave		Start waves in road and trail races.
`events`	array of event	yes	What is contested, in running order. A results document adds `rounds`, and lists the component events of a multi-event.
`teams`	array of team	yes
`athletes`	array of athlete	yes
`entries`	array of entry	yes	In a registration document, one entry per athlete or relay per event: who entered. In a results document, one entry per athlete or relay per round, with `round` required: what happened. A scratch in a registration document is an entry with `status: "scr"`, never a missing entry.
`publish`	array of publishDestination		Registration only: the destinations Meet Operations hands the results to, each with its own credential. Absent or empty means Registration does not want the meet back, which is a complete implementation. A results document carries no `publish`.
`team_scores`	array of teamScores		Team standings. Only in a results document, written by Meet Operations.

id

Opaque identifier chosen by the product that wrote the document. Stable for the life of the meet. A reader never parses it.

string

externalIds

This record’s ids in other products, keyed by system id (a writer’s own generator.id, such as examplereg; for a system that writes no OMX document, the key the spec lists, such as anet), one per system. Only the meet, events, teams, and athletes carry them; an entry never does. A writer never lists itself: its own id is id. In a results document, a record that came from Registration carries Registration’s id here under Registration’s system id (meet.origin.id), and Meet Operations writes back every id it received, unchanged, whether or not it knows the system. A record Meet Operations created carries no Registration id.

object of string keyed by name

laterValue

A value this version does not define: one a later minor version adds. A writer of this version sends only defined values. A reader that meets a value it does not know follows the rule in the field’s own description; the spec’s Versioning section tabulates them.

string

dateTime

RFC 3339 date-time with seconds and a UTC offset, e.g. 2026-10-03T09:00:00-04:00. A writer always includes seconds (the strict writer schemas require them); a reader also accepts a date-time without seconds.

string (matches ^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}:\d{2})$)

date

ISO 8601 calendar date, e.g. 2026-10-03.

string (matches ^\d{4}-\d{2}-\d{2}$)

athleteGender

An athlete’s gender: M male, F female, X non-binary. Closed. Absent when the athlete did not state one, which road registration commonly allows; a reader that does not tell the two apart may treat an absent gender as X.

one of M, F, X

eventGender

Who a contest is for, with the same letters as an athlete’s gender: M men or boys, F women or girls, X non-binary athletes, C everyone (mixed, combined, or co-ed), including a relay whose team may mix genders; each athlete in a C contest is also placed within their own gender. C is never an athlete’s gender. Closed. Registration decides who may enter; Meet Operations takes an entry as given.

one of M, F, X, C

sport

The sport. Indoor and outdoor track are separate because their event catalogs differ. Event codes are defined per sport. Open: a later minor adds sports. A Meet Operations product that does not run a sport refuses the document and names the sport; a Publisher shows the meet’s events by their names and codes.

one of xc, tf-indoor, tf-outdoor, run, or a laterValue

markUnit

ms milliseconds, mm millimetres, in inches, pt points: the unit the event’s code ranks by. Open: a reader that meets a unit it does not know shows the mark’s display and never compares or sorts on it.

one of ms, mm, in, pt, or a laterValue

mark

A seed or performance. value is a number in the unit the writer measured in, so nothing is converted before the reader sees it: ms for times, mm or in for distances and heights, pt for points, as the event’s code ranks. ms, mm, and pt are integers; in is decimal inches to at most two places (16-06.25 is 198.25). Compare on value; print display, the writer’s own formatting, which is never parsed.

Field	Type	Required	Meaning
`value`	number (≥ 0)	yes
`unit`	markUnit	yes
`display`	string
`source`	string		On a seed: where the mark came from, e.g. `season_best`, `coach_entered`, `previous_meet`. Free text; shown to the timer, never interpreted.
`achieved_on`	date

split

One intermediate time: where it was taken (a marker, a relay leg, or both) and the elapsed time there.

Field	Type	Required	Meaning
`marker_id`	id		Where the split was taken, by its `id` in the event’s `markers`.
`leg`	integer (≥ 1)		For a relay, the leg this split ends: `1` is the first leg.
`time_ms`	integer (≥ 0)	yes	Elapsed milliseconds from the same start as `result`: the gun for the athlete’s race or wave. A relay leg’s split is the running clock when that leg finished. A Publisher subtracts two splits to show one stretch.

header

About this copy of the document: the format version, its kind, which product wrote it, and, in a results document, what it covers and when the meet last changed.

Field	Type	Required	Meaning
`version`	string (matches `^(0\|1)\.\d+$`)	yes	Format version as MAJOR.MINOR. A reader accepts any minor within a major it implements and ignores fields it does not know; a major it does not implement is refused with a message naming both versions. A draft document carries its draft number (`0.1` to `0.9`), which a 1.x reader refuses; a reader checks the version before validating.
`kind`	one of `registration`, `results`	yes	Which handoff this is. `registration`: written by Registration, who entered. `results`: written by Meet Operations, what happened. Closed: a reader refuses a document whose kind it does not know, or that is not the kind it reads (Meet Operations reads registration documents; a Publisher reads results documents).
`update`	one of `full`, `partial`, or a laterValue		Results documents only: what the document covers. `full`: the whole meet as it stands; the Publisher replaces everything it holds for the meet. `partial`: only the rounds it carries, each whole; the Publisher replaces those rounds and the team scores the document carries, adds or updates the meet, divisions, groups, waves, events, teams, and athletes it carries by `id`, and changes nothing else. A Publisher refuses an `update` it does not know with 422 and never reads it as `full`.
`updated_at`	string		Results documents only, required there: when the meet’s data last changed, not when this copy was sent. Orders documents: a Publisher applies a newer one, treats an equal one as a no-op, and refuses an older one with 409, whatever its `update`, comparing instants rather than text. Written to at least the millisecond, with a UTC offset; a reader accepts one with less. Any change moves it forward, including a deletion; it never goes backwards.
`generator`	object	yes	The product that wrote this copy: Registration’s product in a registration document, Meet Operations’ product in a results document.
`generator.id`	string (matches `^[a-z0-9_]{1,32}$`)	yes	The writer’s system id: lowercase letters, digits, and `_`, at most 32, any name the writer picks, chosen once and never changed, such as `2t` for 2Timer; nobody assigns it. Other documents carry this product’s ids in `external_ids` under it.
`generator.name`	string	yes	The product’s name as people know it, e.g. ExampleRegistration or 2Timer.
`generator.version`	string		The product’s own version, e.g. 3.4.

meet

Field	Type	Required	Meaning
`id`	id	yes
`external_ids`	externalIds
`name`	string	yes
`sport`	sport	yes
`start_date`	date	yes
`end_date`	date
`time_zone`	string		IANA time zone, e.g. America/New_York: the zone the meet’s dates and schedule are in. Optional. Without it, dates are the meet’s own local calendar dates as written, and each date-time is read by its own UTC offset.
`venue`	object
`venue.name`	string
`venue.address`	string
`venue.city`	string
`venue.region`	string		State, province, or county.
`venue.postal_code`	string
`venue.country`	string		ISO 3166-1 alpha-2, e.g. US.
`venue.latitude`	number (≥ -90, ≤ 90)
`venue.longitude`	number (≥ -180, ≤ 180)
`track`	object		Results documents only: the track the meet was run on, written by Meet Operations. Track and field only.
`track.length_m`	number (> 0)		Lap length in metres. A 160-yard track is `146.304`.
`track.lane_count`	integer (≥ 1)
`track.straight_lane_count`	integer (≥ 1)
`track.shape`	one of `oval_flat`, `oval_banked`, or a laterValue		Open. A reader treats a value it does not know as absent.
`notes`	string		For the timer only. Meet Operations leaves it out of every results document, and a Publisher never publishes it.
`origin`	object		Results documents only: the product this meet started in. A meet’s entries come from one Registration product. Registration’s system id and name when the meet was built from a registration document, so records from Registration carry their ids in `external_ids` under `origin.id`; Meet Operations’ own when the timer built the meet, so no record carries a Registration id.
`origin.id`	string (matches `^[a-z0-9_]{1,32}$`)	yes	That product’s system id: its `omx.generator.id`.
`origin.name`	string	yes	That product’s name: its `omx.generator.name`, e.g. ExampleRegistration.

division

Field	Type	Required	Meaning
`id`	id	yes
`name`	string	yes
`short_name`	string
`sequence`	integer (≥ 1)	yes
`gender_names`	object of string keyed by name		What this division calls each gender’s contest, keyed by event gender, e.g. {“M”: “Boys”, “F”: “Girls”, “C”: “Mixed”}.

span

Field	Type	Required	Meaning
`min`	integer (≥ 0)
`max`	integer (≥ 0)

gradeSpan

Grades as Registration labels them (“9”, “12”, “K”).

Field	Type	Required	Meaning
`min`	string
`max`	string

group

An award group within a race: an age group in a road race, JV within a varsity cross country race. Age and grade spans are inclusive at both ends; an age span is matched against the athlete’s age.

Field	Type	Required	Meaning
`id`	id	yes
`name`	string	yes
`event_id`	id		The race this group awards within. Absent means every event.
`gender`	eventGender	yes	Who the group is for. `C` groups everyone in the age or grade span; `X` is a non-binary group.
`age`	span
`grade`	gradeSpan
`award_count`	integer (≥ 0)

event

Field	Type	Required	Meaning
`id`	id	yes
`external_ids`	externalIds
`number`	integer (≥ 1)		Event number if one is assigned. Otherwise Meet Operations numbers in array order.
`name`	string	yes
`code`	eventCode	yes
`division_id`	id
`gender`	eventGender	yes
`hurdle_height_mm`	integer (≥ 0)		Registration may suggest it; a results document carries the height used.
`implement_weight_g`	integer (≥ 0)		Registration may suggest it; a results document carries the weight used.
`multi_event_id`	id		Results documents only: for a component of a multi-event (the 100 m of a decathlon), the id of the multi-event it belongs to. Meet Operations builds the component events; Registration sends the multi-event alone.
`notes`	string		For the timer only. Meet Operations leaves it out of every results document, and a Publisher never publishes it.
`adaptive`	object		Marks an adaptive or para event: an event of the same code contested in an adaptive form. An adaptive event is a different event from the standard one with the same code; a reader that cannot hold adaptive events tells the operator and never merges one into the standard event.
`adaptive.mode`	one of `wheelchair`, `seated`, `guided`, `ambulatory`, or a laterValue	yes	`wheelchair` a wheelchair race, `seated` a seated throw, `guided` run with a guide, `ambulatory` an adaptive event contested standing or running without a chair or guide. Open: a reader that does not know the value shows the event as adaptive with no mode.
`markers`	array of objects		Results documents only: the timing points on the course or track where splits are taken, in course order. An entry’s `splits` name them by `id`. A relay’s leg splits need no marker.
`markers[].id`	id	yes
`markers[].name`	string	yes	How the point is named on results: `1 Mile`, `2K`, `Swim`, `T1`.
`rounds`	array of round		Results documents only: the rounds of this event, written by Meet Operations. Entries point at a round by number.

team

Field	Type	Required	Meaning
`id`	id	yes
`external_ids`	externalIds
`code`	string	yes	Short display code, unique within the document (`LHS`, `NIKE`), at most 16 characters in a written document. A writer that holds a longer code writes a shortened one of its own, still unique; it never holds back the meet for it. An athlete with no team leaves out `team_id`; a team listed by name for unattached athletes sets `unattached`.
`name`	string	yes
`city`	string
`region`	string
`country`	string
`unattached`	boolean		A team listed by name, such as Unattached, whose athletes compete for no team: they carry no points and take no scoring position. Default `false`.

athlete

Field	Type	Required	Meaning
`id`	id	yes	Stable within the meet.
`external_ids`	externalIds
`first_name`	string		Given name. Absent for an athlete with one name.
`middle_name`	string
`last_name`	string	yes	Family name, or the athlete’s only name when they have one.
`gender`	athleteGender
`birth_date`	date		Registration documents only: the athlete’s birth date, sent instead of `age`, never with it. It never leaves Meet Operations.
`age`	integer (≥ 0)		In a registration document, the age Registration computed for this meet; an athlete carries `age` or `birth_date`, never both. In a results document, the age Meet Operations placed the athlete by, whether Registration sent an age or a birth date.
`grade`	string
`team_id`	id		The athlete’s team. An athlete with no team_id competes for no team: it carries no points and takes no scoring position.
`bib`	string		The athlete’s bib for the meet. Registration may assign it, or leave it to the timer. In a results document it is the bib the athlete raced under. A runner with two bibs in one meet is two athletes.
`chip`	string		Registration documents only: the transponder id, when Registration assigned one.
`city`	string
`region`	string
`country`	string		ISO 3166-1 alpha-2 country code, upper case (`US`, `CA`).
`email`	string		Registration documents only, for the timer’s use on meet day. Never in a results document, and a Publisher never publishes it.
`phone`	string		Registration documents only, for the timer’s use on meet day. Never in a results document, and a Publisher never publishes it.
`exhibition`	boolean		Exhibition, non-scoring athlete. Places and wins awards normally; never scores, never displaces, never takes a scoring slot, in any event the athlete enters. Separate from the team’s `unattached` flag. Default `false`.
`notes`	string		For the timer only. Meet Operations leaves it out of every results document, and a Publisher never publishes it.

entryStatus

Where this entry stands. Closed. A registration entry may carry one: e entered (confirmed or not), scr scratched, or wait wait list; a registration entry with none is e. A results entry carries exactly one of status and overall_place: a place means it placed, and otherwise its status is e on a heat sheet, s in the round with nothing to place yet, or where it ended without a place: dnf did not finish (a race, or a multi-event the athlete abandoned), dns did not start, dq disqualified, fs false start (timed track only), nr no result. Which a results entry may be depends on its round’s status. NT, NM, and NH are NOT statuses: they are how nr prints (NT for a race, NM for a throw or horizontal jump, NH for a vertical jump), never NR, except in an event whose code the reader does not know. Only a placed entry and a dq carry a result; a dq keeps its recorded result and holds no place.

one of e, scr, wait, s, dnf, dns, dq, fs, nr

entry

In a registration document: one athlete or relay entered in one event, with its seed and status, and no result fields. In a results document: one athlete or relay in one round of one event, with round required. A prelim and a final are two entries, each with its own id. No entry carries external_ids: a Publisher joins an entry to Registration through its athlete and event (a relay’s team, letter, and event).

Exactly one of athlete_id, relay is required.

Field	Type	Required	Meaning
`id`	id	yes
`event_id`	id	yes
`athlete_id`	id		Individual entries. Exactly one of `athlete_id` or `relay`. In a registration document, athlete + event is unique among individual entries.
`relay`	object		Relay entries. Team + letter + event is unique among the relay entries of a registration document.
`relay.team_id`	id	yes
`relay.letter`	string (matches `^[A-Z]$`)	yes	The team’s squad in this event: one upper-case letter, A for its first.
`relay.legs`	array of id		Athlete ids in running order. May be shorter than the event’s legs, may be empty, may name alternates after the running legs.
`seed`	mark
`status`	entryStatus
`group_id`	id		Registration documents only: the award group Registration placed this entry in, when it does not follow from age and gender alone.
`wave_id`	id		The start wave this entry runs in, by its `id` in `waves`. A wave runner’s `result` is timed from the wave’s own gun.
`round`	integer (≥ 1)		Results documents only, required there: the round of the event this entry is in. Round-level state lives in `events[].rounds`. An athlete who competed in two rounds appears as two entries.
`heat`	integer (≥ 1)		Heat or flight number.
`lane`	integer (≥ 1)		Lane or position. Omitted where the event does not use lanes.
`result`	mark		The recorded time or mark. For a timed event, the gun time: from the start signal for the athlete’s race or wave, however the finish was captured. `value` is the stored value: times store to thousandths even where an event shows hundredths, and two results tie only when equal at stored value. Absent on a finisher with no recorded value.
`net_result`	mark		Net time: from the moment the athlete crossed the start line to the finish, where a start mat recorded it. Never a substitute for `result`, which stays the gun time. The round’s `place_by` says which of the two decided places.
`overall_place`	integer (≥ 1)		Place across the whole round; on the round marked `final`, that is the event’s place. A results entry carries exactly one of `overall_place` and `status`: a placed entry has no status. In a `started` round it is the place so far, which may still move. Two entries in one round with the same place are tied.
`heat_place`	integer (≥ 1)		Place within the heat.
`gender_place`	integer (≥ 1)		Place among athletes of the same gender, by the same clock as `overall_place`.
`group_places`	array of objects		Places within the award groups the entry placed in.
`group_places[].group_id`	id	yes	The award group, by its `id` in `groups`.
`group_places[].place`	integer (≥ 1)	yes
`qualified`	one of `Q`, `q`, `qD`, `qR`, `qJ`, or a laterValue		The letter the results print after this entry’s result in a round before the event’s last, as it advanced: `Q` by place, `q` by time or mark, `qD` won a draw for the last spot, `qR` advanced by the referee, `qJ` advanced by the Jury of Appeal (World Athletics CR 25.4). A field qualifier is `q`. Absent on a final and on any result that prints no letter. Open: a reader shows a value it does not know as written.
`flags`	array of string		The timer’s own flags on this result, in the order typed, as typed: a record (`MR`), a best (`PB`, `SB`), a standard met, a state qualifier at a regional (`Q`). Printed after the result and its `qualified`. Never a qualifier letter in a round before the event’s last. Absent when there are none, which does not mean the result is not a record.
`wind_mps`	number		For a field result only: the wind in metres per second for the mark that counted. A race’s wind is on its heat (`rounds[].heats[].wind_mps`).
`reaction_time_ms`	integer (≥ 0)		Reaction time from the start signal, in milliseconds, where the start was monitored.
`points`	number		Team-scoring value, whether or not it counted: the track points earned, or the cross country scoring position. One value per entry: every team score block that lists the entry uses it. The team standing’s `role` says whether it counted. Absent for a runner on an incomplete or unattached team.
`multi_points`	number		On a component entry of a multi-event: the points that component earned. A multi-event entry’s total is its `result`, in `pt`.
`splits`	array of split		Intermediate times, in the order they were taken.
`field_series`	array of objects		A field-event series in order. For a horizontal jump or throw, each attempt is one jump or throw. For a vertical jump, each attempt is one try at a bar height.
`field_series[].order`	integer (≥ 1)	yes
`field_series[].mark`	mark		For a horizontal jump or throw, the measured mark, present when `outcome` is `o`. For a vertical jump, the bar height attempted, present on every attempt so a miss says what was missed.
`field_series[].outcome`	one of `o`, `x`, `-`, `r`, or a laterValue	yes	`o` a valid attempt (a measured mark, or a height cleared), `x` a foul or miss, `-` a pass, `r` retired from the competition. Open: a reader treats a value it does not know as an attempt with no valid mark.
`field_series[].wind_mps`	number		Wind for this attempt in metres per second, where the event records one per attempt.
`official_note`	string		A note from the officials about this result, published with it: the rule a disqualification was under, a jump-off, a protest outcome.

publishDestination

One Publisher Meet Operations hands the results to. The credential here is separate from the document URL’s; holding the read link never grants the right to write.

Field	Type	Required	Meaning
`id`	id	yes	Identifier for this destination, unique within the document and stable for the life of the meet.
`label`	string		Human name for this destination, shown to the timer when they are asked to approve it. Strongly recommended: without one the timer is asked to trust a bare URL.
`url`	string (matches `^https://`)	yes	Where Meet Operations POSTs each results document.
`token`	string	yes	Sent as `Authorization: Bearer <token>` on every handoff. Never placed in a query string. Issued by whoever runs this destination, with at least 128 bits from a cryptographically secure generator (22 or more base62 characters; 32 recommended). A readable prefix is allowed and does not count toward the 128 bits. The Publisher decides how long it works and answers 410 once it stops.
`deliver`	one of `final`, `progressive`, `live`, or a laterValue		How often this destination wants results. `final` (the default): `full` documents once every round is official or cancelled, and again for each correction. `progressive`: a first `full` document, then `partial` ones as each round is seeded, goes official, or changes. `live`: everything `progressive` gets, plus a `partial` document every few seconds while a round runs. Meet Operations may always send `full` instead of `partial`. Open: a value Meet Operations does not know is read as `final`. Default `"final"`.
`content`	array of one of `results`, `start_lists`, or a laterValue		What this destination wants. `results` (the default): entries once a round is under way. `start_lists`: also heat-sheet entries for rounds that have not run yet. Open: Meet Operations ignores a value it does not know.
`accepts`	array of string (matches `^\d+\.\d+$`)		The Open Meet Exchange versions this destination reads, newest first, such as [“1.0”]. Listing a version accepts every later minor of its major: [“1.0”] reads every 1.x. Optional: without it, Meet Operations writes a version of the major of the document or card that named this destination. Meet Operations sends only a major listed here.

round

Round-level state, written by Meet Operations. Entries point at a round by round number.

Field	Type	Required	Meaning
`round`	integer (≥ 1)	yes
`label`	string		How the round is named on paperwork, e.g. Prelims, Final. Shown, never used to decide which round is the final.
`final`	boolean		True on the round whose places are the event’s result, including the only round of a single-round event. Omitted on every other round, and on every round while the final is not yet known. On a round that is not the final, `overall_place` is the place across that round only.
`status`	one of `upcoming`, `started`, `cancelled`, `unofficial`, `under_review`, `official`, or a laterValue	yes	Where the round stands. `upcoming` not run yet; `started` under way, some results may be in; `cancelled` will not run; `unofficial` every heat has run and results may still change; `under_review` a protest or review is open; `official` final, unless a correction follows. Open, and fails safe: a reader treats a value it does not know as not official.
`scheduled_at`	dateTime		When the round is planned to start. The meet’s only schedule: a registration document carries none. A plan, never a start: when a heat went is its `started_at`.
`timing`	one of `hand`, `fat`, `transponder`, or a laterValue		How times in this round were taken: `hand` (stopwatch or hand-operated timer), `fat` (fully automatic, photo-finish), `transponder` (chip). Omitted when Meet Operations does not record it. Open; a reader treats a value it does not know as absent.
`place_by`	object		Which time decided places in a round that has net times: `gun` (`result`) or `net` (`net_result`). Absent when the round has gun times only, which then decide every place.
`place_by.overall`	one of `gun`, `net`		Overall and gender places.
`place_by.groups`	one of `gun`, `net`		Places within award groups (`group_places`).
`heats`	array of objects		Heat or flight records for this round, where Meet Operations holds something about a heat itself. Entries still name their heat by number. A round run as one race, such as a cross country or road race, lists at most heat 1, to carry its started_at; an entry with no heat belongs to it.
`heats[].heat`	integer (≥ 1)	yes
`heats[].started_at`	dateTime		When the heat’s start signal went, as recorded.
`heats[].wind_mps`	number		Official wind for the heat in metres per second, where one is recorded.

teamScores

Team standings, written by Meet Operations when the meet is scored. Values arrive computed; render them, never recompute them.

Field	Type	Required	Meaning
`id`	id	yes	This block’s id, the same from one document to the next. A `partial` document replaces the blocks it carries by `id`.
`scope`	object	yes	What this standing covers: one event, one division across its events, or the whole meet, and whose standings they are.
`scope.type`	one of `event`, `division`, `meet`, or a laterValue	yes	Open: a reader that does not know the value skips the block rather than show standings it cannot label.
`scope.id`	id		The event or division id. Absent when `type` is `meet`.
`scope.gender`	eventGender	yes	Whose standings these are, always present: `M`, `F`, or `X` when teams are scored separately by gender (a co-ed school’s boys’ and girls’ scores are two blocks), `C` when the standings count every gender together.
`standings`	array of objects	yes
`standings[].team_id`	id	yes	The team, by its `id` in `teams`.
`standings[].place`	integer (≥ 1)		Two standings in one block with the same place are tied.
`standings[].points`	number
`standings[].complete`	boolean		Whether the team fielded enough scorers to score. An incomplete team carries no `place`, no `points`, and no `entries`.
`standings[].entries`	array of objects		The entries that scored or displaced for this standing, so a results page can print a team’s line without recomputing it. Each entry’s own `points` is its value. Optional; Meet Operations writes it where it holds it.
`standings[].entries[].entry_id`	id	yes
`standings[].entries[].role`	one of `scorer`, `displacer`, or a laterValue	yes	`scorer` counted in the team total; `displacer` did not count but pushed other teams’ runners back. Open; a reader treats a value it does not know as absent.

wave

A start wave in a road or trail race. An entry names its wave with wave_id. Registration may assign waves; a results document carries the waves run.

Field	Type	Required	Meaning
`id`	id	yes
`name`	string	yes
`offset_ms`	integer (≥ 0)		How long after the start of the athlete’s event this wave started, in milliseconds. A `result` is already timed from the wave’s own start.

eventCode

What the event is, how far, and how it ranks: the only field that says any of them. Codes are defined per sport; the spec tabulates them. A race in metres (100, 5000) or miles (1MILE, 3.1MILE), HMAR, MAR; hurdles in metres with H (110H); a steeplechase with S (3000S); a race walk with W (5000W, 1MILEW); an even relay as legs × leg (4X100, 4X1MILE, 4X110H); a medley by its total (800R, 1000R, 1600R, 3200R, 4000R); a field event (LJ, TJ, SLJ, HJ, PV, SHJ, SP, DT, HT, JT, WT, TJT, SBT, BBT, CT); or a multi-event (DEC, HEP, PENT), for any gender, whose component events Meet Operations builds. A race’s code is its advertised distance, not what the course measured, and each distance has one code: a half marathon is always HMAR, a marathon always MAR. Running events and relays rank lowest time first, field events by best mark, multi-events by points. Open: a later minor version adds codes. A writer sends only a code this version defines for the meet’s sport, never one of its own; a reader that meets a code it does not know leaves that event and its entries out, tells the operator, and reads the rest of the meet.

string