volleyballsimtypes 0.0.356 → 0.0.358

package/dist/esm/src/data/transformers/match-set.js

@@ -0,0 +1,48 @@
+import { MatchSet } from '../../service';
+import { transformFromBoxScore, transformFromCourtPosition, transformFromRally, transformToBoxScore, transformToCourtPosition, transformToRally } from '.';
+function fromPosition(playerPosition, side) {
+    return {
+        side,
+        court_position: transformFromCourtPosition(playerPosition.position),
+        player_id: playerPosition.playerId
+    };
+}
+function toPosition(model) {
+    return {
+        playerId: model.player_id,
+        position: transformToCourtPosition(model.court_position)
+    };
+}
+function transformToAttributes(set, matchId) {
+    const homeSetPositions = set.homePlayerPosition.map(position => fromPosition(position, 'HOME'));
+    const awaySetPositions = set.awayPlayerPosition.map(position => fromPosition(position, 'AWAY'));
+    return {
+        match_set_id: set.id,
+        match_id: matchId,
+        order: set.order,
+        is_tie_break: set.isTieBreak,
+        home_score: set.homeScore,
+        away_score: set.awayScore,
+        player_positions: [...homeSetPositions, ...awaySetPositions],
+        BoxScores: (set.boxScores ?? []).map(transformFromBoxScore),
+        Rallies: (set.rallies ?? []).map((rally) => transformFromRally(rally, set.id))
+    };
+}
+function transformToObject(model) {
+    const playerPositions = model.player_positions ?? [];
+    const homePlayerPosition = playerPositions.filter((p) => p.side === 'HOME').map(toPosition);
+    const awayPlayerPosition = playerPositions.filter((p) => p.side === 'AWAY').map(toPosition);
+    const rallies = (model.Rallies ?? []).map(transformToRally).sort((r1, r2) => r1.order - r2.order);
+    return MatchSet.create({
+        id: model.match_set_id,
+        order: model.order,
+        homeScore: model.home_score,
+        awayScore: model.away_score,
+        isTieBreak: model.is_tie_break,
+        boxScores: (model.BoxScores ?? []).map(transformToBoxScore),
+        homePlayerPosition,
+        awayPlayerPosition,
+        rallies
+    });
+}
+export { transformToObject as transformToMatchSet, transformToAttributes as transformFromMatchSet };

package/dist/esm/src/data/transformers/match.d.ts

@@ -0,0 +1,5 @@
+import { MatchAttributes, MatchModel } from '../models';
+import { Match } from '../../service';
+declare function transformToAttributes(match: Match): MatchAttributes;
+declare function transformToObject(model: MatchModel): Match;
+export { transformToObject as transformToMatch, transformToAttributes as transformFromMatch };

package/dist/esm/src/data/transformers/match.js

@@ -0,0 +1,57 @@
+import { Match } from '../../service';
+import { transformToMatchSet } from './match-set';
+import { transformToTeam } from './team';
+import { transformToVPER } from './vper';
+function transformToAttributes(match) {
+    return {
+        match_id: match.id,
+        away_team: match.awayTeam.id,
+        home_team: match.homeTeam.id,
+        scheduled_date: match.scheduledDate,
+        status: match.status
+    };
+}
+function transformToObject(model) {
+    const sets = (model.MatchSets ?? []).map(transformToMatchSet)
+        .sort((s1, s2) => s1.order - s2.order);
+    let homeScore = 0;
+    let awayScore = 0;
+    for (let i = 0; i < 5; i++) {
+        if (model.MatchResult != null) {
+            if (model.MatchResult.home_scores[i] == null && model.MatchResult.away_scores[i] == null)
+                break;
+            if (model.MatchResult.home_scores[i] > model.MatchResult.away_scores[i])
+                homeScore++;
+            else if (model.MatchResult.away_scores[i] > model.MatchResult.home_scores[i])
+                awayScore++;
+            else
+                throw new Error(`INVALID_TIE: match=${model.match_id} set=${i}`);
+        }
+        else if (model.MatchSets != null) {
+            if (model.MatchSets[i] == null)
+                break;
+            if (model.MatchSets[i].home_score > model.MatchSets[i].away_score)
+                homeScore++;
+            else if (model.MatchSets[i].away_score > model.MatchSets[i].home_score)
+                awayScore++;
+            else
+                throw new Error(`INVALID_TIE: match=${model.match_id} set=${i}`);
+        }
+        else
+            break;
+    }
+    const VPERs = (model.VPERs ?? []).map(transformToVPER);
+    return Match.create({
+        id: model.match_id,
+        homeTeam: transformToTeam(model.HomeTeam),
+        awayTeam: transformToTeam(model.AwayTeam),
+        scheduledDate: new Date(model.scheduled_date),
+        sets,
+        status: model.status,
+        VPERs,
+        homeScore,
+        awayScore,
+        winner: model.MatchResult?.Winner != null ? transformToTeam(model.MatchResult.Winner) : undefined
+    });
+}
+export { transformToObject as transformToMatch, transformToAttributes as transformFromMatch };

