volleyballsimtypes 0.0.100 → 0.0.102

package/dist/esm/src/data/models/season-teams.d.ts

@@ -1,23 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { SeasonId, SeasonModel, TeamId, TeamModel } from '.';
-export interface SeasonTeamsAttributes {
-    season_id: string;
-    team_id: string;
-}
-export type SeasonTeamsPk = 'season_id' | 'team_id';
-export type SeasonTeamsId = SeasonTeamsModel[SeasonTeamsPk];
-export type SeasonTeamsCreationAttributes = SeasonTeamsAttributes;
-export declare class SeasonTeamsModel extends Model<SeasonTeamsAttributes, SeasonTeamsCreationAttributes> implements SeasonTeamsAttributes {
-    season_id: string;
-    team_id: string;
-    season: SeasonModel;
-    getSeason: Sequelize.BelongsToGetAssociationMixin<SeasonModel>;
-    setSeason: Sequelize.BelongsToSetAssociationMixin<SeasonModel, SeasonId>;
-    createSeason: Sequelize.BelongsToCreateAssociationMixin<SeasonModel>;
-    team: TeamModel;
-    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
-    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
-    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof SeasonTeamsModel;
-}

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

@@ -1,68 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { IterationId, LeagueAttributes, LeagueId, LeagueModel, SeasonMatchAttributes, SeasonTeamsAttributes, SeasonTeamsId, SeasonTeamsModel, TeamAttributes, TeamId, TeamModel } from '.';
-import { IterationModel, SeasonMatchId, SeasonMatchModel } from '.';
-export interface SeasonAttributes {
-    season_id: string;
-    iteration: number;
-    league_id: string;
-    seasonTeams?: TeamAttributes[];
-    SeasonMatches?: SeasonMatchAttributes[];
-    SeasonTeams?: SeasonTeamsAttributes[];
-    league?: LeagueAttributes;
-    champion?: string;
-}
-export type SeasonPk = 'season_id';
-export type SeasonId = SeasonModel[SeasonPk];
-export type SeasonCreationAttributes = SeasonAttributes;
-export declare class SeasonModel extends Model<SeasonAttributes, SeasonCreationAttributes> implements SeasonAttributes {
-    season_id: string;
-    iteration: number;
-    league_id: string;
-    seasonTeams: TeamModel[];
-    SeasonMatches: SeasonMatchModel[];
-    league: LeagueModel;
-    Iteration: IterationModel;
-    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
-    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
-    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
-    getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
-    setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
-    createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;
-    SeasonTeams: SeasonTeamsModel[];
-    getSeasonTeams: Sequelize.HasManyGetAssociationsMixin<SeasonTeamsModel>;
-    setSeasonTeams: Sequelize.HasManySetAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    addSeasonTeam: Sequelize.HasManyAddAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
-    addSeasonTeams: Sequelize.HasManyAddAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    createSeasonTeam: Sequelize.HasManyCreateAssociationMixin<SeasonTeamsModel>;
-    removeSeasonTeam: Sequelize.HasManyRemoveAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
-    removeSeasonTeams: Sequelize.HasManyRemoveAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    hasSeasonTeam: Sequelize.HasManyHasAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
-    hasSeasonTeams: Sequelize.HasManyHasAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    countSeasonTeams: Sequelize.HasManyCountAssociationsMixin;
-    getseasonTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
-    setseasonTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
-    addTeam_id_Team: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
-    addseasonTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
-    createTeam_id_Team: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
-    removeTeam_id_Team: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
-    removeseasonTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
-    hasTeam_id_Team: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
-    hasseasonTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
-    countseasonTeams: Sequelize.BelongsToManyCountAssociationsMixin;
-    getSeasonMatches: Sequelize.HasManyGetAssociationsMixin<SeasonMatchModel>;
-    setSeasonMatches: Sequelize.HasManySetAssociationsMixin<SeasonMatchModel, SeasonMatchId>;
-    addSeasonMatch: Sequelize.HasManyAddAssociationMixin<SeasonMatchModel, SeasonMatchId>;
-    addSeasonMatches: Sequelize.HasManyAddAssociationsMixin<SeasonMatchModel, SeasonMatchId>;
-    createSeasonMatch: Sequelize.HasManyCreateAssociationMixin<SeasonMatchModel>;
-    removeSeasonMatch: Sequelize.HasManyRemoveAssociationMixin<SeasonMatchModel, SeasonMatchId>;
-    removeSeasonMatches: Sequelize.HasManyRemoveAssociationsMixin<SeasonMatchModel, SeasonMatchId>;
-    hasSeasonMatch: Sequelize.HasManyHasAssociationMixin<SeasonMatchModel, SeasonMatchId>;
-    hasSeasonMatches: Sequelize.HasManyHasAssociationsMixin<SeasonMatchModel, SeasonMatchId>;
-    countSeasonMatches: Sequelize.HasManyCountAssociationsMixin;
-    Champion: TeamModel;
-    getChampion: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
-    setChampion: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
-    createChampion: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof SeasonModel;
-}

