volleyballsimtypes 0.0.8 → 0.0.10

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromRally = exports.transformToAPIRally = exports.transformToRally = void 0;
+const service_1 = require("../../service");
+const team_1 = require("./team");
+const rally_position_1 = require("./rally-position");
+const libero_replacement_1 = require("./libero-replacement");
+const substitution_1 = require("./substitution");
+const serve_1 = require("./serve");
+const reception_1 = require("./reception");
+const set_1 = require("./set");
+const spike_1 = require("./spike");
+const block_1 = require("./block");
+const score_1 = require("./score");
+function transformToAttributes(rally, set) {
+    const rallyPositions = [
+        ...rally.awayPlayerPosition.map(pp => (0, rally_position_1.transformFromPlayerPosition)(pp, 'Away', rally)),
+        ...rally.homePlayerPosition.map(pp => (0, rally_position_1.transformFromPlayerPosition)(pp, 'Home', rally))
+    ];
+    const temp = {};
+    for (const p of rallyPositions) {
+        // @ts-ignore
+        if (temp[p.player_id] != null) {
+            throw new Error('DUPLICATE_KEY');
+        }
+        else {
+            // @ts-ignore
+            temp[p.player_id] = p.rally_id;
+        }
+    }
+    return {
+        rally_id: rally.id,
+        match_set_id: set.id,
+        order: rally.order,
+        serving_team: rally.servingTeam.id,
+        RallyPositions: rallyPositions,
+        LiberoReplacements: rally.events.filter(event => event.eventType === service_1.EventType.LIBERO_REPLACEMENT)
+            .map(event => (0, libero_replacement_1.transformFromLiberoReplacement)(event, rally)),
+        Substitutions: rally.events.filter(event => event.eventType === service_1.EventType.SUBSTITUTION)
+            .map(event => (0, substitution_1.transformFromSubstitution)(event, rally)),
+        Serves: rally.events.filter(event => event.eventType === service_1.EventType.SERVE)
+            .map(event => (0, serve_1.transformFromServe)(event, rally)),
+        Receptions: rally.events.filter(event => event.eventType === service_1.EventType.RECEPTION)
+            .map(event => (0, reception_1.transformFromReception)(event, rally)),
+        Sets: rally.events.filter(event => event.eventType === service_1.EventType.SET)
+            .map(event => (0, set_1.transformFromSet)(event, rally)),
+        Spikes: rally.events.filter(event => event.eventType === service_1.EventType.SPIKE)
+            .map(event => (0, spike_1.transformFromSpike)(event, rally)),
+        Blocks: rally.events.filter(event => event.eventType === service_1.EventType.BLOCK)
+            .map(event => (0, block_1.transformFromBlock)(event, rally)),
+        Scores: rally.events.filter(event => event.eventType === service_1.EventType.SCORE)
+            .map(event => (0, score_1.transformFromScore)(event, rally))
+    };
+}
+exports.transformFromRally = transformToAttributes;
+function transformToObject(model) {
+    const liberoReplacements = model.LiberoReplacements.map(libero_replacement_1.transformToLiberoReplacement);
+    const substitutions = model.Substitutions.map(substitution_1.transformToSubstitution);
+    const serves = model.Serves.map(serve_1.transformToServe);
+    const receptions = model.Receptions.map(reception_1.transformToReception);
+    const sets = model.Sets.map(set_1.transformToSet);
+    const spikes = model.Spikes.map(spike_1.transformToSpike);
+    const blocks = model.Blocks.map(block_1.transformToBlock);
+    const scores = model.Scores.map(score_1.transformToScore);
+    const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks, ...scores]
+        .sort((e1, e2) => e1.order - e2.order);
+    return new service_1.Rally({
+        id: model.rally_id,
+        order: model.order,
+        servingTeam: (0, team_1.transformToTeam)(model.serving_team_Team),
+        awayPlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Away')
+            .map(rally_position_1.transformToPlayerPosition),
+        homePlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Home')
+            .map(rally_position_1.transformToPlayerPosition),
+        events: events
+    });
+}
+exports.transformToRally = transformToObject;
+function transformToAPIObject(model) {
+    const liberoReplacements = model.LiberoReplacements.map(libero_replacement_1.transformToAPILiberoReplacement);
+    const substitutions = model.Substitutions.map(substitution_1.transformToAPISubstitution);
+    const serves = model.Serves.map(serve_1.transformToAPIServe);
+    const receptions = model.Receptions.map(reception_1.transformToAPIReception);
+    const sets = model.Sets.map(set_1.transformToAPISet);
+    const spikes = model.Spikes.map(spike_1.transformToAPISpike);
+    const blocks = model.Blocks.map(block_1.transformToAPIBlock);
+    const scores = model.Scores.map(score_1.transformToAPIScore);
+    const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks, ...scores]
+        .sort((e1, e2) => e1.order - e2.order);
+    return {
+        id: model.rally_id,
+        order: model.order,
+        servingTeamId: model.serving_team,
+        awayPlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Away')
+            .map(rally_position_1.transformToPlayerPosition),
+        homePlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Home')
+            .map(rally_position_1.transformToPlayerPosition),
+        events: events
+    };
+}
+exports.transformToAPIRally = transformToAPIObject;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromReception = exports.transformToAPIReception = exports.transformToReception = void 0;
+const service_1 = require("../../service");
+const event_type_1 = require("./event-type");
+const court_target_1 = require("./court-target");
+const player_1 = require("./player");
+function transformToReceptionFailure(failure) {
+    switch (failure) {
+        case service_1.ReceptionFailure.NO_FAILURE:
+            return 'NO_FAILURE';
+        case service_1.ReceptionFailure.FAULT:
+            return 'FAULT';
+        case service_1.ReceptionFailure.MISS:
+            return 'MISS';
+        case service_1.ReceptionFailure.OUT_OF_BOUNDS:
+            return 'OUT_OF_BOUNDS';
+        case service_1.ReceptionFailure.BAD_PASS:
+            return 'BAD_PASS';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromReceptionFailure(failure) {
+    return service_1.ReceptionFailure[failure];
+}
+function transformToReceptionType(type) {
+    switch (type) {
+        case service_1.ReceptionType.DIG:
+            return 'DIG';
+        case service_1.ReceptionType.OVERHAND:
+            return 'OVERHAND';
+        case service_1.ReceptionType.ONE_HAND:
+            return 'ONE_HAND';
+        case service_1.ReceptionType.OTHER_BODY_PART:
+            return 'OTHER_BODY_PART';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromReceptionType(type) {
+    return service_1.ReceptionType[type];
+}
+function transformToAttributes(event, rally) {
+    return {
+        event_id: event.id,
+        player_id: event.player.id,
+        rally_id: rally.id,
+        order: event.order,
+        modifier: event.modifier,
+        score: event.score,
+        target: (0, court_target_1.transformFromCourtTarget)(event.target),
+        failure: transformToReceptionFailure(event.failure),
+        type: transformToReceptionType(event.type),
+        event_type: (0, event_type_1.transformFromEventType)(event.eventType)
+    };
+}
+exports.transformFromReception = transformToAttributes;
+function transformToObject(event) {
+    return new service_1.Reception({
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        failure: transformFromReceptionFailure(event.failure),
+        type: transformFromReceptionType(event.type),
+        player: (0, player_1.transformToPlayer)(event.player),
+        target: (0, court_target_1.transformToCourtTarget)(event.target),
+        modifier: event.modifier,
+        order: event.order,
+        score: event.score
+    });
+}
+exports.transformToReception = transformToObject;
+function transformToAPIObject(event) {
+    return {
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        failure: transformFromReceptionFailure(event.failure),
+        type: transformFromReceptionType(event.type),
+        playerId: event.player_id,
+        target: (0, court_target_1.transformToCourtTarget)(event.target),
+        modifier: event.modifier,
+        order: event.order,
+        score: event.score
+    };
+}
+exports.transformToAPIReception = transformToAPIObject;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToRole = exports.transformFromRole = void 0;
+const service_1 = require("../../service");
+function transformToType(role) {
+    switch (role) {
+        case service_1.Role.SETTER:
+            return 'SETTER';
+        case service_1.Role.DEFENSIVE_SPECIALIST:
+            return 'DEFENSIVE_SPECIALIST';
+        case service_1.Role.LIBERO:
+            return 'LIBERO';
+        case service_1.Role.MIDDLE_BLOCKER:
+            return 'MIDDLE_BLOCKER';
+        case service_1.Role.OUTSIDE_HITTER:
+            return 'OUTSIDE_HITTER';
+        case service_1.Role.OPPOSITE_HITTER:
+            return 'OPPOSITE_HITTER';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+exports.transformFromRole = transformToType;
+function transformFromType(role) {
+    return service_1.Role[role];
+}
+exports.transformToRole = transformFromType;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromScore = exports.transformToAPIScore = exports.transformToScore = void 0;
+const service_1 = require("../../service");
+const event_type_1 = require("./event-type");
+const player_1 = require("./player");
+const team_1 = require("./team");
+function transformToAttributes(event, rally) {
+    return {
+        player_id: event.player.id,
+        event_id: event.id,
+        order: event.order,
+        event_type: (0, event_type_1.transformFromEventType)(event.eventType),
+        rally_id: rally.id,
+        team_id: event.team.id
+    };
+}
+exports.transformFromScore = transformToAttributes;
+function transformToObject(event) {
+    return new service_1.Score({
+        id: event.event_id,
+        player: (0, player_1.transformToPlayer)(event.player),
+        order: event.order,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        team: (0, team_1.transformToTeam)(event.team)
+    });
+}
+exports.transformToScore = transformToObject;
+function transformToAPIObject(event) {
+    return {
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        playerId: event.player_id,
+        order: event.order,
+        teamId: event.team_id
+    };
+}
+exports.transformToAPIScore = transformToAPIObject;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromSeason = exports.transformToAPISeason = exports.transformToSeason = void 0;
+const team_1 = require("./team");
+const league_1 = require("../../service/league");
+const match_1 = require("./match");
+const league_2 = require("./league");
+function transformToAttributes(season, league) {
+    return {
+        season_id: season.id,
+        iteration: season.iteration,
+        league_id: league.id
+    };
+}
+exports.transformFromSeason = transformToAttributes;
+function transformToObject(model) {
+    return new league_1.Season({
+        id: model.season_id,
+        matches: model.Matches != null ? model.Matches.map(match_1.transformToMatch) : [],
+        iteration: model.iteration,
+        teams: model.seasonTeams != null ? model.seasonTeams.map(team_1.transformToTeam) : [],
+    });
+}
+exports.transformToSeason = transformToObject;
+function transformToAPIObject(model) {
+    const season = transformToObject(model);
+    return {
+        id: model.season_id,
+        matches: model.Matches != null ? model.Matches.map(match_1.transformToAPIMatch) : [],
+        iteration: model.iteration,
+        teams: model.seasonTeams != null ? model.seasonTeams.map(team_1.transformToAPITeam) : [],
+        league: (0, league_2.transformToLeague)(model.league),
+        standings: season.standings
+    };
+}
+exports.transformToAPISeason = transformToAPIObject;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromServe = exports.transformToAPIServe = exports.transformToServe = void 0;
+const service_1 = require("../../service");
+const event_type_1 = require("./event-type");
+const court_target_1 = require("./court-target");
+const player_1 = require("./player");
+function transformToServeFailure(failure) {
+    switch (failure) {
+        case service_1.ServeFailure.NO_FAILURE:
+            return 'NO_FAILURE';
+        case service_1.ServeFailure.FAULT:
+            return 'FAULT';
+        case service_1.ServeFailure.MISS:
+            return 'MISS';
+        case service_1.ServeFailure.OUT_OF_BOUNDS:
+            return 'OUT_OF_BOUNDS';
+        case service_1.ServeFailure.NET:
+            return 'NET';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromServeFailure(failure) {
+    return service_1.ServeFailure[failure];
+}
+function transformToServeType(type) {
+    switch (type) {
+        case service_1.ServeType.UNDERHAND:
+            return 'UNDERHAND';
+        case service_1.ServeType.OVERHAND_TOPSPIN:
+            return 'OVERHAND_TOPSPIN';
+        case service_1.ServeType.OVERHAND_FLOAT:
+            return 'OVERHAND_FLOAT';
+        case service_1.ServeType.JUMP_TOPSPIN:
+            return 'JUMP_TOPSPIN';
+        case service_1.ServeType.JUMP_FLOAT:
+            return 'JUMP_FLOAT';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromServeType(type) {
+    return service_1.ServeType[type];
+}
+function transformToAttributes(event, rally) {
+    return {
+        event_id: event.id,
+        player_id: event.player.id,
+        rally_id: rally.id,
+        order: event.order,
+        modifier: event.modifier,
+        score: event.score,
+        target: (0, court_target_1.transformFromCourtTarget)(event.target),
+        failure: transformToServeFailure(event.failure),
+        type: transformToServeType(event.type),
+        event_type: (0, event_type_1.transformFromEventType)(event.eventType)
+    };
+}
+exports.transformFromServe = transformToAttributes;
+function transformToObject(serve) {
+    return new service_1.Serve({
+        id: serve.event_id,
+        eventType: (0, event_type_1.transformToEventType)(serve.event_type),
+        failure: transformFromServeFailure(serve.failure),
+        type: transformFromServeType(serve.type),
+        player: (0, player_1.transformToPlayer)(serve.player),
+        target: (0, court_target_1.transformToCourtTarget)(serve.target),
+        modifier: serve.modifier,
+        order: serve.order,
+        score: serve.score
+    });
+}
+exports.transformToServe = transformToObject;
+function transformToAPIObject(event) {
+    return {
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        failure: transformFromServeFailure(event.failure),
+        type: transformFromServeType(event.type),
+        playerId: event.player_id,
+        target: (0, court_target_1.transformToCourtTarget)(event.target),
+        modifier: event.modifier,
+        order: event.order,
+        score: event.score
+    };
+}
+exports.transformToAPIServe = transformToAPIObject;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromSet = exports.transformToAPISet = exports.transformToSet = void 0;
+const service_1 = require("../../service");
+const event_type_1 = require("./event-type");
+const court_target_1 = require("./court-target");
+const player_1 = require("./player");
+function transformToSetFailure(failure) {
+    switch (failure) {
+        case service_1.SetFailure.NO_FAILURE:
+            return 'NO_FAILURE';
+        case service_1.SetFailure.FAULT:
+            return 'FAULT';
+        case service_1.SetFailure.MISS:
+            return 'MISS';
+        case service_1.SetFailure.OUT_OF_BOUNDS:
+            return 'OUT_OF_BOUNDS';
+        case service_1.SetFailure.BAD_PASS:
+            return 'BAD_PASS';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromSetFailure(failure) {
+    return service_1.SetFailure[failure];
+}
+function transformToSetType(type) {
+    switch (type) {
+        case service_1.SetType.OVERHAND:
+            return 'OVERHAND';
+        case service_1.SetType.UNDERHAND:
+            return 'UNDERHAND';
+        case service_1.SetType.SPIKE:
+            return 'SPIKE';
+        case service_1.SetType.DUMP:
+            return 'DUMP';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromSetType(type) {
+    return service_1.SetType[type];
+}
+function transformToAttributes(event, rally) {
+    return {
+        event_id: event.id,
+        player_id: event.player.id,
+        rally_id: rally.id,
+        order: event.order,
+        modifier: event.modifier,
+        score: event.score,
+        target: (0, court_target_1.transformFromCourtTarget)(event.target),
+        failure: transformToSetFailure(event.failure),
+        type: transformToSetType(event.type),
+        event_type: (0, event_type_1.transformFromEventType)(event.eventType)
+    };
+}
+exports.transformFromSet = transformToAttributes;
+function transformToObject(set) {
+    return new service_1.Set({
+        id: set.event_id,
+        eventType: (0, event_type_1.transformToEventType)(set.event_type),
+        failure: transformFromSetFailure(set.failure),
+        type: transformFromSetType(set.type),
+        player: (0, player_1.transformToPlayer)(set.player),
+        target: (0, court_target_1.transformToCourtTarget)(set.target),
+        modifier: set.modifier,
+        order: set.order,
+        score: set.score
+    });
+}
+exports.transformToSet = transformToObject;
+function transformToAPIObject(event) {
+    return {
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        failure: transformFromSetFailure(event.failure),
+        type: transformFromSetType(event.type),
+        playerId: event.player_id,
+        target: (0, court_target_1.transformToCourtTarget)(event.target),
+        modifier: event.modifier,
+        order: event.order,
+        score: event.score
+    };
+}
+exports.transformToAPISet = transformToAPIObject;

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromSpike = exports.transformToAPISpike = exports.transformToSpike = void 0;
+const service_1 = require("../../service");
+const event_type_1 = require("./event-type");
+const court_target_1 = require("./court-target");
+const player_1 = require("./player");
+function transformToSpikeFailure(failure) {
+    switch (failure) {
+        case service_1.SpikeFailure.NO_FAILURE:
+            return 'NO_FAILURE';
+        case service_1.SpikeFailure.FAULT:
+            return 'FAULT';
+        case service_1.SpikeFailure.MISS:
+            return 'MISS';
+        case service_1.SpikeFailure.OUT_OF_BOUNDS:
+            return 'OUT_OF_BOUNDS';
+        case service_1.SpikeFailure.NET:
+            return 'NET';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromSpikeFailure(failure) {
+    return service_1.SpikeFailure[failure];
+}
+function transformToSpikeType(type) {
+    switch (type) {
+        case service_1.SpikeType.CROSS_SHOT:
+            return 'CROSS_SHOT';
+        case service_1.SpikeType.LINE_SHOT:
+            return 'LINE_SHOT';
+        case service_1.SpikeType.TOOL_SHOT:
+            return 'TOOL_SHOT';
+        case service_1.SpikeType.TIP:
+            return 'TIP';
+        case service_1.SpikeType.DOWN_BALL:
+            return 'DOWN_BALL';
+        case service_1.SpikeType.OVERHAND:
+            return 'OVERHAND';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromSpikeType(type) {
+    return service_1.SpikeType[type];
+}
+function transformToAttributes(event, rally) {
+    return {
+        event_id: event.id,
+        player_id: event.player.id,
+        rally_id: rally.id,
+        order: event.order,
+        modifier: event.modifier,
+        score: event.score,
+        target: (0, court_target_1.transformFromCourtTarget)(event.target),
+        failure: transformToSpikeFailure(event.failure),
+        type: transformToSpikeType(event.type),
+        event_type: (0, event_type_1.transformFromEventType)(event.eventType)
+    };
+}
+exports.transformFromSpike = transformToAttributes;
+function transformToObject(spike) {
+    return new service_1.Spike({
+        id: spike.event_id,
+        eventType: (0, event_type_1.transformToEventType)(spike.event_type),
+        failure: transformFromSpikeFailure(spike.failure),
+        type: transformFromSpikeType(spike.type),
+        player: (0, player_1.transformToPlayer)(spike.player),
+        target: (0, court_target_1.transformToCourtTarget)(spike.target),
+        modifier: spike.modifier,
+        order: spike.order,
+        score: spike.score
+    });
+}
+exports.transformToSpike = transformToObject;
+function transformToAPIObject(event) {
+    return {
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        failure: transformFromSpikeFailure(event.failure),
+        type: transformFromSpikeType(event.type),
+        playerId: event.player_id,
+        target: (0, court_target_1.transformToCourtTarget)(event.target),
+        modifier: event.modifier,
+        order: event.order,
+        score: event.score
+    };
+}
+exports.transformToAPISpike = transformToAPIObject;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromSubstitution = exports.transformToAPISubstitution = exports.transformToSubstitution = void 0;
+const service_1 = require("../../service");
+const event_type_1 = require("./event-type");
+const player_1 = require("./player");
+function transformToAttributes(event, rally) {
+    return {
+        player_id: event.player.id,
+        event_id: event.id,
+        order: event.order,
+        event_type: (0, event_type_1.transformFromEventType)(event.eventType),
+        player_out: event.playerOut.id,
+        rally_id: rally.id
+    };
+}
+exports.transformFromSubstitution = transformToAttributes;
+function transformToObject(event) {
+    return new service_1.Substitution({
+        id: event.event_id,
+        player: (0, player_1.transformToPlayer)(event.player),
+        playerOut: (0, player_1.transformToPlayer)(event.player_out_Player),
+        order: event.order,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type)
+    });
+}
+exports.transformToSubstitution = transformToObject;
+function transformToAPIObject(event) {
+    return {
+        id: event.event_id,
+        eventType: (0, event_type_1.transformToEventType)(event.event_type),
+        playerId: event.player_id,
+        order: event.order,
+        playerOutId: event.player_out
+    };
+}
+exports.transformToAPISubstitution = transformToAPIObject;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromTeam = exports.transformToAPITeam = exports.transformToTeam = void 0;
+const service_1 = require("../../service");
+const country_1 = require("./country");
+const coach_1 = require("./coach");
+const player_1 = require("./player");
+function transformToAttributes(team) {
+    return {
+        team_id: team.id,
+        name: team.name,
+        short_name: team.shortName,
+        coach_id: team.coach.id,
+        country_id: team.country.id,
+        league_id: team.league.id
+    };
+}
+exports.transformFromTeam = transformToAttributes;
+function transformToObject(team) {
+    return new service_1.Team({
+        id: team.team_id,
+        name: team.name,
+        shortName: team.short_name,
+        country: team.country != null ? (0, country_1.transformToCountry)(team.country) : undefined,
+        coach: team.coach != null ? (0, coach_1.transformToCoach)(team.coach) : undefined,
+        roster: team.Players != null ? team.Players.map(player_1.transformToPlayer) : []
+    });
+}
+exports.transformToTeam = transformToObject;
+function transformToAPIObject(team) {
+    return {
+        id: team.team_id,
+        name: team.name,
+        shortName: team.short_name,
+        country: (0, country_1.transformToCountry)(team.country),
+        coach: (0, coach_1.transformToCoach)(team.coach),
+        roster: team.Players != null ? team.Players.map(player_1.transformToAPIPlayer) : []
+    };
+}
+exports.transformToAPITeam = transformToAPIObject;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToAPITrait = exports.transformToTrait = exports.transformFromTrait = void 0;
+const trait_1 = require("../../service/player/trait");
+const routing_1 = require("../../routing");
+function transformToType(trait) {
+    switch (trait.name) {
+        case 'Marksman':
+            return 'MARKSMAN';
+        case 'Master Mind':
+            return 'MASTER_MIND';
+        case 'Moving Wall':
+            return 'MOVING_WALL';
+        case 'Meteor Serve':
+            return 'METEOR_SERVE';
+        case 'Vigorous':
+            return 'VIGOROUS';
+        case 'Guardian':
+            return 'GUARDIAN';
+        default:
+            throw new Error('UNKNOWN_TRAIT');
+    }
+}
+exports.transformFromTrait = transformToType;
+function transformFromType(trait) {
+    return trait_1.Trait[trait];
+}
+exports.transformToTrait = transformFromType;
+function transformToEnum(trait) {
+    return routing_1.APITrait[trait];
+}
+exports.transformToAPITrait = transformToEnum;