volleyballsimtypes 0.0.122 → 0.0.123

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

@@ -1,46 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class EventModel extends Model {
-    static initModel(sequelize) {
-        return EventModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Event',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Event_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

package/dist/esm/src/data/models/libero-replacement.d.ts

@@ -1,38 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface LiberoReplacementAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    type: LiberoReplacementType;
-    libero: string;
-    event_type: EventType;
-}
-export type LiberoReplacementPk = 'event_id';
-export type LiberoReplacementType = 'LIBERO_IN' | 'LIBERO_OUT';
-export type LiberoReplacementId = LiberoReplacementModel[LiberoReplacementPk];
-export type LiberoReplacementCreationAttributes = LiberoReplacementAttributes;
-export declare class LiberoReplacementModel extends Model<LiberoReplacementAttributes, LiberoReplacementCreationAttributes> implements LiberoReplacementAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    type: LiberoReplacementType;
-    libero: string;
-    event_type: EventType;
-    Libero: PlayerModel;
-    getLibero: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setLibero: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createLibero: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof LiberoReplacementModel;
-}

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

@@ -1,58 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class LiberoReplacementModel extends Model {
-    static initModel(sequelize) {
-        return LiberoReplacementModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            type: {
-                type: DataTypes.ENUM('LIBERO_IN', 'LIBERO_OUT'),
-                allowNull: false
-            },
-            libero: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'LiberoReplacement',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'LiberoReplacement_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

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

@@ -1,37 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface ReceptionAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    failure: ReceptionFailure;
-    type: ReceptionType;
-    target: CourtTarget;
-}
-export type ReceptionPk = 'event_id';
-export type ReceptionFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS';
-export type ReceptionType = 'DIG' | 'OVERHAND' | 'ONE_HAND' | 'OTHER_BODY_PART';
-export type ReceptionId = ReceptionModel[ReceptionPk];
-export type ReceptionCreationAttributes = ReceptionAttributes;
-export declare class ReceptionModel extends Model<ReceptionAttributes, ReceptionCreationAttributes> implements ReceptionAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    failure: ReceptionFailure;
-    type: ReceptionType;
-    target: CourtTarget;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof ReceptionModel;
-}

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

