volleyballsimtypes 0.0.82 → 0.0.84

package/dist/cjs/src/data/models/trait.d.ts

@@ -0,0 +1,70 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { EventId, EventModel, EventTraitId, EventTraitModel, PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
+export interface TraitAttributes {
+    trait_id: string;
+    name: string;
+    modifier: number;
+    chance: number;
+    threshold: number;
+    weight: number;
+    general_stat: GeneralStatType;
+}
+export type TraitPk = 'trait_id';
+export type TraitId = TraitModel[TraitPk];
+export type TraitCreationAttributes = TraitAttributes;
+export type GeneralStatType = 'Attack' | 'Defense' | 'Physical' | 'Serve';
+export declare class TraitModel extends Model<TraitAttributes, TraitCreationAttributes> implements TraitAttributes {
+    trait_id: string;
+    name: string;
+    modifier: number;
+    chance: number;
+    threshold: number;
+    weight: number;
+    general_stat: GeneralStatType;
+    Events: EventModel[];
+    getEvents: Sequelize.BelongsToManyGetAssociationsMixin<EventModel>;
+    setEvents: Sequelize.BelongsToManySetAssociationsMixin<EventModel, EventId>;
+    addEvent: Sequelize.BelongsToManyAddAssociationMixin<EventModel, EventId>;
+    addEvents: Sequelize.BelongsToManyAddAssociationsMixin<EventModel, EventId>;
+    createEvent: Sequelize.BelongsToManyCreateAssociationMixin<EventModel>;
+    removeEvent: Sequelize.BelongsToManyRemoveAssociationMixin<EventModel, EventId>;
+    removeEvents: Sequelize.BelongsToManyRemoveAssociationsMixin<EventModel, EventId>;
+    hasEvent: Sequelize.BelongsToManyHasAssociationMixin<EventModel, EventId>;
+    hasEvents: Sequelize.BelongsToManyHasAssociationsMixin<EventModel, EventId>;
+    countEvents: Sequelize.BelongsToManyCountAssociationsMixin;
+    EventTraits: EventTraitModel[];
+    getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
+    setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
+    addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;
+    addEventTraits: Sequelize.HasManyAddAssociationsMixin<EventTraitModel, EventTraitId>;
+    createEventTrait: Sequelize.HasManyCreateAssociationMixin<EventTraitModel>;
+    removeEventTrait: Sequelize.HasManyRemoveAssociationMixin<EventTraitModel, EventTraitId>;
+    removeEventTraits: Sequelize.HasManyRemoveAssociationsMixin<EventTraitModel, EventTraitId>;
+    hasEventTrait: Sequelize.HasManyHasAssociationMixin<EventTraitModel, EventTraitId>;
+    hasEventTraits: Sequelize.HasManyHasAssociationsMixin<EventTraitModel, EventTraitId>;
+    countEventTraits: Sequelize.HasManyCountAssociationsMixin;
+    Players: PlayerModel[];
+    getPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
+    setPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
+    removePlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removePlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
+    PlayerTraits: PlayerTraitModel[];
+    getPlayerTraits: Sequelize.HasManyGetAssociationsMixin<PlayerTraitModel>;
+    setPlayerTraits: Sequelize.HasManySetAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTrait: Sequelize.HasManyAddAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTraits: Sequelize.HasManyAddAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    createPlayerTrait: Sequelize.HasManyCreateAssociationMixin<PlayerTraitModel>;
+    removePlayerTrait: Sequelize.HasManyRemoveAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    removePlayerTraits: Sequelize.HasManyRemoveAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTrait: Sequelize.HasManyHasAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTraits: Sequelize.HasManyHasAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    countPlayerTraits: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TraitModel;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitModel = void 0;
+const sequelize_1 = require("sequelize");
+class TraitModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return TraitModel.init({
+            trait_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            modifier: {
+                type: sequelize_1.DataTypes.REAL,
+                allowNull: false
+            },
+            chance: {
+                type: sequelize_1.DataTypes.REAL,
+                allowNull: false
+            },
+            threshold: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            weight: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            general_stat: {
+                type: sequelize_1.DataTypes.ENUM('Attack', 'Defense', 'Physical', 'Serve'),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Trait',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'trait_pk',
+                    unique: true,
+                    fields: [{ name: 'trait_id' }]
+                }]
+        });
+    }
+}
+exports.TraitModel = TraitModel;

