/** * Open Meet Exchange types, version 1.0. Generated from meet-document-v1.schema.json by * `npm run sync:omx`; the schema is the authority. Readers ignore keys they do not know, so a * received document may carry more than these types name. * * Dedicated to the public domain under CC0 1.0. */ /** Opaque identifier chosen by the product that wrote the document. Stable for the life of the meet. A reader never parses it. */ export type Id = string; /** 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. */ export type ExternalIds = Record; /** 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. */ export type LaterValue = string; /** 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. */ export type DateTime = string; /** ISO 8601 calendar date, e.g. 2026-10-03. */ export type CalendarDate = string; /** 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`. */ export type AthleteGender = 'M' | 'F' | 'X'; /** 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. */ export type EventGender = 'M' | 'F' | 'X' | 'C'; /** 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. */ export type Sport = 'xc' | 'tf-indoor' | 'tf-outdoor' | 'run' | LaterValue; /** `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. */ export type MarkUnit = 'ms' | 'mm' | 'in' | 'pt' | LaterValue; /** 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. */ export interface Mark { value: number; unit: MarkUnit; display?: 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. */ source?: string; achieved_on?: CalendarDate; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** One intermediate time: where it was taken (a marker, a relay leg, or both) and the elapsed time there. */ export interface Split { /** Where the split was taken, by its `id` in the event's `markers`. */ marker_id?: Id; /** For a relay, the leg this split ends: `1` is the first leg. */ leg?: number; /** 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. */ time_ms: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** 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. */ export interface Header { /** 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. */ version: string; /** 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). */ kind: 'registration' | 'results'; /** 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`. */ update?: 'full' | 'partial' | LaterValue; /** 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. */ updated_at?: string; /** The product that wrote this copy: Registration's product in a registration document, Meet Operations' product in a results document. */ generator: { /** 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. */ id: string; /** The product's name as people know it, e.g. ExampleRegistration or 2Timer. */ name: string; /** The product's own version, e.g. 3.4. */ version?: string; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } export interface Meet { id: Id; external_ids?: ExternalIds; name: string; sport: Sport; start_date: CalendarDate; end_date?: CalendarDate; /** 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. */ time_zone?: string; venue?: { name?: string; address?: string; city?: string; /** State, province, or county. */ region?: string; postal_code?: string; /** ISO 3166-1 alpha-2, e.g. US. */ country?: string; latitude?: number; longitude?: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; /** Results documents only: the track the meet was run on, written by Meet Operations. Track and field only. */ track?: { /** Lap length in metres. A 160-yard track is `146.304`. */ length_m?: number; lane_count?: number; straight_lane_count?: number; /** Open. A reader treats a value it does not know as absent. */ shape?: 'oval_flat' | 'oval_banked' | LaterValue; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; /** For the timer only. Meet Operations leaves it out of every results document, and a Publisher never publishes it. */ notes?: string; /** 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?: { /** That product's system id: its `omx.generator.id`. */ id: string; /** That product's name: its `omx.generator.name`, e.g. ExampleRegistration. */ name: string; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } export interface Division { id: Id; name: string; short_name?: string; sequence: number; /** What this division calls each gender's contest, keyed by event gender, e.g. {"M": "Boys", "F": "Girls", "C": "Mixed"}. */ gender_names?: Partial>; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } export interface Span { min?: number; max?: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** Grades as Registration labels them ("9", "12", "K"). */ export interface GradeSpan { min?: string; max?: string; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** 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`. */ export interface Group { id: Id; name: string; /** The race this group awards within. Absent means every event. */ event_id?: Id; /** Who the group is for. `C` groups everyone in the age or grade span; `X` is a non-binary group. */ gender: EventGender; age?: Span; grade?: GradeSpan; award_count?: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } export interface Event { id: Id; external_ids?: ExternalIds; /** Event number if one is assigned. Otherwise Meet Operations numbers in array order. */ number?: number; name: string; code: EventCode; division_id?: Id; gender: EventGender; /** Registration may suggest it; a results document carries the height used. */ hurdle_height_mm?: number; /** Registration may suggest it; a results document carries the weight used. */ implement_weight_g?: number; /** 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. */ multi_event_id?: Id; /** For the timer only. Meet Operations leaves it out of every results document, and a Publisher never publishes it. */ notes?: string; /** 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?: { /** `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. */ mode: 'wheelchair' | 'seated' | 'guided' | 'ambulatory' | LaterValue; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; /** 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?: Array<{ id: Id; /** How the point is named on results: `1 Mile`, `2K`, `Swim`, `T1`. */ name: string; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }>; /** Results documents only: the rounds of this event, written by Meet Operations. Entries point at a round by number. */ rounds?: Round[]; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } export interface Team { id: Id; external_ids?: ExternalIds; /** 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`. */ code: string; name: string; city?: string; region?: string; country?: string; /** A team listed by name, such as Unattached, whose athletes compete for no team: they carry no points and take no scoring position. */ unattached?: boolean; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } export interface Athlete { /** Stable within the meet. */ id: Id; external_ids?: ExternalIds; /** Given name. Absent for an athlete with one name. */ first_name?: string; middle_name?: string; /** Family name, or the athlete's only name when they have one. */ last_name: string; gender?: AthleteGender; /** Registration documents only: the athlete's birth date, sent instead of `age`, never with it. It never leaves Meet Operations. */ birth_date?: CalendarDate; /** 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. */ age?: number; grade?: string; /** The athlete's team. An athlete with no team_id competes for no team: it carries no points and takes no scoring position. */ team_id?: Id; /** 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. */ bib?: string; /** Registration documents only: the transponder id, when Registration assigned one. */ chip?: string; city?: string; region?: string; /** ISO 3166-1 alpha-2 country code, upper case (`US`, `CA`). */ country?: string; /** Registration documents only, for the timer's use on meet day. Never in a results document, and a Publisher never publishes it. */ 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; /** 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. */ exhibition?: boolean; /** For the timer only. Meet Operations leaves it out of every results document, and a Publisher never publishes it. */ notes?: string; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** 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. */ export type EntryStatus = 'e' | 'scr' | 'wait' | 's' | 'dnf' | 'dns' | 'dq' | 'fs' | 'nr'; /** 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). */ export interface Entry { id: Id; event_id: Id; /** Individual entries. Exactly one of `athlete_id` or `relay`. In a registration document, athlete + event is unique among individual entries. */ athlete_id?: Id; /** Relay entries. Team + letter + event is unique among the relay entries of a registration document. */ relay?: { team_id: Id; /** The team's squad in this event: one upper-case letter, A for its first. */ letter: string; /** Athlete ids in running order. May be shorter than the event's legs, may be empty, may name alternates after the running legs. */ legs?: Id[]; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; seed?: Mark; status?: EntryStatus; /** Registration documents only: the award group Registration placed this entry in, when it does not follow from age and gender alone. */ group_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. */ wave_id?: Id; /** 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. */ round?: number; /** Heat or flight number. */ heat?: number; /** Lane or position. Omitted where the event does not use lanes. */ lane?: number; /** 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. */ 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. */ net_result?: Mark; /** 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. */ overall_place?: number; /** Place within the heat. */ heat_place?: number; /** Place among athletes of the same gender, by the same clock as `overall_place`. */ gender_place?: number; /** Places within the award groups the entry placed in. */ group_places?: Array<{ /** The award group, by its `id` in `groups`. */ group_id: Id; place: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }>; /** 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. */ qualified?: 'Q' | 'q' | 'qD' | 'qR' | 'qJ' | LaterValue; /** 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. */ flags?: string[]; /** 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`). */ wind_mps?: number; /** Reaction time from the start signal, in milliseconds, where the start was monitored. */ reaction_time_ms?: 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. */ 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`. */ multi_points?: number; /** Intermediate times, in the order they were taken. */ splits?: Split[]; /** 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?: Array<{ order: number; /** 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. */ mark?: Mark; /** `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. */ outcome: 'o' | 'x' | '-' | 'r' | LaterValue; /** Wind for this attempt in metres per second, where the event records one per attempt. */ wind_mps?: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }>; /** A note from the officials about this result, published with it: the rule a disqualification was under, a jump-off, a protest outcome. */ official_note?: string; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** 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. */ export interface PublishDestination { /** Identifier for this destination, unique within the document and stable for the life of the meet. */ id: Id; /** 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. */ label?: string; /** Where Meet Operations POSTs each results document. */ url: string; /** Sent as `Authorization: Bearer ` 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. */ token: string; /** 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`. */ deliver?: 'final' | 'progressive' | 'live' | 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. */ content?: Array<'results' | 'start_lists' | LaterValue>; /** 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. */ accepts?: string[]; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** Round-level state, written by Meet Operations. Entries point at a round by `round` number. */ export interface Round { round: number; /** How the round is named on paperwork, e.g. Prelims, Final. Shown, never used to decide which round is the final. */ label?: string; /** 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. */ final?: boolean; /** 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. */ status: 'upcoming' | 'started' | 'cancelled' | 'unofficial' | 'under_review' | 'official' | LaterValue; /** 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`. */ scheduled_at?: DateTime; /** 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. */ timing?: 'hand' | 'fat' | 'transponder' | LaterValue; /** 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 and gender places. */ overall?: 'gun' | 'net'; /** Places within award groups (`group_places`). */ groups?: 'gun' | 'net'; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; /** 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?: Array<{ heat: number; /** When the heat's start signal went, as recorded. */ started_at?: DateTime; /** Official wind for the heat in metres per second, where one is recorded. */ wind_mps?: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }>; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** Team standings, written by Meet Operations when the meet is scored. Values arrive computed; render them, never recompute them. */ export interface TeamScores { /** This block's id, the same from one document to the next. A `partial` document replaces the blocks it carries by `id`. */ id: Id; /** What this standing covers: one event, one division across its events, or the whole meet, and whose standings they are. */ scope: { /** Open: a reader that does not know the value skips the block rather than show standings it cannot label. */ type: 'event' | 'division' | 'meet' | LaterValue; /** The event or division id. Absent when `type` is `meet`. */ id?: Id; /** 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. */ gender: EventGender; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }; standings: Array<{ /** The team, by its `id` in `teams`. */ team_id: Id; /** Two standings in one block with the same place are tied. */ place?: number; points?: number; /** Whether the team fielded enough scorers to score. An incomplete team carries no `place`, no `points`, and no `entries`. */ complete?: boolean; /** 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. */ entries?: Array<{ entry_id: Id; /** `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. */ role: 'scorer' | 'displacer' | LaterValue; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }>; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }>; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** 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. */ export interface Wave { id: Id; name: string; /** 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. */ offset_ms?: number; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; } /** 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. */ export type EventCode = string | LaterValue; /** 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. */ export interface MeetDocument { omx: Header; meet: Meet; /** Competition groupings that events belong to (Varsity, Masters 40–44, U12). */ divisions?: Division[]; /** 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. */ groups?: Group[]; /** Start waves in road and trail races. */ waves?: Wave[]; /** What is contested, in running order. A results document adds `rounds`, and lists the component events of a multi-event. */ events: Event[]; teams: Team[]; athletes: Athlete[]; /** 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. */ entries: Entry[]; /** 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`. */ publish?: PublishDestination[]; /** Team standings. Only in a results document, written by Meet Operations. */ team_scores?: TeamScores[]; /** A field this version does not define, which a reader ignores (OMX-R129). */ [field: string]: unknown; }