volleyballsimtypes 0.0.75 → 0.0.77

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

@@ -1,36 +1,35 @@
-import { transformFromBlock, transformToAPIBlock, transformToBlock } from './block';
-import { transformFromCoach, transformToAPICoach, transformToCoach } from './coach';
-import { transformFromCountry, transformToCountry } from './country';
-import { transformFromCourtPosition, transformToCourtPosition } from './court-position';
-import { transformFromCourtTarget, transformToCourtTarget } from './court-target';
-import { transformFromEventType, transformToEventType } from './event-type';
-import { transformFromFormation, transformToFormation } from './formation';
-import { transformFromIteration, transformToIteration } from './iteration';
-import { transformFromDraft, transformToDraft } from './draft';
-import { transformFromDraftPick, transformToDraftPick } from './draft-pick';
-import { transformFromLeague, transformToAPILeague, transformToLeague } from './league';
-import { transformFromLiberoReplacement, transformToAPILiberoReplacement, transformToLiberoReplacement } from './libero-replacement';
-import { transformFromTournament, transformToAPITournament, transformToTournament } from './tournament';
-import { transformFromTournamentMatch, transformToAPITournamentMatch, transformToTournamentMatch, } from './tournament-match';
-import { transformFromStage, transformToStage } from './stage';
-import { transformFromMatch, transformToAPIMatch, transformToMatch } from './match';
-import { transformFromMatchSet, transformToAPIMatchSet, transformToMatchSet } from './match-set';
-import { transformFromMatchSetStats, transformToAPIMatchSetStats, transformToMatchSetStats } from './match-set-stats';
-import { transformFromPerformanceStats, transformToPerformanceStats } from './performance-stats';
-import { transformFromPlayer, transformToAPIPlayer, transformToPlayer } from './player';
-import { transformFromRally, transformToAPIRally, transformToRally } from './rally';
-import { transformFromPlayerPosition, transformToPlayerPosition } from './rally-position';
-import { transformFromReception, transformToAPIReception, transformToReception } from './reception';
-import { transformFromRole, transformToRole } from './role';
-import { transformFromScore, transformToAPIScore, transformToScore } from './score';
-import { transformFromSeason, transformToAPISeason, transformToSeason } from './season';
-import { transformFromSeasonMatch } from './season-match';
-import { transformFromPlayerTeam } from './player-team';
-import { transformFromMatchRating } from './match-rating';
-import { transformFromServe, transformToAPIServe, transformToServe } from './serve';
-import { transformFromSet, transformToAPISet, transformToSet } from './set';
-import { transformFromSpike, transformToAPISpike, transformToSpike } from './spike';
-import { transformFromSubstitution, transformToAPISubstitution, transformToSubstitution } from './substitution';
-import { transformFromTeam, transformToAPITeam, transformToTeam } from './team';
-import { transformFromTrait, transformToAPITrait, transformToTrait } from './trait';
-export { transformFromDraft, transformToDraft, transformFromDraftPick, transformToDraftPick, transformFromPlayerTeam, transformFromMatchRating, transformFromIteration, transformToIteration, transformFromTournament, transformFromSeasonMatch, transformToAPITournament, transformToTournament, transformFromTournamentMatch, transformToAPITournamentMatch, transformToTournamentMatch, transformFromBlock, transformToAPICoach, transformFromCoach, transformFromCountry, transformFromCourtPosition, transformFromCourtTarget, transformFromEventType, transformFromFormation, transformFromLeague, transformFromLiberoReplacement, transformFromMatch, transformFromMatchSet, transformFromMatchSetStats, transformFromPerformanceStats, transformFromPlayer, transformFromPlayerPosition, transformFromRally, transformFromReception, transformFromRole, transformToStage, transformFromStage, transformFromScore, transformFromSeason, transformFromServe, transformToAPILeague, transformFromSet, transformFromSpike, transformFromSubstitution, transformFromTeam, transformFromTrait, transformToAPIBlock, transformToAPILiberoReplacement, transformToAPIMatch, transformToAPIMatchSet, transformToAPIMatchSetStats, transformToAPIPlayer, transformToAPIRally, transformToAPIReception, transformToAPIScore, transformToAPISeason, transformToAPIServe, transformToAPISet, transformToAPISpike, transformToAPISubstitution, transformToAPITeam, transformToAPITrait, transformToBlock, transformToCoach, transformToCountry, transformToCourtPosition, transformToCourtTarget, transformToEventType, transformToFormation, transformToLeague, transformToLiberoReplacement, transformToMatch, transformToMatchSet, transformToMatchSetStats, transformToPerformanceStats, transformToPlayer, transformToPlayerPosition, transformToRally, transformToReception, transformToRole, transformToScore, transformToSeason, transformToServe, transformToSet, transformToSpike, transformToSubstitution, transformToTeam, transformToTrait };
+export * from './block';
+export * from './coach';
+export * from './country';
+export * from './court-position';
+export * from './court-target';
+export * from './event-type';
+export * from './formation';
+export * from './iteration';
+export * from './draft';
+export * from './draft-pick';
+export * from './league';
+export * from './libero-replacement';
+export * from './tournament';
+export * from './tournament-match';
+export * from './stage';
+export * from './match';
+export * from './match-set';
+export * from './match-set-stats';
+export * from './performance-stats';
+export * from './player';
+export * from './rally';
+export * from './rally-position';
+export * from './reception';
+export * from './role';
+export * from './score';
+export * from './season';
+export * from './season-match';
+export * from './player-team';
+export * from './match-rating';
+export * from './serve';
+export * from './set';
+export * from './spike';
+export * from './substitution';
+export * from './team';
+export * from './trait';