package/dist/esm/src/data/models/season.js

@@ -1,53 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class SeasonModel extends Model {
-    static initModel(sequelize) {
-        return SeasonModel.init({
-            season_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            iteration: {
-                type: DataTypes.INTEGER,
-                allowNull: false,
-                references: {
-                    model: 'Iteration',
-                    key: 'iteration'
-                }
-            },
-            league_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'League',
-                    key: 'league_id'
-                }
-            },
-            champion: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Team',
-                    key: 'team_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'Season',
-            schema: 'public',
-            timestamps: false,
-            indexes: [
-                {
-                    name: 'Season_pk',
-                    unique: true,
-                    fields: [{ name: 'season_id' }]
-                },
-                {
-                    name: 'Season_unique',
-                    unique: true,
-                    fields: [{ name: 'iteration' }]
-                }
-            ]
-        });
-    }
-}

package/dist/esm/src/data/models/tournament-match.d.ts

@@ -1,29 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { MatchAttributes, MatchId, MatchModel, TournamentId, TournamentModel } from '.';
-export interface TournamentMatchAttributes {
-    tournament_id: string;
-    match_id: string;
-    index: number;
-    stage: TournamentStage;
-    match?: MatchAttributes;
-}
-export type TournamentStage = 'ROUND_OF_8' | 'QUARTERFINALS' | 'SEMIFINALS' | 'FINAL';
-export type TournamentMatchPk = 'match_id';
-export type TournamentMatchId = TournamentMatchModel[TournamentMatchPk];
-export type TournamentMatchCreationAttributes = TournamentMatchAttributes;
-export declare class TournamentMatchModel extends Model<TournamentMatchAttributes, TournamentMatchCreationAttributes> implements TournamentMatchAttributes {
-    tournament_id: string;
-    match_id: string;
-    index: number;
-    stage: TournamentStage;
-    match: MatchModel;
-    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
-    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
-    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
-    tournament: TournamentModel;
-    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
-    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
-    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentMatchModel;
-}

package/dist/esm/src/data/models/tournament-teams.d.ts

@@ -1,23 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { TeamId, TeamModel, TournamentId, TournamentModel } from '.';
-export interface TournamentTeamsAttributes {
-    tournament_id: string;
-    team_id: string;
-}
-export type TournamentTeamsPk = 'tournament_id' | 'team_id';
-export type TournamentTeamsId = TournamentTeamsModel[TournamentTeamsPk];
-export type TournamentTeamsCreationAttributes = TournamentTeamsAttributes;
-export declare class TournamentTeamsModel extends Model<TournamentTeamsAttributes, TournamentTeamsCreationAttributes> implements TournamentTeamsAttributes {
-    tournament_id: string;
-    team_id: string;
-    tournament: TournamentModel;
-    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
-    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
-    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
-    team: TeamModel;
-    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
-    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
-    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentTeamsModel;
-}

package/dist/esm/src/data/models/tournament.d.ts

