volleyballsimtypes 0.0.120 → 0.0.121

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

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

package/dist/cjs/src/service/event/block.js

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Block = exports.BlockTypeEnum = exports.BlockFailureEnum = void 0;
-const in_play_event_1 = require("./in-play-event");
-const player_1 = require("../player");
-var BlockFailureEnum;
-(function (BlockFailureEnum) {
-    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    BlockFailureEnum[BlockFailureEnum["FAULT"] = 1] = "FAULT";
-    BlockFailureEnum[BlockFailureEnum["MISS"] = 2] = "MISS";
-    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
-    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
-})(BlockFailureEnum = exports.BlockFailureEnum || (exports.BlockFailureEnum = {}));
-var BlockTypeEnum;
-(function (BlockTypeEnum) {
-    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
-    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
-    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
-    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
-})(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
-class Block extends in_play_event_1.InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ id, order, score, player, target, modifier, eventType, activeTraits });
-        this.type = type;
-        this.failure = failure;
-        this.blockers = blockers;
-    }
-    static getScore(blockers, modifier, activeTraits) {
-        const type = blockers.length;
-        if (blockers.length > 3)
-            throw new Error('UNKNOWN_TYPE');
-        let bmod;
-        switch (type) {
-            case BlockTypeEnum.NO_BLOCKER:
-                return 0;
-            case BlockTypeEnum.SINGLE:
-                bmod = 1;
-                break;
-            case BlockTypeEnum.DOUBLE:
-                bmod = 1.2;
-                break;
-            case BlockTypeEnum.TRIPLE:
-                bmod = 1.4;
-                break;
-            default:
-                throw new Error('UNKNOWN_TYPE');
-        }
-        const total = blockers.reduce((score, player) => {
-            return score + Block.calculateScore(player.stats, 'BLOCK', BlockTypeEnum[type]);
-        }, 0);
-        const avg = total / blockers.length;
-        let score = avg * bmod * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.MOVING_WALL: {
-                    score *= player_1.Trait.MOVING_WALL.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-}
-exports.Block = Block;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = exports.BlockTypeEnum = exports.BlockFailureEnum = void 0;
+const in_play_event_1 = require("./in-play-event");
+const player_1 = require("../player");
+var BlockFailureEnum;
+(function (BlockFailureEnum) {
+    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    BlockFailureEnum[BlockFailureEnum["FAULT"] = 1] = "FAULT";
+    BlockFailureEnum[BlockFailureEnum["MISS"] = 2] = "MISS";
+    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
+    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
+})(BlockFailureEnum = exports.BlockFailureEnum || (exports.BlockFailureEnum = {}));
+var BlockTypeEnum;
+(function (BlockTypeEnum) {
+    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
+    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
+    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
+    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
+})(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
+class Block extends in_play_event_1.InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ id, order, score, player, target, modifier, eventType, activeTraits });
+        this.type = type;
+        this.failure = failure;
+        this.blockers = blockers;
+    }
+    static getScore(blockers, modifier, activeTraits) {
+        const type = blockers.length;
+        if (blockers.length > 3)
+            throw new Error('UNKNOWN_TYPE');
+        let bmod;
+        switch (type) {
+            case BlockTypeEnum.NO_BLOCKER:
+                return 0;
+            case BlockTypeEnum.SINGLE:
+                bmod = 1;
+                break;
+            case BlockTypeEnum.DOUBLE:
+                bmod = 1.2;
+                break;
+            case BlockTypeEnum.TRIPLE:
+                bmod = 1.4;
+                break;
+            default:
+                throw new Error('UNKNOWN_TYPE');
+        }
+        const total = blockers.reduce((score, player) => {
+            return score + Block.calculateScore(player.stats, 'BLOCK', BlockTypeEnum[type]);
+        }, 0);
+        const avg = total / blockers.length;
+        let score = avg * bmod * modifier;
+        for (const trait of activeTraits) {
+            switch (true) {
+                case trait === player_1.Trait.MOVING_WALL: {
+                    score *= player_1.Trait.MOVING_WALL.modifier;
+                    break;
+                }
+            }
+        }
+        return score;
+    }
+}
+exports.Block = Block;

package/dist/cjs/src/service/event/in-play-event.d.ts

@@ -1,19 +1,19 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { CourtTargetEnum } from '../match';
-import { PerformanceStats, Trait } from '../player';
-export interface InPlayEventOpts extends RallyEventOpts {
-    readonly target: CourtTargetEnum;
-    readonly modifier: number;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-}
-export declare abstract class InPlayEvent extends RallyEvent {
-    abstract failure: number;
-    abstract type: number;
-    readonly target: CourtTargetEnum;
-    readonly modifier: number;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
-    protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
-}
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { CourtTargetEnum } from '../match';
+import { PerformanceStats, Trait } from '../player';
+export interface InPlayEventOpts extends RallyEventOpts {
+    readonly target: CourtTargetEnum;
+    readonly modifier: number;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+}
+export declare abstract class InPlayEvent extends RallyEvent {
+    abstract failure: number;
+    abstract type: number;
+    readonly target: CourtTargetEnum;
+    readonly modifier: number;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
+}