package/dist/cjs/src/data/models/user.d.ts

@@ -1,22 +1,22 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-export interface UserAttributes {
-    user_id: string;
-    username: string;
-    email: string;
-    password: string;
-    role: UserRole;
-}
-export type UserPk = 'user_id';
-export type UserId = UserModel[UserPk];
-export type UserOptionalAttributes = 'role';
-export type UserRole = 'ADMIN' | 'PLAYER';
-export type UserCreationAttributes = Optional<UserAttributes, UserOptionalAttributes>;
-export declare class UserModel extends Model<UserAttributes, UserCreationAttributes> implements UserAttributes {
-    user_id: string;
-    username: string;
-    email: string;
-    password: string;
-    role: UserRole;
-    static initModel(sequelize: Sequelize.Sequelize): typeof UserModel;
-}
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface UserAttributes {
+    user_id: string;
+    username: string;
+    email: string;
+    password: string;
+    role: UserRole;
+}
+export type UserPk = 'user_id';
+export type UserId = UserModel[UserPk];
+export type UserOptionalAttributes = 'role';
+export type UserRole = 'ADMIN' | 'PLAYER';
+export type UserCreationAttributes = Optional<UserAttributes, UserOptionalAttributes>;
+export declare class UserModel extends Model<UserAttributes, UserCreationAttributes> implements UserAttributes {
+    user_id: string;
+    username: string;
+    email: string;
+    password: string;
+    role: UserRole;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserModel;
+}

package/dist/cjs/src/data/models/user.js

@@ -1,57 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserModel = void 0;
-const sequelize_1 = require("sequelize");
-class UserModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return UserModel.init({
-            user_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            username: {
-                type: sequelize_1.DataTypes.STRING,
-                allowNull: false,
-                unique: 'User_pk2'
-            },
-            email: {
-                type: sequelize_1.DataTypes.STRING,
-                allowNull: false,
-                unique: 'User_pk3'
-            },
-            password: {
-                type: sequelize_1.DataTypes.STRING,
-                allowNull: false
-            },
-            role: {
-                type: sequelize_1.DataTypes.ENUM('ADMIN', 'PLAYER'),
-                allowNull: false,
-                defaultValue: 'PLAYER'
-            }
-        }, {
-            sequelize,
-            tableName: 'User',
-            schema: 'public',
-            timestamps: false,
-            indexes: [
-                {
-                    name: 'User_pk',
-                    unique: true,
-                    fields: [{ name: 'user_id' }]
-                },
-                {
-                    name: 'User_pk2',
-                    unique: true,
-                    fields: [{ name: 'username' }]
-                },
-                {
-                    name: 'User_pk3',
-                    unique: true,
-                    fields: [{ name: 'email' }]
-                }
-            ]
-        });
-    }
-}
-exports.UserModel = UserModel;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = void 0;
+const sequelize_1 = require("sequelize");
+class UserModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return UserModel.init({
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            username: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                unique: 'User_pk2'
+            },
+            email: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                unique: 'User_pk3'
+            },
+            password: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            role: {
+                type: sequelize_1.DataTypes.ENUM('ADMIN', 'PLAYER'),
+                allowNull: false,
+                defaultValue: 'PLAYER'
+            }
+        }, {
+            sequelize,
+            tableName: 'User',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'User_pk',
+                    unique: true,
+                    fields: [{ name: 'user_id' }]
+                },
+                {
+                    name: 'User_pk2',
+                    unique: true,
+                    fields: [{ name: 'username' }]
+                },
+                {
+                    name: 'User_pk3',
+                    unique: true,
+                    fields: [{ name: 'email' }]
+                }
+            ]
+        });
+    }
+}
+exports.UserModel = UserModel;

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