package/dist/esm/src/data/transformers/libero-replacement.js

@@ -1,17 +1,17 @@
-import { LiberoReplacement, LiberoReplacementType } from '../../service';
+import { LiberoReplacement, LiberoReplacementTypeEnum } from '../../service';
 import { transformFromEventType, transformToEventType, transformToPlayer } from '.';
 function transformToLiberoReplacementType(type) {
     switch (type) {
-        case LiberoReplacementType.LIBERO_IN:
+        case LiberoReplacementTypeEnum.LIBERO_IN:
             return 'LIBERO_IN';
-        case LiberoReplacementType.LIBERO_OUT:
+        case LiberoReplacementTypeEnum.LIBERO_OUT:
             return 'LIBERO_OUT';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromLiberoReplacementType(type) {
-    return LiberoReplacementType[type];
+    return LiberoReplacementTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
     return {

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

@@ -1,4 +1,4 @@
-import { EventType, Rally } from '../../service';
+import { EventTypeEnum, Rally } from '../../service';
 import { transformFromBlock, transformFromLiberoReplacement, transformFromPlayerPosition, transformFromReception, transformFromScore, transformFromServe, transformFromSet, transformFromSpike, transformFromSubstitution, transformToAPIBlock, transformToAPILiberoReplacement, transformToAPIReception, transformToAPIScore, transformToAPIServe, transformToAPISet, transformToAPISpike, transformToAPISubstitution, transformToBlock, transformToLiberoReplacement, transformToPlayerPosition, transformToReception, transformToScore, transformToServe, transformToSet, transformToSpike, transformToSubstitution, transformToTeam } from '.';
 function transformToAttributes(rally, setId) {
     const rallyPositions = [
@@ -22,21 +22,21 @@ function transformToAttributes(rally, setId) {
         order: rally.order,
         serving_team: rally.servingTeam.id,
         RallyPositions: rallyPositions,
-        LiberoReplacements: rally.events.filter(event => event.eventType === EventType.LIBERO_REPLACEMENT)
+        LiberoReplacements: rally.events.filter(event => event.eventType === EventTypeEnum.LIBERO_REPLACEMENT)
             .map(event => transformFromLiberoReplacement(event, rally.id)),
-        Substitutions: rally.events.filter(event => event.eventType === EventType.SUBSTITUTION)
+        Substitutions: rally.events.filter(event => event.eventType === EventTypeEnum.SUBSTITUTION)
             .map(event => transformFromSubstitution(event, rally.id)),
-        Serves: rally.events.filter(event => event.eventType === EventType.SERVE)
+        Serves: rally.events.filter(event => event.eventType === EventTypeEnum.SERVE)
             .map(event => transformFromServe(event, rally.id)),
-        Receptions: rally.events.filter(event => event.eventType === EventType.RECEPTION)
+        Receptions: rally.events.filter(event => event.eventType === EventTypeEnum.RECEPTION)
             .map(event => transformFromReception(event, rally.id)),
-        Sets: rally.events.filter(event => event.eventType === EventType.SET)
+        Sets: rally.events.filter(event => event.eventType === EventTypeEnum.SET)
             .map(event => transformFromSet(event, rally.id)),
-        Spikes: rally.events.filter(event => event.eventType === EventType.SPIKE)
+        Spikes: rally.events.filter(event => event.eventType === EventTypeEnum.SPIKE)
             .map(event => transformFromSpike(event, rally.id)),
-        Blocks: rally.events.filter(event => event.eventType === EventType.BLOCK)
+        Blocks: rally.events.filter(event => event.eventType === EventTypeEnum.BLOCK)
             .map(event => transformFromBlock(event, rally.id)),
-        Scores: rally.events.filter(event => event.eventType === EventType.SCORE)
+        Scores: rally.events.filter(event => event.eventType === EventTypeEnum.SCORE)
             .map(event => transformFromScore(event, rally.id))
     };
 }

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

@@ -1,40 +1,40 @@
-import { Reception, ReceptionFailure, ReceptionType } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { Reception, ReceptionFailureEnum, ReceptionTypeEnum } from '../../service';
+import { transformFromCourtTarget, transformFromEventType, transformFromTrait, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToReceptionFailure(failure) {
     switch (failure) {
-        case ReceptionFailure.NO_FAILURE:
+        case ReceptionFailureEnum.NO_FAILURE:
             return 'NO_FAILURE';
-        case ReceptionFailure.FAULT:
+        case ReceptionFailureEnum.FAULT:
             return 'FAULT';
-        case ReceptionFailure.MISS:
+        case ReceptionFailureEnum.MISS:
             return 'MISS';
-        case ReceptionFailure.OUT_OF_BOUNDS:
+        case ReceptionFailureEnum.OUT_OF_BOUNDS:
             return 'OUT_OF_BOUNDS';
-        case ReceptionFailure.BAD_PASS:
+        case ReceptionFailureEnum.BAD_PASS:
             return 'BAD_PASS';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromReceptionFailure(failure) {
-    return ReceptionFailure[failure];
+    return ReceptionFailureEnum[failure];
 }
 function transformToReceptionType(type) {
     switch (type) {
-        case ReceptionType.DIG:
+        case ReceptionTypeEnum.DIG:
             return 'DIG';
-        case ReceptionType.OVERHAND:
+        case ReceptionTypeEnum.OVERHAND:
             return 'OVERHAND';
-        case ReceptionType.ONE_HAND:
+        case ReceptionTypeEnum.ONE_HAND:
             return 'ONE_HAND';
-        case ReceptionType.OTHER_BODY_PART:
+        case ReceptionTypeEnum.OTHER_BODY_PART:
             return 'OTHER_BODY_PART';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromReceptionType(type) {
-    return ReceptionType[type];
+    return ReceptionTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
     return {
@@ -47,7 +47,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToReceptionFailure(event.failure),
         type: transformToReceptionType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        active_traits: event.activeTraits.map(transformFromTrait)
     };
 }
 function transformToObject(event) {
@@ -60,7 +61,8 @@ function transformToObject(event) {
         target: transformToCourtTarget(event.target),
         modifier: event.modifier,
         order: event.order,
-        score: event.score
+        score: event.score,
+        activeTraits: event.active_traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

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

@@ -1,42 +1,42 @@
-import { Serve, ServeFailure, ServeType } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { Serve, ServeFailureEnum, ServeTypeEnum } from '../../service';
+import { transformFromCourtTarget, transformFromEventType, transformFromTrait, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToServeFailure(failure) {
     switch (failure) {
-        case ServeFailure.NO_FAILURE:
+        case ServeFailureEnum.NO_FAILURE:
             return 'NO_FAILURE';
-        case ServeFailure.FAULT:
+        case ServeFailureEnum.FAULT:
             return 'FAULT';
-        case ServeFailure.MISS:
+        case ServeFailureEnum.MISS:
             return 'MISS';
-        case ServeFailure.OUT_OF_BOUNDS:
+        case ServeFailureEnum.OUT_OF_BOUNDS:
             return 'OUT_OF_BOUNDS';
-        case ServeFailure.NET:
+        case ServeFailureEnum.NET:
             return 'NET';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromServeFailure(failure) {
-    return ServeFailure[failure];
+    return ServeFailureEnum[failure];
 }
 function transformToServeType(type) {
     switch (type) {
-        case ServeType.UNDERHAND:
+        case ServeTypeEnum.UNDERHAND:
             return 'UNDERHAND';
-        case ServeType.OVERHAND_TOPSPIN:
+        case ServeTypeEnum.OVERHAND_TOPSPIN:
             return 'OVERHAND_TOPSPIN';
-        case ServeType.OVERHAND_FLOAT:
+        case ServeTypeEnum.OVERHAND_FLOAT:
             return 'OVERHAND_FLOAT';
-        case ServeType.JUMP_TOPSPIN:
+        case ServeTypeEnum.JUMP_TOPSPIN:
             return 'JUMP_TOPSPIN';
-        case ServeType.JUMP_FLOAT:
+        case ServeTypeEnum.JUMP_FLOAT:
             return 'JUMP_FLOAT';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromServeType(type) {
-    return ServeType[type];
+    return ServeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
     return {
@@ -49,7 +49,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToServeFailure(event.failure),
         type: transformToServeType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        active_traits: event.activeTraits.map(transformFromTrait)
     };
 }
 function transformToObject(serve) {
@@ -62,7 +63,8 @@ function transformToObject(serve) {
         target: transformToCourtTarget(serve.target),
         modifier: serve.modifier,
         order: serve.order,
-        score: serve.score
+        score: serve.score,
+        activeTraits: serve.active_traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

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

@@ -1,40 +1,40 @@
-import { Set, SetFailure, SetType } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { Set, SetFailureEnum, SetTypeEnum } from '../../service';
+import { transformFromCourtTarget, transformFromEventType, transformFromTrait, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToSetFailure(failure) {
     switch (failure) {
-        case SetFailure.NO_FAILURE:
+        case SetFailureEnum.NO_FAILURE:
             return 'NO_FAILURE';
-        case SetFailure.FAULT:
+        case SetFailureEnum.FAULT:
             return 'FAULT';
-        case SetFailure.MISS:
+        case SetFailureEnum.MISS:
             return 'MISS';
-        case SetFailure.OUT_OF_BOUNDS:
+        case SetFailureEnum.OUT_OF_BOUNDS:
             return 'OUT_OF_BOUNDS';
-        case SetFailure.BAD_PASS:
+        case SetFailureEnum.BAD_PASS:
             return 'BAD_PASS';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromSetFailure(failure) {
-    return SetFailure[failure];
+    return SetFailureEnum[failure];
 }
 function transformToSetType(type) {
     switch (type) {
-        case SetType.OVERHAND:
+        case SetTypeEnum.OVERHAND:
             return 'OVERHAND';
-        case SetType.UNDERHAND:
+        case SetTypeEnum.UNDERHAND:
             return 'UNDERHAND';
-        case SetType.SPIKE:
+        case SetTypeEnum.SPIKE:
             return 'SPIKE';
-        case SetType.DUMP:
+        case SetTypeEnum.DUMP:
             return 'DUMP';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromSetType(type) {
-    return SetType[type];
+    return SetTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
     return {
@@ -47,7 +47,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToSetFailure(event.failure),
         type: transformToSetType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        active_traits: event.activeTraits.map(transformFromTrait)
     };
 }
 function transformToObject(set) {
@@ -60,7 +61,8 @@ function transformToObject(set) {
         target: transformToCourtTarget(set.target),
         modifier: set.modifier,
         order: set.order,
-        score: set.score
+        score: set.score,
+        activeTraits: set.active_traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

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

@@ -1,44 +1,44 @@
-import { Spike, SpikeFailure, SpikeType } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
+import { transformFromCourtTarget, transformFromEventType, transformFromTrait, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToSpikeFailure(failure) {
     switch (failure) {
-        case SpikeFailure.NO_FAILURE:
+        case SpikeFailureEnum.NO_FAILURE:
             return 'NO_FAILURE';
-        case SpikeFailure.FAULT:
+        case SpikeFailureEnum.FAULT:
             return 'FAULT';
-        case SpikeFailure.MISS:
+        case SpikeFailureEnum.MISS:
             return 'MISS';
-        case SpikeFailure.OUT_OF_BOUNDS:
+        case SpikeFailureEnum.OUT_OF_BOUNDS:
             return 'OUT_OF_BOUNDS';
-        case SpikeFailure.NET:
+        case SpikeFailureEnum.NET:
             return 'NET';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromSpikeFailure(failure) {
-    return SpikeFailure[failure];
+    return SpikeFailureEnum[failure];
 }
 function transformToSpikeType(type) {
     switch (type) {
-        case SpikeType.CROSS_SHOT:
+        case SpikeTypeEnum.CROSS_SHOT:
             return 'CROSS_SHOT';
-        case SpikeType.LINE_SHOT:
+        case SpikeTypeEnum.LINE_SHOT:
             return 'LINE_SHOT';
-        case SpikeType.TOOL_SHOT:
+        case SpikeTypeEnum.TOOL_SHOT:
             return 'TOOL_SHOT';
-        case SpikeType.TIP:
+        case SpikeTypeEnum.TIP:
             return 'TIP';
-        case SpikeType.DOWN_BALL:
+        case SpikeTypeEnum.DOWN_BALL:
             return 'DOWN_BALL';
-        case SpikeType.OVERHAND:
+        case SpikeTypeEnum.OVERHAND:
             return 'OVERHAND';
         default:
             throw new Error('UNKNOWN_ROLE');
     }
 }
 function transformFromSpikeType(type) {
-    return SpikeType[type];
+    return SpikeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
     return {
@@ -51,7 +51,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToSpikeFailure(event.failure),
         type: transformToSpikeType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        active_traits: event.activeTraits.map(transformFromTrait)
     };
 }
 function transformToObject(spike) {
@@ -64,7 +65,8 @@ function transformToObject(spike) {
         target: transformToCourtTarget(spike.target),
         modifier: spike.modifier,
         order: spike.order,
-        score: spike.score
+        score: spike.score,
+        activeTraits: spike.active_traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

package/dist/esm/src/index.d.ts

@@ -1,6 +1,3 @@
-import { Block, BlockFailure as BlockFailureEnum, BlockType as BlockTypeEnum, Coach, Country, CourtPosition, CourtRow, CourtTarget as CourtTargetEnum, Draft, DraftPick, EventStat, EventType as EventTypeEnum, Formation, formatNumber, GeneralStat, generateModifier, getKeys, getRandomEnumValue, InPlayEvent, InPlayEventOpts, Iteration, League, LiberoReplacement, LiberoReplacementType as LiberoReplacementTypeEnum, Match, MatchRating, MatchSet, MatchSetState, MatchTeam, Name, PerformanceStats, Player, PlayerPosition, Rally, RallyEvent, RallyEventOpts, RallyState, randomNumber, Reception, ReceptionFailure as ReceptionFailureEnum, ReceptionType as ReceptionTypeEnum, Role, Score, Season, Serve, ServeFailure as ServeFailureEnum, ServeType as ServeTypeEnum, Set, SetFailure as SetFailureEnum, SetStatistics, SetType as SetTypeEnum, shuffle, Spike, SpikeFailure as SpikeFailureEnum, SpikeType as SpikeTypeEnum, Stage, Standing, Stat, SubPriority, Substitution, Team, Tournament, TournamentMatch, Trait, validateUUID } from './service';
-import { APIBlock, APICoach, APIEvent, APIInPlayEvent, APILeague, APILiberoReplacement, APIMatch, APIMatchSet, APIPlayer, APIRally, APIReception, APIScore, APISeason, APIServe, APISet, APISetStatistics, APISpike, APISubstitution, APITeam, APITournament, APITournamentMatch, APITrait } from './api';
-import type { BlockCreationAttributes, BlockFailure, BlockId, BlockPk, BlockType, CoachCreationAttributes, CoachId, CoachPk, CountryCreationAttributes, CountryId, CountryPk, CourtPositionType, CourtTarget, DraftCreationAttributes, DraftId, DraftPickCreationAttributes, DraftPickId, DraftPickPk, DraftPk, EventCreationAttributes, EventId, EventPk, EventType, FormationType, IterationCreationAttributes, IterationId, IterationPk, LeagueCreationAttributes, LeagueId, LeaguePk, LiberoReplacementCreationAttributes, LiberoReplacementId, LiberoReplacementPk, LiberoReplacementType, MatchCreationAttributes, MatchId, MatchPk, MatchSetCreationAttributes, MatchSetId, MatchSetPk, MatchSetStatsCreationAttributes, MatchSetStatsId, MatchSetStatsPk, PerformanceStatsCreationAttributes, PerformanceStatsId, PerformanceStatsPk, PlayerCreationAttributes, PlayerId, PlayerPk, PlayerTeamCreationAttributes, PlayerTeamId, PlayerTeamOptionalAttributes, PlayerTeamPk, RallyCreationAttributes, RallyId, RallyPk, RallyPositionCreationAttributes, RallyPositionId, RallyPositionPk, ReceptionCreationAttributes, ReceptionFailure, ReceptionId, ReceptionPk, ReceptionType, RoleType, ScoreCreationAttributes, ScoreId, ScorePk, SeasonCreationAttributes, SeasonId, SeasonMatchCreationAttributes, SeasonMatchId, SeasonMatchPk, SeasonPk, SeasonTeamsCreationAttributes, SeasonTeamsId, SeasonTeamsPk, ServeCreationAttributes, ServeFailure, ServeId, ServePk, ServeType, SetCreationAttributes, SetFailure, SetId, SetPk, SetType, Side, SpikeCreationAttributes, SpikeFailure, SpikeId, SpikePk, SpikeType, SubstitutionCreationAttributes, SubstitutionId, SubstitutionPk, TeamCreationAttributes, TeamId, TeamPk, TournamentCreationAttributes, TournamentId, TournamentMatchCreationAttributes, TournamentMatchId, TournamentMatchPk, TournamentPk, TournamentStage, TournamentTeamsCreationAttributes, TournamentTeamsId, TournamentTeamsPk, TraitType, UserCreationAttributes, UserId, UserOptionalAttributes, UserPk, UserRole, MatchRatingCreationAttributes, MatchRatingId, MatchRatingPk } from './data';
-import { BlockAttributes, BlockModel, BlockOptionalAttributes, CoachAttributes, CoachModel, CoachOptionalAttributes, CountryAttributes, CountryModel, DraftAttributes, DraftModel, DraftPickAttributes, DraftPickModel, EventAttributes, EventModel, FormationType as FormationOpts, initModels, IterationAttributes, IterationModel, LeagueAttributes, LeagueModel, LiberoReplacementAttributes, LiberoReplacementModel, MatchAttributes, MatchModel, MatchSetAttributes, MatchSetModel, MatchSetOptionalAttributes, MatchSetStatsAttributes, MatchSetStatsModel, MatchSetStatsOptionalAttributes, PerformanceStatsAttributes, PerformanceStatsModel, PerformanceStatsOptionalAttributes, PlayerAttributes, PlayerModel, PlayerTeamAttributes, PlayerTeamModel, RallyAttributes, RallyModel, RallyPositionAttributes, RallyPositionModel, ReceptionAttributes, ReceptionModel, ScoreAttributes, ScoreModel, SeasonAttributes, SeasonMatchAttributes, SeasonMatchModel, SeasonModel, SeasonTeamsAttributes, SeasonTeamsModel, ServeAttributes, ServeModel, SetAttributes, SetModel, SpikeAttributes, SpikeModel, SubstitutionAttributes, SubstitutionModel, TeamAttributes, TeamModel, TournamentAttributes, TournamentMatchAttributes, TournamentMatchModel, TournamentModel, TournamentOptionalAttributes, TournamentTeamsAttributes, TournamentTeamsModel, transformFromBlock, transformFromCoach, transformFromCountry, transformFromCourtPosition, transformFromCourtTarget, transformFromEventType, transformFromFormation, transformFromIteration, transformFromLeague, transformFromLiberoReplacement, transformFromMatch, transformFromMatchSet, transformFromMatchSetStats, transformFromPerformanceStats, transformFromPlayer, transformFromPlayerPosition, transformFromRally, transformFromReception, transformFromRole, transformFromScore, transformFromSeason, transformFromSeasonMatch, transformFromServe, transformFromSet, transformFromSpike, transformFromStage, transformFromSubstitution, transformFromTeam, transformFromTournament, transformFromTournamentMatch, transformFromTrait, transformToAPIBlock, transformToAPICoach, transformToAPILeague, transformToAPILiberoReplacement, transformToAPIMatch, transformToAPIMatchSet, transformToAPIMatchSetStats, transformToAPIPlayer, transformToAPIRally, transformToAPIReception, transformToAPIScore, transformToAPISeason, transformToAPIServe, transformToAPISet, transformToAPISpike, transformToAPISubstitution, transformToAPITeam, transformToAPITournament, transformToAPITournamentMatch, transformToAPITrait, transformToBlock, transformToCoach, transformToCountry, transformToCourtPosition, transformToCourtTarget, transformToEventType, transformToFormation, transformToIteration, transformToLeague, transformToLiberoReplacement, transformToMatch, transformToMatchSet, transformToMatchSetStats, transformToPerformanceStats, transformToPlayer, transformToPlayerPosition, transformToRally, transformToReception, transformToRole, transformToScore, transformToSeason, transformToServe, transformToSet, transformToSpike, transformToStage, transformToSubstitution, transformToTeam, transformToTournament, transformToTournamentMatch, transformToTrait, transformFromMatchRating, transformFromPlayerTeam, transformFromDraft, transformToDraft, transformFromDraftPick, transformToDraftPick, UserAttributes, UserModel, MatchRatingAttributes, MatchRatingModel } from './data';
-export { MatchRatingAttributes, MatchRatingModel, DraftModel, DraftAttributes, DraftPickModel, DraftPickAttributes, PlayerTeamAttributes, PlayerTeamModel, UserAttributes, UserModel, League, Standing, Season, Country, Coach, Role, SubPriority, GeneralStat, PerformanceStats, Formation, Stat, Block, EventTypeEnum, LiberoReplacement, MatchSet, Rally, RallyEvent, Reception, Score, Serve, Set, Spike, Substitution, BlockTypeEnum, LiberoReplacementTypeEnum, BlockFailureEnum, MatchSetState, RallyEventOpts, InPlayEventOpts, EventStat, Match, InPlayEvent, CourtRow, CourtPosition, CourtTargetEnum, formatNumber, generateModifier, getKeys, Draft, DraftPick, MatchTeam, Name, Player, RallyState, PlayerPosition, randomNumber, ReceptionTypeEnum, ServeFailureEnum, ServeTypeEnum, SetFailureEnum, SetStatistics, SetTypeEnum, ReceptionFailureEnum, SpikeFailureEnum, SpikeTypeEnum, Team, shuffle, Trait, getRandomEnumValue, validateUUID, APIBlock, APICoach, APIEvent, APILiberoReplacement, APIRally, APIReception, transformToAPILeague, transformFromMatchRating, transformFromPlayerTeam, transformFromDraft, transformToDraft, transformFromDraftPick, transformToDraftPick, APIScore, APIServe, APISet, APISpike, APISubstitution, APILeague, APIMatch, APIInPlayEvent, APIMatchSet, APIPlayer, APISeason, APITeam, APITrait, APITournament, APITournamentMatch, APISetStatistics, initModels, BlockModel, RallyModel, EventModel, MatchSetModel, PerformanceStatsModel, BlockAttributes, LiberoReplacementModel, MatchSetStatsModel, ReceptionModel, BlockOptionalAttributes, CoachAttributes, CountryModel, ScoreModel, CoachModel, RallyPositionModel, CoachOptionalAttributes, CountryAttributes, EventAttributes, LeagueAttributes, LeagueModel, LiberoReplacementAttributes, MatchAttributes, MatchModel, MatchSetAttributes, MatchSetOptionalAttributes, MatchSetStatsAttributes, MatchSetStatsOptionalAttributes, transformToAPICoach, PerformanceStatsAttributes, PerformanceStatsOptionalAttributes, PlayerAttributes, RallyAttributes, RallyPositionAttributes, ReceptionAttributes, ScoreAttributes, SeasonAttributes, SeasonTeamsAttributes, PlayerModel, SeasonTeamsModel, SeasonModel, ServeAttributes, ServeModel, SetAttributes, SetModel, SpikeAttributes, SpikeModel, SubstitutionAttributes, TeamAttributes, TeamModel, transformToStage, transformFromStage, SubstitutionModel, TournamentAttributes, TournamentModel, TournamentMatchAttributes, TournamentMatchModel, SeasonMatchModel, SeasonMatchAttributes, IterationAttributes, IterationModel, Iteration, transformFromIteration, transformToIteration, transformFromBlock, transformToAPIBlock, transformToBlock, transformFromCoach, transformFromCountry, transformFromRally, transformToAPIReception, transformToReception, transformToAPIScore, transformToScore, transformFromFormation, transformFromMatch, transformToAPISet, transformToSet, transformFromMatchSet, transformFromMatchSetStats, transformFromLeague, transformFromPlayer, transformFromPlayerPosition, transformToPlayerPosition, transformFromCourtPosition, transformFromCourtTarget, transformFromPerformanceStats, transformFromReception, transformFromRole, transformFromScore, transformFromSeason, transformFromEventType, transformFromServe, transformToAPIServe, transformToServe, transformFromSet, transformFromSpike, transformToAPISpike, transformToSpike, transformFromSubstitution, transformToAPISubstitution, transformToSubstitution, transformFromTeam, transformFromTrait, transformToAPIMatch, transformToAPIMatchSet, transformToAPIMatchSetStats, transformToAPIPlayer, transformToAPIRally, transformFromSeasonMatch, transformToAPISeason, transformToAPITeam, transformToAPITrait, transformFromLiberoReplacement, transformToAPILiberoReplacement, transformToLiberoReplacement, transformToCoach, transformToCountry, transformToEventType, transformToMatchSet, transformToCourtPosition, transformToCourtTarget, transformToFormation, transformToMatchSetStats, transformToPerformanceStats, transformToPlayer, transformToRally, transformToMatch, transformToSeason, transformToTeam, transformToTrait, transformToLeague, transformToRole, transformFromTournament, transformToAPITournament, transformToTournament, transformFromTournamentMatch, transformToAPITournamentMatch, transformToTournamentMatch, Stage, TournamentMatch, Tournament, FormationOpts, TournamentOptionalAttributes, TournamentTeamsModel, TournamentTeamsAttributes, MatchRating };
-export type { DraftId, DraftPk, DraftCreationAttributes, DraftPickCreationAttributes, DraftPickId, DraftPickPk, PlayerTeamCreationAttributes, PlayerTeamId, PlayerTeamOptionalAttributes, PlayerTeamPk, UserCreationAttributes, UserOptionalAttributes, UserRole, UserId, UserPk, TournamentId, TournamentPk, TournamentMatchId, TournamentMatchPk, TournamentStage, BlockId, BlockPk, CoachId, CoachPk, CountryId, CountryPk, SeasonMatchId, SeasonMatchPk, EventId, EventPk, LeagueId, LeaguePk, LiberoReplacementId, LiberoReplacementPk, MatchId, MatchPk, MatchSetId, MatchSetPk, MatchSetStatsId, MatchSetStatsPk, PerformanceStatsId, PerformanceStatsPk, PlayerId, PlayerPk, RallyId, RallyPk, RallyPositionId, RallyPositionPk, ReceptionId, ReceptionPk, RoleType, ScoreId, ScorePk, SeasonId, SeasonPk, SeasonTeamsId, SeasonTeamsPk, ServeId, ServePk, SetId, SetPk, SpikeId, SpikePk, SubstitutionId, SubstitutionPk, TeamId, TeamPk, TraitType, EventType, BlockFailure, BlockType, FormationType, ServeFailure, SpikeFailure, SpikeType, SetType, ReceptionFailure, SetFailure, ServeType, ReceptionType, CourtPositionType, Side, CourtTarget, LiberoReplacementType, TournamentTeamsId, TournamentTeamsPk, TournamentCreationAttributes, TournamentMatchCreationAttributes, BlockCreationAttributes, CoachCreationAttributes, CountryCreationAttributes, SeasonMatchCreationAttributes, EventCreationAttributes, LeagueCreationAttributes, LiberoReplacementCreationAttributes, MatchCreationAttributes, MatchSetCreationAttributes, MatchSetStatsCreationAttributes, PerformanceStatsCreationAttributes, PlayerCreationAttributes, RallyCreationAttributes, RallyPositionCreationAttributes, ReceptionCreationAttributes, ScoreCreationAttributes, SeasonCreationAttributes, SeasonTeamsCreationAttributes, ServeCreationAttributes, SetCreationAttributes, SpikeCreationAttributes, SubstitutionCreationAttributes, TeamCreationAttributes, TournamentTeamsCreationAttributes, IterationCreationAttributes, IterationId, IterationPk, MatchRatingCreationAttributes, MatchRatingId, MatchRatingPk };
+export * from './service';
+export * from './api';
+export * from './data';

package/dist/esm/src/index.js

@@ -1,4 +1,3 @@
-import { Block, BlockFailure as BlockFailureEnum, BlockType as BlockTypeEnum, Coach, Country, CourtPosition, CourtRow, CourtTarget as CourtTargetEnum, Draft, DraftPick, EventType as EventTypeEnum, Formation, formatNumber, GeneralStat, generateModifier, getKeys, getRandomEnumValue, InPlayEvent, Iteration, League, LiberoReplacement, LiberoReplacementType as LiberoReplacementTypeEnum, Match, MatchRating, MatchSet, MatchSetState, MatchTeam, PerformanceStats, Player, Rally, RallyEvent, RallyState, randomNumber, Reception, ReceptionFailure as ReceptionFailureEnum, ReceptionType as ReceptionTypeEnum, Role, Score, Season, Serve, ServeFailure as ServeFailureEnum, ServeType as ServeTypeEnum, Set, SetFailure as SetFailureEnum, SetType as SetTypeEnum, shuffle, Spike, SpikeFailure as SpikeFailureEnum, SpikeType as SpikeTypeEnum, Stage, Standing, Substitution, Team, Tournament, TournamentMatch, Trait, validateUUID } from './service';
-import { APITrait } from './api';
-import { BlockModel, CoachModel, CountryModel, DraftModel, DraftPickModel, EventModel, initModels, IterationModel, LeagueModel, LiberoReplacementModel, MatchModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, RallyModel, RallyPositionModel, ReceptionModel, ScoreModel, SeasonMatchModel, SeasonModel, SeasonTeamsModel, ServeModel, SetModel, SpikeModel, SubstitutionModel, TeamModel, TournamentMatchModel, TournamentModel, TournamentTeamsModel, transformFromBlock, transformFromCoach, transformFromCountry, transformFromCourtPosition, transformFromCourtTarget, transformFromEventType, transformFromFormation, transformFromIteration, transformFromLeague, transformFromLiberoReplacement, transformFromMatch, transformFromMatchSet, transformFromMatchSetStats, transformFromPerformanceStats, transformFromPlayer, transformFromPlayerPosition, transformFromRally, transformFromReception, transformFromRole, transformFromScore, transformFromSeason, transformFromSeasonMatch, transformFromServe, transformFromSet, transformFromSpike, transformFromStage, transformFromSubstitution, transformFromTeam, transformFromTournament, transformFromTournamentMatch, transformFromTrait, transformToAPIBlock, transformToAPICoach, transformToAPILeague, transformToAPILiberoReplacement, transformToAPIMatch, transformToAPIMatchSet, transformToAPIMatchSetStats, transformToAPIPlayer, transformToAPIRally, transformToAPIReception, transformToAPIScore, transformToAPISeason, transformToAPIServe, transformToAPISet, transformToAPISpike, transformToAPISubstitution, transformToAPITeam, transformToAPITournament, transformToAPITournamentMatch, transformToAPITrait, transformToBlock, transformToCoach, transformToCountry, transformToCourtPosition, transformToCourtTarget, transformToEventType, transformToFormation, transformToIteration, transformToLeague, transformToLiberoReplacement, transformToMatch, transformToMatchSet, transformToMatchSetStats, transformToPerformanceStats, transformToPlayer, transformToPlayerPosition, transformToRally, transformToReception, transformToRole, transformToScore, transformToSeason, transformToServe, transformToSet, transformToSpike, transformToStage, transformToSubstitution, transformToTeam, transformToTournament, transformToTournamentMatch, transformToTrait, transformFromMatchRating, transformFromPlayerTeam, transformFromDraft, transformToDraft, transformFromDraftPick, transformToDraftPick, UserModel, MatchRatingModel } from './data';
-export { MatchRatingModel, DraftModel, DraftPickModel, PlayerTeamModel, UserModel, League, Standing, Season, Country, Coach, Role, GeneralStat, PerformanceStats, Formation, Block, EventTypeEnum, LiberoReplacement, MatchSet, Rally, RallyEvent, Reception, Score, Serve, Set, Spike, Substitution, BlockTypeEnum, LiberoReplacementTypeEnum, BlockFailureEnum, MatchSetState, Match, InPlayEvent, CourtRow, CourtPosition, CourtTargetEnum, formatNumber, generateModifier, getKeys, Draft, DraftPick, MatchTeam, Player, RallyState, randomNumber, ReceptionTypeEnum, ServeFailureEnum, ServeTypeEnum, SetFailureEnum, SetTypeEnum, ReceptionFailureEnum, SpikeFailureEnum, SpikeTypeEnum, Team, shuffle, Trait, getRandomEnumValue, validateUUID, transformToAPILeague, transformFromMatchRating, transformFromPlayerTeam, transformFromDraft, transformToDraft, transformFromDraftPick, transformToDraftPick, APITrait, initModels, BlockModel, RallyModel, EventModel, MatchSetModel, PerformanceStatsModel, LiberoReplacementModel, MatchSetStatsModel, ReceptionModel, CountryModel, ScoreModel, CoachModel, RallyPositionModel, LeagueModel, MatchModel, transformToAPICoach, PlayerModel, SeasonTeamsModel, SeasonModel, ServeModel, SetModel, SpikeModel, TeamModel, transformToStage, transformFromStage, SubstitutionModel, TournamentModel, TournamentMatchModel, SeasonMatchModel, IterationModel, Iteration, transformFromIteration, transformToIteration, transformFromBlock, transformToAPIBlock, transformToBlock, transformFromCoach, transformFromCountry, transformFromRally, transformToAPIReception, transformToReception, transformToAPIScore, transformToScore, transformFromFormation, transformFromMatch, transformToAPISet, transformToSet, transformFromMatchSet, transformFromMatchSetStats, transformFromLeague, transformFromPlayer, transformFromPlayerPosition, transformToPlayerPosition, transformFromCourtPosition, transformFromCourtTarget, transformFromPerformanceStats, transformFromReception, transformFromRole, transformFromScore, transformFromSeason, transformFromEventType, transformFromServe, transformToAPIServe, transformToServe, transformFromSet, transformFromSpike, transformToAPISpike, transformToSpike, transformFromSubstitution, transformToAPISubstitution, transformToSubstitution, transformFromTeam, transformFromTrait, transformToAPIMatch, transformToAPIMatchSet, transformToAPIMatchSetStats, transformToAPIPlayer, transformToAPIRally, transformFromSeasonMatch, transformToAPISeason, transformToAPITeam, transformToAPITrait, transformFromLiberoReplacement, transformToAPILiberoReplacement, transformToLiberoReplacement, transformToCoach, transformToCountry, transformToEventType, transformToMatchSet, transformToCourtPosition, transformToCourtTarget, transformToFormation, transformToMatchSetStats, transformToPerformanceStats, transformToPlayer, transformToRally, transformToMatch, transformToSeason, transformToTeam, transformToTrait, transformToLeague, transformToRole, transformFromTournament, transformToAPITournament, transformToTournament, transformFromTournamentMatch, transformToAPITournamentMatch, transformToTournamentMatch, Stage, TournamentMatch, Tournament, TournamentTeamsModel, MatchRating };
+export * from './service';
+export * from './api';
+export * from './data';

package/dist/esm/src/service/event/__stubs__/index.js

@@ -1,7 +1,7 @@
-import { Serve, ServeFailure, ServeType } from '../serve';
+import { Serve, ServeFailureEnum, ServeTypeEnum } from '../serve';
 import { player } from '../../player/__stubs__';
-import { CourtTarget } from '../../match';
-import { EventType } from '../rally-event';
+import { CourtTargetEnum } from '../../match';
+import { EventTypeEnum } from '../rally-event';
 import { Score } from '../score';
 import { team } from '../../team/__stubs__';
 export const serve = new Serve({
@@ -9,16 +9,17 @@ export const serve = new Serve({
     order: 0,
     id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
     player: player,
-    target: CourtTarget.OPPONENT_RIGHT_BACK,
-    eventType: EventType.SERVE,
-    type: ServeType.JUMP_FLOAT,
-    failure: ServeFailure.NO_FAILURE,
-    modifier: 1
+    target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+    eventType: EventTypeEnum.SERVE,
+    type: ServeTypeEnum.JUMP_FLOAT,
+    failure: ServeFailureEnum.NO_FAILURE,
+    modifier: 1,
+    activeTraits: []
 });
 export const score = new Score({
     id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
     order: 0,
-    eventType: EventType.SCORE,
+    eventType: EventTypeEnum.SCORE,
     player,
     team
 });

package/dist/esm/src/service/event/block.d.ts

@@ -1,6 +1,6 @@
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
 import { Player } from '../player';
-export declare enum BlockFailure {
+export declare enum BlockFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -8,22 +8,22 @@ export declare enum BlockFailure {
     WIPE = 4,
     TOOL = 5
 }
-export declare enum BlockType {
+export declare enum BlockTypeEnum {
     NO_BLOCKER = 0,
     SINGLE = 1,
     DOUBLE = 2,
     TRIPLE = 3
 }
 interface BlockOpts extends InPlayEventOpts {
-    readonly type: BlockType;
-    readonly failure: BlockFailure;
+    readonly type: BlockTypeEnum;
+    readonly failure: BlockFailureEnum;
     readonly blockers: Player[];
 }
 export declare class Block extends InPlayEvent {
-    readonly failure: BlockFailure;
-    readonly type: BlockType;
+    readonly failure: BlockFailureEnum;
+    readonly type: BlockTypeEnum;
     readonly blockers: Player[];
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers }: BlockOpts);
+    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
     static getScore(blockers: Player[], modifier: number): number;
 }
 export {};