package/dist/cjs/src/service/event/in-play-event.js

@@ -1,27 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InPlayEvent = void 0;
-const rally_event_1 = require("./rally-event");
-const event_formula_json_1 = __importDefault(require("../../../data/event.formula.json"));
-const utils_1 = require("../utils");
-class InPlayEvent extends rally_event_1.RallyEvent {
-    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ id, order, player, eventType });
-        this.target = target;
-        this.score = score;
-        this.modifier = modifier;
-        this.activeTraits = activeTraits;
-    }
-    static calculateScore(stats, eventType, type) {
-        const weight = event_formula_json_1.default[eventType][type];
-        const penalty = weight.penalty ?? 0;
-        const score = (0, utils_1.getKeys)(weight).reduce((score, key) => {
-            return score + (key === 'penalty' ? 0 : stats[key] * weight[key]);
-        }, 0);
-        return Math.round(score * (1 - penalty));
-    }
-}
-exports.InPlayEvent = InPlayEvent;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InPlayEvent = void 0;
+const rally_event_1 = require("./rally-event");
+const event_formula_json_1 = __importDefault(require("../../../data/event.formula.json"));
+const utils_1 = require("../utils");
+class InPlayEvent extends rally_event_1.RallyEvent {
+    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
+        super({ id, order, player, eventType });
+        this.target = target;
+        this.score = score;
+        this.modifier = modifier;
+        this.activeTraits = activeTraits;
+    }
+    static calculateScore(stats, eventType, type) {
+        const weight = event_formula_json_1.default[eventType][type];
+        const penalty = weight.penalty ?? 0;
+        const score = (0, utils_1.getKeys)(weight).reduce((score, key) => {
+            return score + (key === 'penalty' ? 0 : stats[key] * weight[key]);
+        }, 0);
+        return Math.round(score * (1 - penalty));
+    }
+}
+exports.InPlayEvent = InPlayEvent;

package/dist/cjs/src/service/event/index.d.ts

@@ -1,9 +1,9 @@
-export * from './set';
-export * from './block';
-export * from './serve';
-export * from './in-play-event';
-export * from './rally-event';
-export * from './reception';
-export * from './spike';
-export * from './substitution';
-export * from './libero-replacement';
+export * from './set';
+export * from './block';
+export * from './serve';
+export * from './in-play-event';
+export * from './rally-event';
+export * from './reception';
+export * from './spike';
+export * from './substitution';
+export * from './libero-replacement';

package/dist/cjs/src/service/event/index.js