@@ -1,7 +1,7 @@
-import { Block } from '../../service';
-import { BlockAttributes, BlockModel } from '../models';
-import { APIBlock } from '../../api';
-declare function transformToAttributes(event: Block, rallyId: string): BlockAttributes;
-declare function transformToObject(model: BlockModel): Block;
-declare function transformToAPIObject(model: BlockModel): APIBlock;
-export { transformToObject as transformToBlock, transformToAPIObject as transformToAPIBlock, transformToAttributes as transformFromBlock };
+import { Block } from '../../service';
+import { BlockAttributes, BlockModel } from '../models';
+import { APIBlock } from '../../api';
+declare function transformToAttributes(event: Block, rallyId: string): BlockAttributes;
+declare function transformToObject(model: BlockModel): Block;
+declare function transformToAPIObject(model: BlockModel): APIBlock;
+export { transformToObject as transformToBlock, transformToAPIObject as transformToAPIBlock, transformToAttributes as transformFromBlock };

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

@@ -1,107 +1,106 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromBlock = exports.transformToAPIBlock = exports.transformToBlock = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-function transformToBlockFailure(failure) {
-    switch (failure) {
-        case service_1.BlockFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case service_1.BlockFailureEnum.FAULT:
-            return 'FAULT';
-        case service_1.BlockFailureEnum.MISS:
-            return 'MISS';
-        case service_1.BlockFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case service_1.BlockFailureEnum.WIPE:
-            return 'WIPE';
-        case service_1.BlockFailureEnum.TOOL:
-            return 'TOOL';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromBlockFailure(failure) {
-    return service_1.BlockFailureEnum[failure];
-}
-function transformToBlockType(type) {
-    switch (type) {
-        case service_1.BlockTypeEnum.NO_BLOCKER:
-            return 'NO_BLOCKER';
-        case service_1.BlockTypeEnum.SINGLE:
-            return 'SINGLE';
-        case service_1.BlockTypeEnum.DOUBLE:
-            return 'DOUBLE';
-        case service_1.BlockTypeEnum.TRIPLE:
-            return 'TRIPLE';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromBlockType(type) {
-    return service_1.BlockTypeEnum[type];
-}
-function transformToAttributes(event, rallyId) {
-    return {
-        event_id: event.id,
-        player_id: event.player.id,
-        rally_id: rallyId,
-        order: event.order,
-        modifier: event.modifier,
-        score: event.score,
-        target: (0, _1.transformFromCourtTarget)(event.target),
-        failure: transformToBlockFailure(event.failure),
-        type: transformToBlockType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType),
-        blocker_1: event.blockers[0]?.id,
-        blocker_2: event.blockers[1]?.id,
-        blocker_3: event.blockers[2]?.id,
-        active_traits: event.activeTraits.map(_1.transformFromTrait)
-    };
-}
-exports.transformFromBlock = transformToAttributes;
-function transformToObject(model) {
-    const block = new service_1.Block({
-        id: model.event_id,
-        eventType: (0, _1.transformToEventType)(model.event_type),
-        failure: transformFromBlockFailure(model.failure),
-        type: transformFromBlockType(model.type),
-        player: (0, _1.transformToPlayer)(model.player),
-        target: (0, _1.transformToCourtTarget)(model.target),
-        modifier: model.modifier,
-        order: model.order,
-        score: model.score,
-        blockers: [],
-        activeTraits: model.active_traits.map(_1.transformToTrait)
-    });
-    if (model.Blocker_1 != null)
-        block.blockers.push((0, _1.transformToPlayer)(model.Blocker_1));
-    if (model.Blocker_2 != null)
-        block.blockers.push((0, _1.transformToPlayer)(model.Blocker_2));
-    if (model.Blocker_3 != null)
-        block.blockers.push((0, _1.transformToPlayer)(model.Blocker_3));
-    return block;
-}
-exports.transformToBlock = transformToObject;
-function transformToAPIObject(model) {
-    const block = {
-        id: model.event_id,
-        eventType: (0, _1.transformToEventType)(model.event_type),
-        failure: transformFromBlockFailure(model.failure),
-        type: transformFromBlockType(model.type),
-        playerId: model.player_id,
-        target: (0, _1.transformToCourtTarget)(model.target),
-        modifier: model.modifier,
-        order: model.order,
-        score: model.score,
-        blockers: []
-    };
-    if (model.blocker_1 != null)
-        block.blockers.push(model.blocker_1);
-    if (model.blocker_2 != null)
-        block.blockers.push(model.blocker_2);
-    if (model.blocker_3 != null)
-        block.blockers.push(model.blocker_3);
-    return block;
-}
-exports.transformToAPIBlock = transformToAPIObject;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromBlock = exports.transformToAPIBlock = exports.transformToBlock = void 0;
+const service_1 = require("../../service");
+const _1 = require(".");
+function transformToBlockFailure(failure) {
+    switch (failure) {
+        case service_1.BlockFailureEnum.NO_FAILURE:
+            return 'NO_FAILURE';
+        case service_1.BlockFailureEnum.FAULT:
+            return 'FAULT';
+        case service_1.BlockFailureEnum.MISS:
+            return 'MISS';
+        case service_1.BlockFailureEnum.OUT_OF_BOUNDS:
+            return 'OUT_OF_BOUNDS';
+        case service_1.BlockFailureEnum.WIPE:
+            return 'WIPE';
+        case service_1.BlockFailureEnum.TOOL:
+            return 'TOOL';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromBlockFailure(failure) {
+    return service_1.BlockFailureEnum[failure];
+}
+function transformToBlockType(type) {
+    switch (type) {
+        case service_1.BlockTypeEnum.NO_BLOCKER:
+            return 'NO_BLOCKER';
+        case service_1.BlockTypeEnum.SINGLE:
+            return 'SINGLE';
+        case service_1.BlockTypeEnum.DOUBLE:
+            return 'DOUBLE';
+        case service_1.BlockTypeEnum.TRIPLE:
+            return 'TRIPLE';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromBlockType(type) {
+    return service_1.BlockTypeEnum[type];
+}
+function transformToAttributes(event, rallyId) {
+    return {
+        event_id: event.id,
+        player_id: event.player.id,
+        rally_id: rallyId,
+        order: event.order,
+        modifier: event.modifier,
+        score: event.score,
+        target: (0, _1.transformFromCourtTarget)(event.target),
+        failure: transformToBlockFailure(event.failure),
+        type: transformToBlockType(event.type),
+        event_type: (0, _1.transformFromEventType)(event.eventType),
+        blocker_1: event.blockers[0]?.id,
+        blocker_2: event.blockers[1]?.id,
+        blocker_3: event.blockers[2]?.id
+    };
+}
+exports.transformFromBlock = transformToAttributes;
+function transformToObject(model) {
+    const block = new service_1.Block({
+        id: model.event_id,
+        eventType: (0, _1.transformToEventType)(model.event_type),
+        failure: transformFromBlockFailure(model.failure),
+        type: transformFromBlockType(model.type),
+        player: (0, _1.transformToPlayer)(model.player),
+        target: (0, _1.transformToCourtTarget)(model.target),
+        modifier: model.modifier,
+        order: model.order,
+        score: model.score,
+        blockers: [],
+        activeTraits: []
+    });
+    if (model.Blocker_1 != null)
+        block.blockers.push((0, _1.transformToPlayer)(model.Blocker_1));
+    if (model.Blocker_2 != null)
+        block.blockers.push((0, _1.transformToPlayer)(model.Blocker_2));
+    if (model.Blocker_3 != null)
+        block.blockers.push((0, _1.transformToPlayer)(model.Blocker_3));
+    return block;
+}
+exports.transformToBlock = transformToObject;
+function transformToAPIObject(model) {
+    const block = {
+        id: model.event_id,
+        eventType: (0, _1.transformToEventType)(model.event_type),
+        failure: transformFromBlockFailure(model.failure),
+        type: transformFromBlockType(model.type),
+        playerId: model.player_id,
+        target: (0, _1.transformToCourtTarget)(model.target),
+        modifier: model.modifier,
+        order: model.order,
+        score: model.score,
+        blockers: []
+    };
+    if (model.blocker_1 != null)
+        block.blockers.push(model.blocker_1);
+    if (model.blocker_2 != null)
+        block.blockers.push(model.blocker_2);
+    if (model.blocker_3 != null)
+        block.blockers.push(model.blocker_3);
+    return block;
+}
+exports.transformToAPIBlock = transformToAPIObject;

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

@@ -1,7 +1,7 @@
-import { CoachAttributes, CoachModel } from '../models';
-import { Coach } from '../../service';
-import { APICoach } from '../../api';
-declare function transformToAttributes(coach: Coach): CoachAttributes;
-declare function transformToObject(model: CoachModel): Coach;
-declare function transformToAPIObject(model: CoachModel): APICoach;
-export { transformToObject as transformToCoach, transformToAPIObject as transformToAPICoach, transformToAttributes as transformFromCoach };
+import { CoachAttributes, CoachModel } from '../models';
+import { Coach } from '../../service';
+import { APICoach } from '../../api';
+declare function transformToAttributes(coach: Coach): CoachAttributes;
+declare function transformToObject(model: CoachModel): Coach;
+declare function transformToAPIObject(model: CoachModel): APICoach;
+export { transformToObject as transformToCoach, transformToAPIObject as transformToAPICoach, transformToAttributes as transformFromCoach };

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

@@ -1,40 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromCoach = exports.transformToAPICoach = exports.transformToCoach = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-function transformToAttributes(coach) {
-    return {
-        coach_id: coach.id,
-        country_id: coach.country.id,
-        first_name: coach.name.first,
-        last_name: coach.name.last,
-        substitution_tolerance: coach.substitutionTolerance,
-        formation: (0, _1.transformFromFormation)(coach.formation)
-    };
-}
-exports.transformFromCoach = transformToAttributes;
-function transformToObject(model) {
-    return new service_1.Coach({
-        id: model.coach_id,
-        name: {
-            first: model.first_name,
-            last: model.last_name
-        },
-        country: (0, _1.transformToCountry)(model.country),
-        substitutionTolerance: model.substitution_tolerance != null ? model.substitution_tolerance : undefined,
-        formation: (0, _1.transformToFormation)(model.formation)
-    });
-}
-exports.transformToCoach = transformToObject;
-function transformToAPIObject(model) {
-    return {
-        id: model.coach_id,
-        name: {
-            first: model.first_name,
-            last: model.last_name
-        },
-        country: (0, _1.transformToCountry)(model.country)
-    };
-}
-exports.transformToAPICoach = transformToAPIObject;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFromCoach = exports.transformToAPICoach = exports.transformToCoach = void 0;
+const service_1 = require("../../service");
+const _1 = require(".");
+function transformToAttributes(coach) {
+    return {
+        coach_id: coach.id,
+        country_id: coach.country.id,
+        first_name: coach.name.first,
+        last_name: coach.name.last,
+        substitution_tolerance: coach.substitutionTolerance,
+        formation: (0, _1.transformFromFormation)(coach.formation)
+    };
+}
+exports.transformFromCoach = transformToAttributes;
+function transformToObject(model) {
+    return new service_1.Coach({
+        id: model.coach_id,
+        name: {
+            first: model.first_name,
+            last: model.last_name
+        },
+        country: (0, _1.transformToCountry)(model.country),
+        substitutionTolerance: model.substitution_tolerance != null ? model.substitution_tolerance : undefined,
+        formation: (0, _1.transformToFormation)(model.formation)
+    });
+}
+exports.transformToCoach = transformToObject;
+function transformToAPIObject(model) {
+    return {
+        id: model.coach_id,
+        name: {
+            first: model.first_name,
+            last: model.last_name
+        },
+        country: (0, _1.transformToCountry)(model.country)
+    };
+}
+exports.transformToAPICoach = transformToAPIObject;

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

@@ -1,5 +1,5 @@
-import { Country } from '../../service';
-import { CountryAttributes, CountryModel } from '../models';
-declare function transformToAttributes(country: Country): CountryAttributes;
-declare function transformToObject(model: CountryModel): Country;
-export { transformToObject as transformToCountry, transformToAttributes as transformFromCountry };
+import { Country } from '../../service';
+import { CountryAttributes, CountryModel } from '../models';
+declare function transformToAttributes(country: Country): CountryAttributes;
+declare function transformToObject(model: CountryModel): Country;
+export { transformToObject as transformToCountry, transformToAttributes as transformFromCountry };