@@ -1,63 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import type { IterationId, TeamId, TeamModel, TournamentMatchAttributes, TournamentMatchId, TournamentMatchModel, TournamentTeamsAttributes, TournamentTeamsId } from '.';
-import { IterationModel, TeamAttributes, TournamentTeamsModel } from '.';
-export interface TournamentAttributes {
-    tournament_id: string;
-    iteration: number;
-    champion?: string;
-    TournamentMatches?: TournamentMatchAttributes[];
-    TournamentTeams?: TournamentTeamsAttributes[];
-    tournamentTeams?: TeamAttributes[];
-}
-export type TournamentPk = 'tournament_id';
-export type TournamentId = TournamentModel[TournamentPk];
-export type TournamentOptionalAttributes = 'champion';
-export type TournamentCreationAttributes = Optional<TournamentAttributes, TournamentOptionalAttributes>;
-export declare class TournamentModel extends Model<TournamentAttributes, TournamentCreationAttributes> implements TournamentAttributes {
-    tournament_id: string;
-    iteration: number;
-    champion?: string;
-    TournamentMatches: TournamentMatchModel[];
-    tournamentTeams: TeamModel[];
-    Iteration: IterationModel;
-    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
-    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
-    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
-    Champion: TeamModel;
-    getChampion: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
-    setChampion: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
-    createChampion: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
-    getTournamentMatches: Sequelize.HasManyGetAssociationsMixin<TournamentMatchModel>;
-    setTournamentMatches: Sequelize.HasManySetAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    addTournamentMatch: Sequelize.HasManyAddAssociationMixin<TournamentMatchModel, TournamentMatchId>;
-    addTournamentMatches: Sequelize.HasManyAddAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    createTournamentMatch: Sequelize.HasManyCreateAssociationMixin<TournamentMatchModel>;
-    removeTournamentMatch: Sequelize.HasManyRemoveAssociationMixin<TournamentMatchModel, TournamentMatchId>;
-    removeTournamentMatches: Sequelize.HasManyRemoveAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    hasTournamentMatch: Sequelize.HasManyHasAssociationMixin<TournamentMatchModel, TournamentMatchId>;
-    hasTournamentMatches: Sequelize.HasManyHasAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    countTournamentMatches: Sequelize.HasManyCountAssociationsMixin;
-    TournamentTeams: TournamentTeamsModel[];
-    getTournamentTeams: Sequelize.HasManyGetAssociationsMixin<TournamentTeamsModel>;
-    setTournamentTeams: Sequelize.HasManySetAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    addTournamentTeam: Sequelize.HasManyAddAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    addTournamentTeams: Sequelize.HasManyAddAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    createTournamentTeam: Sequelize.HasManyCreateAssociationMixin<TournamentTeamsModel>;
-    removeTournamentTeam: Sequelize.HasManyRemoveAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    removeTournamentTeams: Sequelize.HasManyRemoveAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    hasTournamentTeam: Sequelize.HasManyHasAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    hasTournamentTeams: Sequelize.HasManyHasAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    countTournamentTeams: Sequelize.HasManyCountAssociationsMixin;
-    gettournamentTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
-    settournamentTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
-    addTeam_id_Team: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
-    addtournamentTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
-    createTeam_id_Team: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
-    removeTeam_id_Team: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
-    removetournamentTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
-    hasTeam_id_Team: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
-    hastournamentTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
-    counttournamentTeams: Sequelize.BelongsToManyCountAssociationsMixin;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentModel;
-}

package/dist/esm/src/data/models/tournament.js

@@ -1,45 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class TournamentModel extends Model {
-    static initModel(sequelize) {
-        return TournamentModel.init({
-            tournament_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            iteration: {
-                type: DataTypes.INTEGER,
-                allowNull: false,
-                references: {
-                    model: 'Iteration',
-                    key: 'iteration'
-                }
-            },
-            champion: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Team',
-                    key: 'team_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'Tournament',
-            schema: 'public',
-            timestamps: false,
-            indexes: [
-                {
-                    name: 'Tournament_pk',
-                    unique: true,
-                    fields: [{ name: 'tournament_id' }]
-                },
-                {
-                    name: 'Tournament_unique',
-                    unique: true,
-                    fields: [{ name: 'iteration' }]
-                }
-            ]
-        });
-    }
-}

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

@@ -1,5 +0,0 @@
-import { PlayerPosition } from '../../service';
-import { RallyPositionAttributes, RallyPositionModel } from '../models';
-declare function transformToAttributes(playerPosition: PlayerPosition, side: 'Home' | 'Away', rallyId: string): RallyPositionAttributes;
-declare function transformToObject(model: RallyPositionModel): PlayerPosition;
-export { transformToObject as transformToPlayerPosition, transformToAttributes as transformFromPlayerPosition };

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

@@ -1,7 +0,0 @@
-import { Score } from '../../service';
-import { ScoreAttributes, ScoreModel } from '../models';
-import { APIScore } from '../../api';
-declare function transformToAttributes(event: Score, rallyId: string): ScoreAttributes;
-declare function transformToObject(event: ScoreModel): Score;
-declare function transformToAPIObject(event: ScoreModel): APIScore;
-export { transformToObject as transformToScore, transformToAPIObject as transformToAPIScore, transformToAttributes as transformFromScore };

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