package/dist/esm/src/data/transformers/performance-stats.d.ts

@@ -0,0 +1,5 @@
+import { PerformanceStatsAttributes, PerformanceStatsModel } from '../models';
+import { PerformanceStats } from '../../service';
+declare function transformToAttributes(stats: PerformanceStats, playerId: string): PerformanceStatsAttributes;
+declare function transformToObject(model: PerformanceStatsModel): PerformanceStats;
+export { transformToObject as transformToPerformanceStats, transformToAttributes as transformFromPerformanceStats };

package/dist/esm/src/data/transformers/performance-stats.js

@@ -0,0 +1,47 @@
+import { PerformanceStats } from '../../service';
+function transformToAttributes(stats, playerId) {
+    return {
+        player_id: playerId,
+        back_attack: stats.backAttack,
+        block: stats.block,
+        read: stats.read,
+        commit: stats.commit,
+        focus: stats.focus,
+        awareness: stats.awareness,
+        defense: stats.defense,
+        quick: stats.quick,
+        power: stats.power,
+        attack: stats.attack,
+        serve: stats.serve,
+        reception: stats.reception,
+        overhand: stats.overhand,
+        bump: stats.bump,
+        setting: stats.setting,
+        spike: stats.spike,
+        stamina: stats.stamina,
+        reflex: stats.reflex
+    };
+}
+function transformToObject(model) {
+    return PerformanceStats.create({
+        setting: model.setting,
+        serve: model.serve,
+        spike: model.spike,
+        quick: model.quick,
+        power: model.power,
+        awareness: model.awareness,
+        attack: model.attack,
+        backAttack: model.back_attack,
+        reception: model.reception,
+        overhand: model.overhand,
+        bump: model.bump,
+        block: model.block,
+        read: model.read,
+        commit: model.commit,
+        focus: model.focus,
+        defense: model.defense,
+        stamina: model.stamina,
+        reflex: model.reflex
+    });
+}
+export { transformToObject as transformToPerformanceStats, transformToAttributes as transformFromPerformanceStats };

package/dist/esm/src/data/transformers/player-team.d.ts

@@ -0,0 +1,3 @@
+import { PlayerTeamAttributes } from '../models';
+declare function transformToAttributes(playerId: string, teamId: string, jerseyNumber: number, active?: boolean, locked?: boolean): PlayerTeamAttributes;
+export { transformToAttributes as transformFromPlayerTeam };

package/dist/esm/src/data/transformers/player-team.js

@@ -0,0 +1,10 @@
+function transformToAttributes(playerId, teamId, jerseyNumber, active = false, locked = false) {
+    return {
+        player_id: playerId,
+        team_id: teamId,
+        jersey_number: jerseyNumber,
+        active,
+        locked
+    };
+}
+export { transformToAttributes as transformFromPlayerTeam };

package/dist/esm/src/data/transformers/player.d.ts

@@ -0,0 +1,5 @@
+import { PlayerAttributes, PlayerModel } from '../models';
+import { Player } from '../../service';
+declare function transformToAttributes(player: Player): PlayerAttributes;
+declare function transformToObject(model: PlayerModel): Player;
+export { transformToObject as transformToPlayer, transformToAttributes as transformFromPlayer };

package/dist/esm/src/data/transformers/player.js