@@ -1,58 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class ReceptionModel extends Model {
-    static initModel(sequelize) {
-        return ReceptionModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            failure: {
-                type: DataTypes.ENUM('BAD_PASS', 'FAULT', 'MISS', 'NO_FAILURE', 'OUT_OF_BOUNDS'),
-                allowNull: false
-            },
-            type: {
-                type: DataTypes.ENUM('DIG', 'ONE_HAND', 'OTHER_BODY_PART', 'OVERHAND'),
-                allowNull: false
-            },
-            target: {
-                type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_LEFT_BACK', 'OPPONENT_LEFT_FRONT', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_RIGHT_BACK', 'OPPONENT_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_BACK', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_BACK', 'TEAM_RIGHT_FRONT'),
-                allowNull: false
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Reception',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Reception_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

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

@@ -1,37 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface ServeAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    failure: ServeFailure;
-    target: CourtTarget;
-    type: ServeType;
-}
-export type ServeFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'NET' | 'OUT_OF_BOUNDS';
-export type ServeType = 'UNDERHAND' | 'OVERHAND_TOPSPIN' | 'OVERHAND_FLOAT' | 'JUMP_TOPSPIN' | 'JUMP_FLOAT';
-export type ServePk = 'event_id';
-export type ServeId = ServeModel[ServePk];
-export type ServeCreationAttributes = ServeAttributes;
-export declare class ServeModel extends Model<ServeAttributes, ServeCreationAttributes> implements ServeAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    failure: ServeFailure;
-    target: CourtTarget;
-    type: ServeType;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof ServeModel;
-}

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

@@ -1,58 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class ServeModel extends Model {
-    static initModel(sequelize) {
-        return ServeModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            failure: {
-                type: DataTypes.ENUM('FAULT', 'MISS', 'NET', 'NO_FAILURE', 'OUT_OF_BOUNDS'),
-                allowNull: false
-            },
-            target: {
-                type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_LEFT_BACK', 'OPPONENT_LEFT_FRONT', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_RIGHT_BACK', 'OPPONENT_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_BACK', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_BACK', 'TEAM_RIGHT_FRONT'),
-                allowNull: false
-            },
-            type: {
-                type: DataTypes.ENUM('JUMP_FLOAT', 'JUMP_TOPSPIN', 'OVERHAND_FLOAT', 'OVERHAND_TOPSPIN', 'UNDERHAND'),
-                allowNull: false
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Serve',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Serve_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

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

@@ -1,37 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface SetAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    failure: SetFailure;
-    type: SetType;
-    target: CourtTarget;
-}
-export type SetFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS';
-export type SetType = 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP';
-export type SetPk = 'event_id';
-export type SetId = SetModel[SetPk];
-export type SetCreationAttributes = SetAttributes;
-export declare class SetModel extends Model<SetAttributes, SetCreationAttributes> implements SetAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    failure: SetFailure;
-    type: SetType;
-    target: CourtTarget;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof SetModel;
-}

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

@@ -1,58 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class SetModel extends Model {
-    static initModel(sequelize) {
-        return SetModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            failure: {
-                type: DataTypes.ENUM('BAD_PASS', 'FAULT', 'MISS', 'NO_FAILURE', 'OUT_OF_BOUNDS'),
-                allowNull: false
-            },
-            type: {
-                type: DataTypes.ENUM('DUMP', 'OVERHAND', 'SPIKE', 'UNDERHAND'),
-                allowNull: false
-            },
-            target: {
-                type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_LEFT_BACK', 'OPPONENT_LEFT_FRONT', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_RIGHT_BACK', 'OPPONENT_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_BACK', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_BACK', 'TEAM_RIGHT_FRONT'),
-                allowNull: false
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Set',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Set_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

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

@@ -1,37 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface SpikeAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    target: CourtTarget;
-    type: SpikeType;
-    failure: SpikeFailure;
-}
-export type SpikeType = 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND';
-export type SpikeFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET';
-export type SpikePk = 'event_id';
-export type SpikeId = SpikeModel[SpikePk];
-export type SpikeCreationAttributes = SpikeAttributes;
-export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttributes> implements SpikeAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    target: CourtTarget;
-    type: SpikeType;
-    failure: SpikeFailure;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof SpikeModel;
-}

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

@@ -1,58 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class SpikeModel extends Model {
-    static initModel(sequelize) {
-        return SpikeModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            target: {
-                type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_LEFT_BACK', 'OPPONENT_LEFT_FRONT', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_RIGHT_BACK', 'OPPONENT_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_BACK', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_BACK', 'TEAM_RIGHT_FRONT'),
-                allowNull: false
-            },
-            type: {
-                type: DataTypes.ENUM('CROSS_SHOT', 'DOWN_BALL', 'LINE_SHOT', 'OVERHAND', 'TIP', 'TOOL_SHOT'),
-                allowNull: false
-            },
-            failure: {
-                type: DataTypes.ENUM('FAULT', 'MISS', 'NET', 'NO_FAILURE', 'OUT_OF_BOUNDS'),
-                allowNull: false
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Spike',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Spike_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

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

@@ -1,35 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface SubstitutionAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    player_out: string;
-    event_type: EventType;
-}
-export type SubstitutionPk = 'event_id';
-export type SubstitutionId = SubstitutionModel[SubstitutionPk];
-export type SubstitutionCreationAttributes = SubstitutionAttributes;
-export declare class SubstitutionModel extends Model<SubstitutionAttributes, SubstitutionCreationAttributes> implements SubstitutionAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    player_out: string;
-    event_type: EventType;
-    playerOut: PlayerModel;
-    getPlayerOut: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayerOut: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayerOut: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof SubstitutionModel;
-}

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

@@ -1,54 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class SubstitutionModel extends Model {
-    static initModel(sequelize) {
-        return SubstitutionModel.init({
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            player_out: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            event_type: {
-                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Substitution',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Substitution_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}

package/dist/esm/src/data/transformers/court-target.d.ts

@@ -1,5 +0,0 @@
-import { CourtTargetEnum } from '../../service';
-import { CourtTarget as CourtTargetType } from '../models';
-declare function transformToType(target: CourtTargetEnum): CourtTargetType;
-declare function transformFromType(target: CourtTargetType): CourtTargetEnum;
-export { transformToType as transformFromCourtTarget, transformFromType as transformToCourtTarget };

package/dist/esm/src/data/transformers/court-target.js

@@ -1,37 +0,0 @@
-import { CourtTargetEnum } from '../../service';
-function transformToType(target) {
-    switch (target) {
-        case CourtTargetEnum.NO_TARGET:
-            return 'NO_TARGET';
-        case CourtTargetEnum.OPPONENT_RIGHT_BACK:
-            return 'OPPONENT_RIGHT_BACK';
-        case CourtTargetEnum.OPPONENT_MIDDLE_BACK:
-            return 'OPPONENT_MIDDLE_BACK';
-        case CourtTargetEnum.OPPONENT_LEFT_BACK:
-            return 'OPPONENT_LEFT_BACK';
-        case CourtTargetEnum.OPPONENT_RIGHT_FRONT:
-            return 'OPPONENT_RIGHT_FRONT';
-        case CourtTargetEnum.OPPONENT_MIDDLE_FRONT:
-            return 'OPPONENT_MIDDLE_FRONT';
-        case CourtTargetEnum.OPPONENT_LEFT_FRONT:
-            return 'OPPONENT_LEFT_FRONT';
-        case CourtTargetEnum.TEAM_RIGHT_BACK:
-            return 'TEAM_RIGHT_BACK';
-        case CourtTargetEnum.TEAM_MIDDLE_BACK:
-            return 'TEAM_MIDDLE_BACK';
-        case CourtTargetEnum.TEAM_LEFT_BACK:
-            return 'TEAM_LEFT_BACK';
-        case CourtTargetEnum.TEAM_RIGHT_FRONT:
-            return 'TEAM_RIGHT_FRONT';
-        case CourtTargetEnum.TEAM_MIDDLE_FRONT:
-            return 'TEAM_MIDDLE_FRONT';
-        case CourtTargetEnum.TEAM_LEFT_FRONT:
-            return 'TEAM_LEFT_FRONT';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromType(target) {
-    return CourtTargetEnum[target];
-}
-export { transformToType as transformFromCourtTarget, transformFromType as transformToCourtTarget };

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

@@ -1,5 +0,0 @@
-import { EventTypeEnum } from '../../service';
-import { EventType as eventType } from '../models';
-declare function transformToType(type: EventTypeEnum): eventType;
-declare function transformFromType(type: eventType): EventTypeEnum;
-export { transformToType as transformFromEventType, transformFromType as transformToEventType };