@@ -1,25 +1,25 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./set"), exports);
-__exportStar(require("./block"), exports);
-__exportStar(require("./serve"), exports);
-__exportStar(require("./in-play-event"), exports);
-__exportStar(require("./rally-event"), exports);
-__exportStar(require("./reception"), exports);
-__exportStar(require("./spike"), exports);
-__exportStar(require("./substitution"), exports);
-__exportStar(require("./libero-replacement"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./set"), exports);
+__exportStar(require("./block"), exports);
+__exportStar(require("./serve"), exports);
+__exportStar(require("./in-play-event"), exports);
+__exportStar(require("./rally-event"), exports);
+__exportStar(require("./reception"), exports);
+__exportStar(require("./spike"), exports);
+__exportStar(require("./substitution"), exports);
+__exportStar(require("./libero-replacement"), exports);

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

@@ -1,17 +1,17 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Player } from '../player';
-interface LiberoReplacementOpts extends RallyEventOpts {
-    readonly player: Player;
-    readonly libero: Player;
-    readonly type: LiberoReplacementTypeEnum;
-}
-export declare enum LiberoReplacementTypeEnum {
-    LIBERO_IN = 0,
-    LIBERO_OUT = 1
-}
-export declare class LiberoReplacement extends RallyEvent {
-    readonly type: LiberoReplacementTypeEnum;
-    readonly libero: Player;
-    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
-}
-export {};
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { Player } from '../player';
+interface LiberoReplacementOpts extends RallyEventOpts {
+    readonly player: Player;
+    readonly libero: Player;
+    readonly type: LiberoReplacementTypeEnum;
+}
+export declare enum LiberoReplacementTypeEnum {
+    LIBERO_IN = 0,
+    LIBERO_OUT = 1
+}
+export declare class LiberoReplacement extends RallyEvent {
+    readonly type: LiberoReplacementTypeEnum;
+    readonly libero: Player;
+    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
+}
+export {};

package/dist/cjs/src/service/event/libero-replacement.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiberoReplacement = exports.LiberoReplacementTypeEnum = void 0;
-const rally_event_1 = require("./rally-event");
-var LiberoReplacementTypeEnum;
-(function (LiberoReplacementTypeEnum) {
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
-})(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
-class LiberoReplacement extends rally_event_1.RallyEvent {
-    constructor({ id, order, player, type, libero, eventType }) {
-        super({ id, order, player, eventType });
-        this.type = type;
-        this.libero = libero;
-    }
-}
-exports.LiberoReplacement = LiberoReplacement;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiberoReplacement = exports.LiberoReplacementTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+var LiberoReplacementTypeEnum;
+(function (LiberoReplacementTypeEnum) {
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
+})(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
+class LiberoReplacement extends rally_event_1.RallyEvent {
+    constructor({ id, order, player, type, libero, eventType }) {
+        super({ id, order, player, eventType });
+        this.type = type;
+        this.libero = libero;
+    }
+}
+exports.LiberoReplacement = LiberoReplacement;

package/dist/cjs/src/service/event/rally-event.d.ts

@@ -1,23 +1,23 @@
-import { Player } from '../player';
-export declare enum EventTypeEnum {
-    LIBERO_REPLACEMENT = 0,
-    SUBSTITUTION = 1,
-    SERVE = 2,
-    RECEPTION = 3,
-    SET = 4,
-    SPIKE = 5,
-    BLOCK = 6
-}
-export interface RallyEventOpts {
-    readonly id: string;
-    readonly player: Player;
-    readonly eventType: EventTypeEnum;
-    readonly order: number;
-}
-export declare abstract class RallyEvent {
-    readonly id: string;
-    readonly order: number;
-    readonly player: Player;
-    readonly eventType: EventTypeEnum;
-    protected constructor({ id, eventType, player, order }: RallyEventOpts);
-}
+import { Player } from '../player';
+export declare enum EventTypeEnum {
+    LIBERO_REPLACEMENT = 0,
+    SUBSTITUTION = 1,
+    SERVE = 2,
+    RECEPTION = 3,
+    SET = 4,
+    SPIKE = 5,
+    BLOCK = 6
+}
+export interface RallyEventOpts {
+    readonly id: string;
+    readonly player: Player;
+    readonly eventType: EventTypeEnum;
+    readonly order: number;
+}
+export declare abstract class RallyEvent {
+    readonly id: string;
+    readonly order: number;
+    readonly player: Player;
+    readonly eventType: EventTypeEnum;
+    protected constructor({ id, eventType, player, order }: RallyEventOpts);
+}

package/dist/cjs/src/service/event/rally-event.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RallyEvent = exports.EventTypeEnum = void 0;
-var EventTypeEnum;
-(function (EventTypeEnum) {
-    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
-    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
-    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
-    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
-    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
-    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
-    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
-})(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
-class RallyEvent {
-    constructor({ id, eventType, player, order }) {
-        this.id = id;
-        this.player = player;
-        this.order = order;
-        this.eventType = eventType;
-    }
-}
-exports.RallyEvent = RallyEvent;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RallyEvent = exports.EventTypeEnum = void 0;
+var EventTypeEnum;
+(function (EventTypeEnum) {
+    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
+    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
+    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
+    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
+    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
+    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
+    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+})(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
+class RallyEvent {
+    constructor({ id, eventType, player, order }) {
+        this.id = id;
+        this.player = player;
+        this.order = order;
+        this.eventType = eventType;
+    }
+}
+exports.RallyEvent = RallyEvent;

package/dist/cjs/src/service/event/reception.d.ts

@@ -1,26 +1,26 @@
-import { PerformanceStats, Trait } from '../player';
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum ReceptionTypeEnum {
-    DIG = 0,
-    OVERHAND = 1,
-    ONE_HAND = 2,
-    OTHER_BODY_PART = 3
-}
-export declare enum ReceptionFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    BAD_PASS = 4
-}
-interface ReceptionOpts extends InPlayEventOpts {
-    readonly type: ReceptionTypeEnum;
-    readonly failure: ReceptionFailureEnum;
-}
-export declare class Reception extends InPlayEvent {
-    readonly failure: ReceptionFailureEnum;
-    readonly type: ReceptionTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
-    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
-}
-export {};
+import { PerformanceStats, Trait } from '../player';
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+export declare enum ReceptionTypeEnum {
+    DIG = 0,
+    OVERHAND = 1,
+    ONE_HAND = 2,
+    OTHER_BODY_PART = 3
+}
+export declare enum ReceptionFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    BAD_PASS = 4
+}
+interface ReceptionOpts extends InPlayEventOpts {
+    readonly type: ReceptionTypeEnum;
+    readonly failure: ReceptionFailureEnum;
+}
+export declare class Reception extends InPlayEvent {
+    readonly failure: ReceptionFailureEnum;
+    readonly type: ReceptionTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
+}
+export {};