@@ -1,31 +0,0 @@
-import { Score } from '../../service';
-import { transformFromEventType, transformToEventType, transformToPlayer, transformToTeam } from '.';
-function transformToAttributes(event, rallyId) {
-    return {
-        player_id: event.player.id,
-        event_id: event.id,
-        order: event.order,
-        event_type: transformFromEventType(event.eventType),
-        rally_id: rallyId,
-        team_id: event.team.id
-    };
-}
-function transformToObject(event) {
-    return new Score({
-        id: event.event_id,
-        player: transformToPlayer(event.player),
-        order: event.order,
-        eventType: transformToEventType(event.event_type),
-        team: transformToTeam(event.team)
-    });
-}
-function transformToAPIObject(event) {
-    return {
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        playerId: event.player_id,
-        order: event.order,
-        teamId: event.team_id
-    };
-}
-export { transformToObject as transformToScore, transformToAPIObject as transformToAPIScore, transformToAttributes as transformFromScore };

package/dist/esm/src/service/coach/__stubs__/index.d.ts

@@ -1,3 +0,0 @@
-import { Coach } from '../coach';
-export declare const coaches: Coach[];
-export declare const coach: Coach;

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

@@ -1,43 +0,0 @@
-import { Coach } from '../coach';
-import { Formation } from '../formation';
-import { countries, country } from '../../country/__stubs__';
-export const coaches = [
-    new Coach({
-        name: { first: 'Jameson', last: 'Richardson' },
-        id: '8cd3a3fb-2034-487c-a041-fb06de0e374b',
-        country: countries[0],
-        formation: Formation['4-2'],
-        substitutionTolerance: 5
-    }),
-    new Coach({
-        id: '1be93fd6-62c4-4434-aaa0-730212ab72d7',
-        name: { first: 'Hunter', last: 'Rivera' },
-        country: countries[1],
-        formation: Formation['5-1'],
-        substitutionTolerance: 5
-    }),
-    new Coach({
-        id: 'a96b6732-2a71-451e-8973-c264446c594d',
-        name: {
-            first: 'Jonathan',
-            last: 'Jenkins'
-        },
-        country: countries[2],
-        formation: Formation['5-1'],
-        substitutionTolerance: 5
-    }),
-    new Coach({
-        id: '34086150-9692-4371-a5a4-0349170339e7',
-        name: { first: 'Noah', last: 'Adams' },
-        country: countries[3],
-        formation: Formation['6-2'],
-        substitutionTolerance: 5
-    })
-];
-export const coach = new Coach({
-    id: '1ad40ceb-b5ad-4e20-953c-3c1f050ac61d',
-    formation: Formation['6-2'],
-    name: { first: 'Julio', last: 'Velasco' },
-    country,
-    substitutionTolerance: 5
-});

package/dist/esm/src/service/coach/coach.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/service/coach/coach.test.js

@@ -1,9 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { coach } from './__stubs__';
-describe('Coach Test Module', () => {
-    test('Should instantiate object properly', () => {
-        expect(coach.id).toEqual('1ad40ceb-b5ad-4e20-953c-3c1f050ac61d');
-        expect(coach.name.first).toEqual('Julio');
-        expect(coach.name.last).toEqual('Velasco');
-    });
-});

package/dist/esm/src/service/coach/formation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/service/coach/formation.test.js

@@ -1,8 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-describe('Formation Test Module', () => {
-    // getFormation Tests
-    test('Should return supported formations', () => {
-        // TODO
-        expect(1).toBe(1);
-    });
-});

package/dist/esm/src/service/country/__stubs__/index.d.ts

@@ -1,3 +0,0 @@
-import { Country } from '../country';
-export declare const countries: Country[];
-export declare const country: Country;

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

@@ -1,12 +0,0 @@
-import { Country } from '../country';
-export const countries = [
-    new Country({ id: '53e01e62-fcc1-43fb-a38d-105cc7afb9ad', name: 'Republica de Zamunda', short: 'ZAM' }),
-    new Country({ id: 'acfef762-200a-40b8-b9a8-51bd1547ead9', name: 'Nocturna', short: 'NOC' }),
-    new Country({ id: '9e127575-e881-414e-b662-7a0f24caf227', name: 'Azura', short: 'AZU' }),
-    new Country({ id: '95eb288c-e01c-4593-8034-27c427e90823', name: 'Bantuland', short: 'BAN' })
-];
-export const country = new Country({
-    id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-    name: 'Argentina',
-    short: 'ARG'
-});

package/dist/esm/src/service/country/country.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/service/country/country.test.js

@@ -1,9 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { country } from './__stubs__';
-describe('Country Test Module', () => {
-    test('Should instantiate object properly', () => {
-        expect(country.id).toEqual('622c36dc-f2d2-44b3-a744-667ea53218b7');
-        expect(country.name).toEqual('Argentina');
-        expect(country.short).toEqual('ARG');
-    });
-});

package/dist/esm/src/service/event/__stubs__/index.d.ts