@@ -0,0 +1,82 @@
+import { Player } from '../../service';
+import { transformFromPerformanceStats, transformToBoxScore, transformToCountry, transformToPerformanceStats } from '.';
+function toNumberStrict(value, field) {
+    const parsed = typeof value === 'number' ? value : Number(value);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`INVALID_BOX_SCORE_TOTALS_NUMERIC_FIELD field=${field} value=${JSON.stringify(value)}`);
+    }
+    return parsed;
+}
+function transformToAttributes(player) {
+    return {
+        player_id: player.id,
+        country_id: player.country.id,
+        first_name: player.name.first,
+        last_name: player.name.last,
+        roles: player.roles,
+        traits: player.traits,
+        PerformanceStat: transformFromPerformanceStats(player.stats, player.id),
+        rarity: player.rarity
+    };
+}
+function transformToBoxScoreTotals(model) {
+    return {
+        attack: {
+            attempts: toNumberStrict(model.attack_attempts, 'attack_attempts'),
+            kills: toNumberStrict(model.attack_kills, 'attack_kills'),
+            errors: toNumberStrict(model.attack_errors, 'attack_errors')
+        },
+        serve: {
+            attempts: toNumberStrict(model.serve_attempts, 'serve_attempts'),
+            aces: toNumberStrict(model.serve_aces, 'serve_aces'),
+            errors: toNumberStrict(model.serve_errors, 'serve_errors')
+        },
+        reception: {
+            attempts: toNumberStrict(model.reception_attempts, 'reception_attempts'),
+            perfect: toNumberStrict(model.reception_perfect, 'reception_perfect'),
+            positive: toNumberStrict(model.reception_positive, 'reception_positive'),
+            overpasses: toNumberStrict(model.reception_overpasses, 'reception_overpasses'),
+            errors: toNumberStrict(model.reception_errors, 'reception_errors')
+        },
+        block: {
+            solo: toNumberStrict(model.block_solo, 'block_solo'),
+            assists: toNumberStrict(model.block_assists, 'block_assists'),
+            errors: toNumberStrict(model.block_errors, 'block_errors'),
+            touches: toNumberStrict(model.block_touches, 'block_touches')
+        },
+        setting: {
+            assists: toNumberStrict(model.setting_assists, 'setting_assists'),
+            pass: toNumberStrict(model.setting_pass, 'setting_pass'),
+            errors: toNumberStrict(model.setting_errors, 'setting_errors')
+        },
+        defense: {
+            digs: toNumberStrict(model.defense_digs, 'defense_digs'),
+            errors: toNumberStrict(model.defense_errors, 'defense_errors')
+        },
+        misc: {
+            pointsPlayed: toNumberStrict(model.misc_points_played, 'misc_points_played'),
+            pointsWonOnCourt: toNumberStrict(model.misc_points_won_on_court, 'misc_points_won_on_court'),
+            serveTurns: toNumberStrict(model.misc_serve_turns, 'misc_serve_turns'),
+            sideoutOpportunities: toNumberStrict(model.misc_sideout_opportunities, 'misc_sideout_opportunities'),
+            successfulSideouts: toNumberStrict(model.misc_successful_sideouts, 'misc_successful_sideouts')
+        }
+    };
+}
+function transformToObject(model) {
+    const boxScoreTotals = model.BoxScoreTotals != null ? transformToBoxScoreTotals(model.BoxScoreTotals) : undefined;
+    return Player.create({
+        id: model.player_id,
+        name: {
+            first: model.first_name,
+            last: model.last_name
+        },
+        country: transformToCountry(model.country),
+        roles: model.roles,
+        traits: model.traits,
+        stats: transformToPerformanceStats(model.PerformanceStat),
+        rarity: model.rarity,
+        boxScores: (model.BoxScores ?? []).map(transformToBoxScore),
+        boxScoreTotals
+    });
+}
+export { transformToObject as transformToPlayer, transformToAttributes as transformFromPlayer };

package/dist/esm/src/data/transformers/promotion-match.d.ts

@@ -0,0 +1,5 @@
+import { PromotionMatch } from '../../service';
+import { PromotionMatchAttributes, PromotionMatchModel } from '../models';
+declare function transformToAttributes(promotionMatch: PromotionMatch): PromotionMatchAttributes;
+declare function transformToObject(model: PromotionMatchModel): PromotionMatch;
+export { transformToObject as transformToPromotionMatch, transformToAttributes as transformFromPromotionMatch };

package/dist/esm/src/data/transformers/promotion-match.js

@@ -0,0 +1,20 @@
+import { PromotionMatch } from '../../service';
+import { transformFromMatch, transformToMatch } from '.';
+function transformToAttributes(promotionMatch) {
+    return {
+        iteration: promotionMatch.iteration,
+        match_id: promotionMatch.match.id,
+        upper_competition: promotionMatch.upperCompetitionId,
+        lower_competition: promotionMatch.lowerCompetitionId,
+        match: transformFromMatch(promotionMatch.match)
+    };
+}
+function transformToObject(model) {
+    return PromotionMatch.create({
+        upperCompetitionId: model.upper_competition,
+        lowerCompetitionId: model.lower_competition,
+        iteration: model.iteration,
+        match: transformToMatch(model.Match)
+    });
+}
+export { transformToObject as transformToPromotionMatch, transformToAttributes as transformFromPromotionMatch };

