volleyballsimtypes 0.0.217 → 0.0.358

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

@@ -1,79 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromPlayer = exports.transformToPlayer = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-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: (0, _1.transformFromPerformanceStats)(player.stats, player.id),
-        rarity: player.rarity
-    };
-}
-exports.transformFromPlayer = transformToAttributes;
-function transformToBoxScoreTotals(model) {
-    return {
-        attack: {
-            attempts: model.attack_attempts,
-            kills: model.attack_kills,
-            errors: model.attack_errors
-        },
-        serve: {
-            attempts: model.serve_attempts,
-            aces: model.serve_aces,
-            errors: model.serve_errors
-        },
-        reception: {
-            attempts: model.reception_attempts,
-            perfect: model.reception_perfect,
-            positive: model.reception_positive,
-            overpasses: model.reception_overpasses,
-            errors: model.reception_errors
-        },
-        block: {
-            solo: model.block_solo,
-            assists: model.block_assists,
-            errors: model.block_errors,
-            touches: model.block_touches
-        },
-        setting: {
-            assists: model.setting_assists,
-            pass: model.setting_pass,
-            errors: model.setting_errors
-        },
-        defense: {
-            digs: model.defense_digs,
-            errors: model.defense_errors
-        },
-        misc: {
-            pointsPlayed: model.misc_points_played,
-            pointsWonOnCourt: model.misc_points_won_on_court,
-            serveTurns: model.misc_serve_turns,
-            sideoutOpportunities: model.misc_sideout_opportunities,
-            successfulSideouts: model.misc_successful_sideouts
-        }
-    };
-}
-function transformToObject(model) {
-    const boxScoreTotals = model.BoxScoreTotals != null ? transformToBoxScoreTotals(model.BoxScoreTotals) : undefined;
-    return new service_1.Player({
-        id: model.player_id,
-        name: {
-            first: model.first_name,
-            last: model.last_name
-        },
-        country: (0, _1.transformToCountry)(model.country),
-        roles: model.roles,
-        traits: model.traits,
-        stats: (0, _1.transformToPerformanceStats)(model.PerformanceStat),
-        rarity: model.rarity,
-        boxScores: (model.BoxScores ?? []).map(_1.transformToBoxScore),
-        boxScoreTotals
-    });
-}
-exports.transformToPlayer = transformToObject;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToPlayer = transformToObject;
+exports.transformFromPlayer = transformToAttributes;
+const service_1 = require("../../service");
+const _1 = require(".");
+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: (0, _1.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 service_1.Player.create({
+        id: model.player_id,
+        name: {
+            first: model.first_name,
+            last: model.last_name
+        },
+        country: (0, _1.transformToCountry)(model.country),
+        roles: model.roles,
+        traits: model.traits,
+        stats: (0, _1.transformToPerformanceStats)(model.PerformanceStat),
+        rarity: model.rarity,
+        boxScores: (model.BoxScores ?? []).map(_1.transformToBoxScore),
+        boxScoreTotals
+    });
+}

package/dist/cjs/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/cjs/src/data/transformers/promotion-match.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToPromotionMatch = transformToObject;
+exports.transformFromPromotionMatch = transformToAttributes;
+const service_1 = require("../../service");
+const _1 = require(".");
+function transformToAttributes(promotionMatch) {
+    return {
+        iteration: promotionMatch.iteration,
+        match_id: promotionMatch.match.id,
+        upper_competition: promotionMatch.upperCompetitionId,
+        lower_competition: promotionMatch.lowerCompetitionId,
+        match: (0, _1.transformFromMatch)(promotionMatch.match)
+    };
+}
+function transformToObject(model) {
+    return service_1.PromotionMatch.create({
+        upperCompetitionId: model.upper_competition,
+        lowerCompetitionId: model.lower_competition,
+        iteration: model.iteration,
+        match: (0, _1.transformToMatch)(model.Match)
+    });
+}