@@ -1,4 +0,0 @@
-import { Serve } from '../serve';
-import { Score } from '../score';
-export declare const serve: Serve;
-export declare const score: Score;

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

@@ -1,25 +0,0 @@
-import { Serve, ServeFailureEnum, ServeTypeEnum } from '../serve';
-import { player } from '../../player/__stubs__';
-import { CourtTargetEnum } from '../../match';
-import { EventTypeEnum } from '../rally-event';
-import { Score } from '../score';
-import { team } from '../../team/__stubs__';
-export const serve = new Serve({
-    score: 50,
-    order: 0,
-    id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
-    player: player,
-    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: EventTypeEnum.SCORE,
-    player,
-    team
-});

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

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/service/event/block.test.js

@@ -1,101 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Block, BlockFailureEnum, BlockTypeEnum } from './block';
-import { player } from '../player/__stubs__';
-import { CourtTargetEnum } from '../match';
-import { EventTypeEnum } from './rally-event';
-import { v4 as uuidv4 } from 'uuid';
-describe('Block Test Module', () => {
-    let none;
-    let block;
-    let double;
-    let triple;
-    let failed;
-    beforeEach(() => {
-        none = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.NO_BLOCKER,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [],
-            score: Block.getScore([], 1, []),
-            activeTraits: []
-        });
-        block = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.SINGLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player],
-            score: Block.getScore([player], 1, []),
-            activeTraits: []
-        });
-        double = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.DOUBLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player, player],
-            score: Block.getScore([player, player], 1, []),
-            activeTraits: []
-        });
-        triple = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.TRIPLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player, player, player],
-            score: Block.getScore([player, player, player], 1, []),
-            activeTraits: []
-        });
-        failed = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.NO_TARGET,
-            failure: BlockFailureEnum.FAULT,
-            type: BlockTypeEnum.TRIPLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player],
-            score: Block.getScore([player], 1, []),
-            activeTraits: []
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(block.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
-        expect(block.type).toBe(BlockTypeEnum.SINGLE);
-        expect(block.eventType).toBe(EventTypeEnum.BLOCK);
-        expect(block.player.id).toBe(player.id);
-        expect(block.failure).toBe(BlockFailureEnum.NO_FAILURE);
-        expect(failed.failure).toBe(BlockFailureEnum.FAULT);
-        expect(block.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Block types', () => {
-        expect(none.score).toBe(0);
-        expect(block.score).toBe(7);
-        expect(double.score).toBe(8.4);
-        expect(triple.score).toBe(9.799999999999999);
-        expect(failed.score).toBe(7);
-    });
-    test('Should throw Error when getting score with invalid amount of blockers', () => {
-        function score() { Block.getScore([player, player, player, player, player], 1, []); }
-        expect(score).toThrow(/^UNKNOWN_TYPE$/);
-    });
-});

package/dist/esm/src/service/event/libero-replacement.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/service/event/libero-replacement.test.js

@@ -1,34 +0,0 @@
-import { beforeEach, describe, expect, test } from '@jest/globals';
-import { EventTypeEnum } from './rally-event';
-import { players } from '../player/__stubs__';
-import { LiberoReplacement, LiberoReplacementTypeEnum } from './libero-replacement';
-import { v4 as uuidv4 } from 'uuid';
-describe('LiberoReplacement Test Module', () => {
-    let _in;
-    let _out;
-    beforeEach(() => {
-        _in = new LiberoReplacement({
-            id: uuidv4(),
-            order: 1,
-            player: players[0],
-            libero: players[1],
-            type: LiberoReplacementTypeEnum.LIBERO_IN,
-            eventType: EventTypeEnum.LIBERO_REPLACEMENT
-        });
-        _out = new LiberoReplacement({
-            id: uuidv4(),
-            order: 1,
-            player: players[0],
-            libero: players[1],
-            type: LiberoReplacementTypeEnum.LIBERO_OUT,
-            eventType: EventTypeEnum.LIBERO_REPLACEMENT
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(_in.libero.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
-        expect(_in.player.id).toBe('622c36dc-f2d2-44b3-a744-667ea53218b7');
-        expect(_in.type).toBe(LiberoReplacementTypeEnum.LIBERO_IN);
-        expect(_out.type).toBe(LiberoReplacementTypeEnum.LIBERO_OUT);
-        expect(_in.eventType).toBe(EventTypeEnum.LIBERO_REPLACEMENT);
-    });
-});

package/dist/esm/src/service/event/reception.test.d.ts

@@ -1 +0,0 @@
-export {};