package/dist/esm/src/data/transformers/qualifier-match.d.ts

@@ -0,0 +1,5 @@
+import { QualifierMatch } from '../../service';
+import { CompetitionMatchAttributes, CompetitionMatchModel } from '../models';
+declare function transformToAttributes(tournamentMatch: QualifierMatch, tournamentId: string): CompetitionMatchAttributes;
+declare function transformToObject(model: CompetitionMatchModel): QualifierMatch;
+export { transformToObject as transformToQualifierMatch, transformToAttributes as transformFromQualifierMatch };

package/dist/esm/src/data/transformers/qualifier-match.js

@@ -0,0 +1,19 @@
+import { QualifierMatch } from '../../service';
+import { transformFromMatch, transformFromStage, transformToMatch, transformToStage } from '.';
+function transformToAttributes(tournamentMatch, tournamentId) {
+    return {
+        competition_id: tournamentId,
+        match_id: tournamentMatch.match.id,
+        index: tournamentMatch.index,
+        stage: transformFromStage(tournamentMatch.stage),
+        Match: transformFromMatch(tournamentMatch.match)
+    };
+}
+function transformToObject(model) {
+    return QualifierMatch.create({
+        stage: transformToStage(model.stage),
+        match: transformToMatch(model.Match),
+        index: model.index
+    });
+}
+export { transformToObject as transformToQualifierMatch, transformToAttributes as transformFromQualifierMatch };

package/dist/esm/src/data/transformers/qualifier.d.ts

@@ -0,0 +1,5 @@
+import { CompetitionAttributes, CompetitionModel } from '../models';
+import { Qualifier } from '../../service';
+declare function transformToAttributes(qualifier: Qualifier): CompetitionAttributes;
+declare function transformToObject(model: CompetitionModel): Qualifier;
+export { transformToObject as transformToQualifier, transformToAttributes as transformFromQualifier };

package/dist/esm/src/data/transformers/qualifier.js

@@ -0,0 +1,49 @@
+import { sortTeamsByCompetitionIndex, transformFromQualifierMatch, transformToIteration, transformToQualifierMatch, transformToRegion, transformToTeam } from '.';
+import { Qualifier } from '../../service';
+function transformToAttributes(qualifier) {
+    const CompetitionMatches = qualifier.matches.map((match) => transformFromQualifierMatch(match, qualifier.id));
+    const CompetitionTeams = qualifier.teams.map((team, index) => ({
+        competition_id: qualifier.id,
+        team_id: team.id,
+        index
+    }));
+    const RegionQualifier = {
+        competition_id: qualifier.id,
+        iteration: qualifier.iteration.id,
+        region_code: qualifier.region.code
+    };
+    const CompetitionChampion = (qualifier.champion != null)
+        ? {
+            competition_id: qualifier.id,
+            team_id: qualifier.champion.id
+        }
+        : undefined;
+    return {
+        competition_id: qualifier.id,
+        type: 'QUALIFIER',
+        iteration: qualifier.iteration.id,
+        status: qualifier.status,
+        CompetitionMatches,
+        CompetitionTeams,
+        CompetitionChampion,
+        RegionQualifier
+    };
+}
+function transformToObject(model) {
+    const regionQualifier = model.RegionQualifier;
+    if (regionQualifier == null)
+        throw new Error(`MISSING_REGION_QUALIFIER competition=${model.competition_id}`);
+    const champion = model.CompetitionChampion?.team != null
+        ? transformToTeam(model.CompetitionChampion.team)
+        : undefined;
+    return Qualifier.create({
+        id: model.competition_id,
+        iteration: transformToIteration(model.Iteration),
+        matches: (model.CompetitionMatches ?? []).map(transformToQualifierMatch),
+        teams: sortTeamsByCompetitionIndex(model.Teams ?? []).map(transformToTeam),
+        status: model.status,
+        region: transformToRegion(regionQualifier),
+        champion
+    });
+}
+export { transformToObject as transformToQualifier, transformToAttributes as transformFromQualifier };

package/dist/esm/src/data/transformers/rally-event.d.ts