package/dist/cjs/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/cjs/src/data/transformers/qualifier-match.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToQualifierMatch = transformToObject;
+exports.transformFromQualifierMatch = transformToAttributes;
+const service_1 = require("../../service");
+const _1 = require(".");
+function transformToAttributes(tournamentMatch, tournamentId) {
+    return {
+        competition_id: tournamentId,
+        match_id: tournamentMatch.match.id,
+        index: tournamentMatch.index,
+        stage: (0, _1.transformFromStage)(tournamentMatch.stage),
+        Match: (0, _1.transformFromMatch)(tournamentMatch.match)
+    };
+}
+function transformToObject(model) {
+    return service_1.QualifierMatch.create({
+        stage: (0, _1.transformToStage)(model.stage),
+        match: (0, _1.transformToMatch)(model.Match),
+        index: model.index
+    });
+}

package/dist/cjs/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/cjs/src/data/transformers/qualifier.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToQualifier = transformToObject;
+exports.transformFromQualifier = transformToAttributes;
+const _1 = require(".");
+const service_1 = require("../../service");
+function transformToAttributes(qualifier) {
+    const CompetitionMatches = qualifier.matches.map((match) => (0, _1.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
+        ? (0, _1.transformToTeam)(model.CompetitionChampion.team)
+        : undefined;
+    return service_1.Qualifier.create({
+        id: model.competition_id,
+        iteration: (0, _1.transformToIteration)(model.Iteration),
+        matches: (model.CompetitionMatches ?? []).map(_1.transformToQualifierMatch),
+        teams: (0, _1.sortTeamsByCompetitionIndex)(model.Teams ?? []).map(_1.transformToTeam),
+        status: model.status,
+        region: (0, _1.transformToRegion)(regionQualifier),
+        champion
+    });
+}

package/dist/cjs/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/cjs/src/data/transformers/rally-event.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToCompact = transformToCompact;
+exports.transformToBlock = transformToBlock;
+exports.transformToLiberoReplacement = transformToLiberoReplacement;
+exports.transformToReception = transformToReception;
+exports.transformToServe = transformToServe;
+exports.transformToSet = transformToSet;
+exports.transformToSpike = transformToSpike;
+exports.transformToSubstitution = transformToSubstitution;
+const service_1 = require("../../service");
+function transformToCompact(evt, playerIndex) {
+    const out = {
+        p: playerIndex.get(evt.playerId),
+        e: evt.eventType
+    };
+    if (evt instanceof service_1.InPlayEvent) {
+        out.f = evt.failure;
+        out.t = evt.type;
+        out.a = evt.target;
+        out.s = evt.score;
+        if (evt instanceof service_1.Block) {
+            out.b = evt.blockers.map(id => playerIndex.get(id));
+        }
+    }
+    else if (evt instanceof service_1.LiberoReplacement) {
+        out.t = evt.type;
+        out.l = playerIndex.get(evt.libero);
+    }
+    else if (evt instanceof service_1.Substitution) {
+        out.o = playerIndex.get(evt.playerOut);
+    }
+    return out;
+}
+function transformToBlock(event, roster) {
+    return service_1.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: []
+    });
+}
+function transformToLiberoReplacement(event, roster) {
+    return service_1.LiberoReplacement.create({
+        playerId: roster[event.p],
+        libero: roster[event.l],
+        type: event.t
+    });
+}
+function transformToReception(event, roster) {
+    return service_1.Reception.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+function transformToServe(event, roster) {
+    return service_1.Serve.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+function transformToSet(event, roster) {
+    return service_1.Set.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+function transformToSpike(event, roster) {
+    return service_1.Spike.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s,
+        activeTraits: []
+    });
+}
+function transformToSubstitution(event, roster) {
+    return service_1.Substitution.create({
+        playerId: roster[event.p],
+        playerOut: roster[event.o]
+    });
+}

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

@@ -1,5 +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 };
+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/cjs/src/data/transformers/rally.js

@@ -1,56 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromRally = exports.transformToRally = void 0;
-const service_1 = require("../../service");
-const lz_string_1 = require("lz-string");
-const events_1 = require("./events");
-function transformToAttributes(rally, setId) {
-    const events = `[${rally.events.map((e) => e.toString()).join(',')}]`;
-    return {
-        rally_id: rally.id,
-        match_set_id: setId,
-        order: rally.order,
-        serving_team: rally.servingTeamId,
-        events: (0, lz_string_1.compressToBase64)(events)
-    };
-}
-exports.transformFromRally = transformToAttributes;
-function transformToObject(model) {
-    const decompressed = (0, lz_string_1.decompressFromBase64)(model.events);
-    const parsed = JSON.parse(decompressed);
-    const events = [];
-    parsed.forEach(event => {
-        switch (event.eventType) {
-            case 0:
-                events.push((0, events_1.transformToLiberoReplacement)(event));
-                break;
-            case 1:
-                events.push((0, events_1.transformToSubstitution)(event));
-                break;
-            case 2:
-                events.push((0, events_1.transformToServe)(event));
-                break;
-            case 3:
-                events.push((0, events_1.transformToReception)(event));
-                break;
-            case 4:
-                events.push((0, events_1.transformToSet)(event));
-                break;
-            case 5:
-                events.push((0, events_1.transformToSpike)(event));
-                break;
-            case 6:
-                events.push((0, events_1.transformToBlock)(event));
-                break;
-            default:
-                throw new Error('UNKNOWN_EVENT');
-        }
-    });
-    return new service_1.Rally({
-        id: model.rally_id,
-        order: model.order,
-        servingTeamId: model.serving_team,
-        events
-    });
-}
-exports.transformToRally = transformToObject;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToRally = transformToObject;
+exports.transformFromRally = transformToAttributes;
+const msgpackr_1 = require("msgpackr");
+const zlib_1 = require("zlib");
+const lz_string_1 = require("lz-string");
+const service_1 = require("../../service");
+const rally_event_1 = require("./rally-event");
+const VERSION_BYTE = 0x01;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deflate(data) { return (0, zlib_1.deflateRawSync)(data); }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function inflate(data) { return (0, zlib_1.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 service_1.Block) {
+            evt.blockers.forEach(add);
+        }
+        else if (evt instanceof service_1.LiberoReplacement) {
+            add(evt.libero);
+        }
+        else if (evt instanceof service_1.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 => (0, rally_event_1.transformToCompact)(evt, playerIndex))
+    };
+    const compressed = deflate((0, msgpackr_1.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 (0, rally_event_1.transformToLiberoReplacement)(event, roster);
+        case 1: return (0, rally_event_1.transformToSubstitution)(event, roster);
+        case 2: return (0, rally_event_1.transformToServe)(event, roster);
+        case 3: return (0, rally_event_1.transformToReception)(event, roster);
+        case 4: return (0, rally_event_1.transformToSet)(event, roster);
+        case 5: return (0, rally_event_1.transformToSpike)(event, roster);
+        case 6: return (0, rally_event_1.transformToBlock)(event, roster);
+        default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
+    }
+}
+function decodeLegacyEvent(event) {
+    switch (event.e) {
+        case 0: return service_1.LiberoReplacement.create({ playerId: event.p, libero: event.l, type: event.t });
+        case 1: return service_1.Substitution.create({ playerId: event.p, playerOut: event.o });
+        case 2: return service_1.Serve.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 3: return service_1.Reception.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 4: return service_1.Set.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 5: return service_1.Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
+        case 6: return service_1.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 = (0, msgpackr_1.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 = (0, lz_string_1.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 service_1.Rally.create({
+        id: model.rally_id,
+        order: model.order,
+        servingTeamId: model.serving_team,
+        events
+    });
+}

package/dist/cjs/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/cjs/src/data/transformers/region-qualifier.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromRegionQualifier = transformToAttributes;
+exports.transformToRegion = transformToRegion;
+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
+    };
+}

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

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

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

@@ -1,16 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromSeasonMatch = void 0;
-const service_1 = require("../../service");
-const match_1 = require("./match");
-const stage_1 = require("./stage");
-function transformToAttributes(seasonId, match, index) {
-    return {
-        competition_id: seasonId,
-        match_id: match.id,
-        index,
-        stage: (0, stage_1.transformFromStage)(service_1.Stage.LEAGUE),
-        Match: (0, match_1.transformFromMatch)(match)
-    };
-}
-exports.transformFromSeasonMatch = transformToAttributes;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromSeasonMatch = transformToAttributes;
+const service_1 = require("../../service");
+const match_1 = require("./match");
+const stage_1 = require("./stage");
+function transformToAttributes(seasonId, match, index) {
+    return {
+        competition_id: seasonId,
+        match_id: match.id,
+        index,
+        stage: (0, stage_1.transformFromStage)(service_1.Stage.LEAGUE),
+        Match: (0, match_1.transformFromMatch)(match)
+    };
+}