@@ -0,0 +1,20 @@
+import { Block, LiberoReplacement, RallyEvent, Reception, Serve, Set, Spike, Substitution } from '../../service';
+export interface CompactEvent {
+    p: number;
+    e: number;
+    f?: number;
+    t?: number;
+    a?: number;
+    s?: number;
+    b?: number[];
+    l?: number;
+    o?: number;
+}
+export declare function transformToCompact(evt: RallyEvent, playerIndex: Map<string, number>): CompactEvent;
+export declare function transformToBlock(event: CompactEvent, roster: string[]): Block;
+export declare function transformToLiberoReplacement(event: CompactEvent, roster: string[]): LiberoReplacement;
+export declare function transformToReception(event: CompactEvent, roster: string[]): Reception;
+export declare function transformToServe(event: CompactEvent, roster: string[]): Serve;
+export declare function transformToSet(event: CompactEvent, roster: string[]): Set;
+export declare function transformToSpike(event: CompactEvent, roster: string[]): Spike;
+export declare function transformToSubstitution(event: CompactEvent, roster: string[]): Substitution;

package/dist/esm/src/data/transformers/rally-event.js

@@ -0,0 +1,88 @@
+import { Block, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+export function transformToCompact(evt, playerIndex) {
+    const out = {
+        p: playerIndex.get(evt.playerId),
+        e: evt.eventType
+    };
+    if (evt instanceof InPlayEvent) {
+        out.f = evt.failure;
+        out.t = evt.type;
+        out.a = evt.target;
+        out.s = evt.score;
+        if (evt instanceof Block) {
+            out.b = evt.blockers.map(id => playerIndex.get(id));
+        }
+    }
+    else if (evt instanceof LiberoReplacement) {
+        out.t = evt.type;
+        out.l = playerIndex.get(evt.libero);
+    }
+    else if (evt instanceof Substitution) {
+        out.o = playerIndex.get(evt.playerOut);
+    }
+    return out;
+}
+export function transformToBlock(event, roster) {
+    return Block.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        blockers: (event.b ?? []).map(i => roster[i]),
+        score: event.s,
+        activeTraits: []
+    });
+}
+export function transformToLiberoReplacement(event, roster) {
+    return LiberoReplacement.create({
+        playerId: roster[event.p],
+        libero: roster[event.l],
+        type: event.t
+    });
+}
+export function transformToReception(event, roster) {
+    return Reception.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+export function transformToServe(event, roster) {
+    return Serve.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+export function transformToSet(event, roster) {
+    return Set.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+export function transformToSpike(event, roster) {
+    return Spike.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+export function transformToSubstitution(event, roster) {
+    return Substitution.create({
+        playerId: roster[event.p],
+        playerOut: roster[event.o]
+    });
+}

package/dist/esm/src/data/transformers/rally.d.ts

@@ -0,0 +1,5 @@
+import { RallyAttributes, RallyModel } from '../models';
+import { Rally } from '../../service';
+declare function transformToAttributes(rally: Rally, setId: string): RallyAttributes;
+declare function transformToObject(model: RallyModel): Rally;
+export { transformToObject as transformToRally, transformToAttributes as transformFromRally };

package/dist/esm/src/data/transformers/rally.js

@@ -0,0 +1,97 @@
+import { pack, unpack } from 'msgpackr';
+import { deflateRawSync, inflateRawSync } from 'zlib';
+import { decompressFromBase64 } from 'lz-string';
+import { Block, LiberoReplacement, Rally, Reception, Serve, Set as VolleySet, Spike, Substitution } from '../../service';
+import { transformToBlock, transformToCompact, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution } from './rally-event';
+const VERSION_BYTE = 0x01;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deflate(data) { return deflateRawSync(data); }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function inflate(data) { return inflateRawSync(data); }
+function buildRoster(events) {
+    const seen = [];
+    const index = new Map();
+    function add(id) {
+        if (!index.has(id)) {
+            index.set(id, seen.length);
+            seen.push(id);
+        }
+    }
+    for (const evt of events) {
+        add(evt.playerId);
+        if (evt instanceof Block) {
+            evt.blockers.forEach(add);
+        }
+        else if (evt instanceof LiberoReplacement) {
+            add(evt.libero);
+        }
+        else if (evt instanceof Substitution) {
+            add(evt.playerOut);
+        }
+    }
+    return index;
+}
+function transformToAttributes(rally, setId) {
+    const playerIndex = buildRoster(rally.events);
+    const roster = Array.from(playerIndex.keys());
+    const payload = {
+        r: roster,
+        e: rally.events.map(evt => transformToCompact(evt, playerIndex))
+    };
+    const compressed = deflate(pack(payload));
+    const events = Buffer.from([VERSION_BYTE, ...compressed]);
+    return {
+        rally_id: rally.id,
+        match_set_id: setId,
+        order: rally.order,
+        serving_team: rally.servingTeamId,
+        events
+    };
+}
+function decodeCompactEvent(event, roster) {
+    switch (event.e) {
+        case 0: return transformToLiberoReplacement(event, roster);
+        case 1: return transformToSubstitution(event, roster);
+        case 2: return transformToServe(event, roster);
+        case 3: return transformToReception(event, roster);
+        case 4: return transformToSet(event, roster);
+        case 5: return transformToSpike(event, roster);
+        case 6: return transformToBlock(event, roster);
+        default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
+    }
+}
+function decodeLegacyEvent(event) {
+    switch (event.e) {
+        case 0: return LiberoReplacement.create({ playerId: event.p, libero: event.l, type: event.t });
+        case 1: return Substitution.create({ playerId: event.p, playerOut: event.o });
+        case 2: return Serve.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 3: return Reception.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 4: return VolleySet.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 5: return Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 6: return Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s, activeTraits: [] });
+        default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
+    }
+}
+function transformToObject(model) {
+    const raw = model.events;
+    let events;
+    if (raw[0] === VERSION_BYTE) {
+        const payload = unpack(inflate(raw.subarray(1)));
+        events = payload.e.map(evt => decodeCompactEvent(evt, payload.r));
+    }
+    else {
+        // Legacy: lz-string base64 text stored as UTF-8 bytes in the bytea column
+        const text = raw.toString('utf8');
+        const decompressed = decompressFromBase64(text);
+        const json = (decompressed != null && decompressed.length > 0) ? decompressed : text;
+        const parsed = JSON.parse(json); // eslint-disable-line @typescript-eslint/no-explicit-any
+        events = parsed.map(decodeLegacyEvent);
+    }
+    return Rally.create({
+        id: model.rally_id,
+        order: model.order,
+        servingTeamId: model.serving_team,
+        events
+    });
+}
+export { transformToObject as transformToRally, transformToAttributes as transformFromRally };

package/dist/esm/src/data/transformers/region-qualifier.d.ts

@@ -0,0 +1,5 @@
+import { Qualifier, Region } from '../../service';
+import { RegionQualifierAttributes, RegionQualifierModel } from '../models';
+declare function transformToAttributes(qualifier: Qualifier): RegionQualifierAttributes;
+declare function transformToRegion(model: RegionQualifierModel): Region;
+export { transformToAttributes as transformFromRegionQualifier, transformToRegion };

package/dist/esm/src/data/transformers/region-qualifier.js

@@ -0,0 +1,14 @@
+function transformToAttributes(qualifier) {
+    return {
+        iteration: qualifier.iteration.id,
+        region_code: qualifier.region.code,
+        competition_id: qualifier.id
+    };
+}
+function transformToRegion(model) {
+    return {
+        code: model.region_code,
+        name: model.countryRegion?.region ?? model.region_code
+    };
+}
+export { transformToAttributes as transformFromRegionQualifier, transformToRegion };

package/dist/esm/src/data/transformers/season-match.d.ts

@@ -0,0 +1,4 @@
+import { CompetitionMatchAttributes } from '../models';
+import { Match } from '../../service';
+declare function transformToAttributes(seasonId: string, match: Match, index: number): CompetitionMatchAttributes;
+export { transformToAttributes as transformFromSeasonMatch };

package/dist/esm/src/data/transformers/season-match.js

@@ -0,0 +1,13 @@
+import { Stage } from '../../service';
+import { transformFromMatch } from './match';
+import { transformFromStage } from './stage';
+function transformToAttributes(seasonId, match, index) {
+    return {
+        competition_id: seasonId,
+        match_id: match.id,
+        index,
+        stage: transformFromStage(Stage.LEAGUE),
+        Match: transformFromMatch(match)
+    };
+}
+export { transformToAttributes as transformFromSeasonMatch };

package/dist/esm/src/data/transformers/season.d.ts

@@ -0,0 +1,5 @@
+import { CompetitionAttributes, CompetitionModel } from '../models';
+import { Season } from '../../service';
+declare function transformToAttributes(season: Season): CompetitionAttributes;
+declare function transformToObject(model: CompetitionModel): Season;
+export { transformToObject as transformToSeason, transformToAttributes as transformFromSeason };