ballrush-core 0.5.0 → 0.5.1

package/dist/mongo/index.d.ts

@@ -7,3 +7,5 @@ export * from "./schemas/stat-group-profile.schema";
 export * from "./schemas/stat-group-season.schema";
 export * from "./schemas/stat-group-last-100-games.schema";
 export * from "./schemas/stat-group-activity-chart.schema";
+export * from "./schemas/stat-user-profile.schema";
+export * from "./schemas/stat-user-match-history.schema";

package/dist/mongo/index.js

@@ -23,3 +23,5 @@ __exportStar(require("./schemas/stat-group-profile.schema"), exports);
 __exportStar(require("./schemas/stat-group-season.schema"), exports);
 __exportStar(require("./schemas/stat-group-last-100-games.schema"), exports);
 __exportStar(require("./schemas/stat-group-activity-chart.schema"), exports);
+__exportStar(require("./schemas/stat-user-profile.schema"), exports);
+__exportStar(require("./schemas/stat-user-match-history.schema"), exports);

package/dist/mongo/schemas/stat-user-match-history.schema.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from "mongoose";
+/**
+ * Mongoose document interface for StatUserMatchHistory
+ */
+export interface StatUserMatchHistoryDoc {
+    userId: number;
+    groupId: number;
+    eventId: number;
+    result: 'Win' | 'Loss' | 'Draw';
+    matchup: string;
+    score: string;
+    date: Date;
+    seasonName: string;
+    createdAt: Date;
+}
+/**
+ * Factory function to create StatUserMatchHistory schema
+ * Collection: stat_user_match_history
+ */
+export declare function createStatUserMatchHistorySchema(): Schema<StatUserMatchHistoryDoc, import("mongoose").Model<StatUserMatchHistoryDoc, any, any, any, import("mongoose").Document<unknown, any, StatUserMatchHistoryDoc> & StatUserMatchHistoryDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, StatUserMatchHistoryDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<StatUserMatchHistoryDoc>> & import("mongoose").FlatRecord<StatUserMatchHistoryDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/stat-user-match-history.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatUserMatchHistorySchema = createStatUserMatchHistorySchema;
+const mongoose_1 = require("mongoose");
+/**
+ * Factory function to create StatUserMatchHistory schema
+ * Collection: stat_user_match_history
+ */
+function createStatUserMatchHistorySchema() {
+    const StatUserMatchHistorySchema = new mongoose_1.Schema({
+        userId: { type: Number, required: true, index: true },
+        groupId: { type: Number, required: true, index: true },
+        eventId: { type: Number, required: true },
+        result: { type: String, enum: ['Win', 'Loss', 'Draw'], required: true },
+        matchup: { type: String, required: true },
+        score: { type: String, required: true },
+        date: { type: Date, required: true },
+        seasonName: { type: String, required: true },
+        createdAt: { type: Date, default: Date.now },
+    }, {
+        collection: 'stat_user_match_history',
+        versionKey: false,
+    });
+    // Compound index for efficient queries (userId + groupId + date DESC)
+    StatUserMatchHistorySchema.index({ userId: 1, groupId: 1, date: -1 });
+    // Compound index for season filtering (userId + groupId + seasonName + date DESC)
+    StatUserMatchHistorySchema.index({ userId: 1, groupId: 1, seasonName: 1, date: -1 });
+    return StatUserMatchHistorySchema;
+}

package/dist/mongo/schemas/stat-user-profile.schema.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from "mongoose";
+/**
+ * Mongoose sub-schema for SkillHistoryPoint
+ */
+export interface SkillHistoryPointDoc {
+    date: Date;
+    earnedRating: number | null;
+    manualAdjustment: number | null;
+}
+/**
+ * Mongoose sub-schema for ProfileAchievement
+ */
+export interface ProfileAchievementDoc {
+    icon: string;
+    name: string;
+    description: string;
+    count: number;
+}
+/**
+ * Mongoose document interface for StatUserProfile
+ */
+export interface StatUserProfileDoc {
+    userId: number;
+    groupId: number;
+    username: string;
+    fullName: string;
+    avatarUrl: string;
+    position: string;
+    currentSkillRating: number;
+    groupName: string;
+    gamesCount: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    winPercentage: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    eventsCount: number;
+    skillHistory: SkillHistoryPointDoc[];
+    achievements: ProfileAchievementDoc[];
+    lastUpdated: Date;
+}
+/**
+ * Factory function to create StatUserProfile schema
+ * Collection: stat_user_profile
+ */
+export declare function createStatUserProfileSchema(): Schema<StatUserProfileDoc, import("mongoose").Model<StatUserProfileDoc, any, any, any, import("mongoose").Document<unknown, any, StatUserProfileDoc> & StatUserProfileDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, StatUserProfileDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<StatUserProfileDoc>> & import("mongoose").FlatRecord<StatUserProfileDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/stat-user-profile.schema.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatUserProfileSchema = createStatUserProfileSchema;
+const mongoose_1 = require("mongoose");
+/**
+ * Factory function to create StatUserProfile schema
+ * Collection: stat_user_profile
+ */
+function createStatUserProfileSchema() {
+    const SkillHistoryPointSchema = new mongoose_1.Schema({
+        date: { type: Date, required: true },
+        earnedRating: { type: Number, default: null },
+        manualAdjustment: { type: Number, default: null },
+    }, { _id: false });
+    const ProfileAchievementSchema = new mongoose_1.Schema({
+        icon: { type: String, required: true },
+        name: { type: String, required: true },
+        description: { type: String, required: true },
+        count: { type: Number, required: true, min: 0, default: 0 },
+    }, { _id: false });
+    const StatUserProfileSchema = new mongoose_1.Schema({
+        userId: { type: Number, required: true, index: true },
+        groupId: { type: Number, required: true, index: true },
+        username: { type: String, required: true },
+        fullName: { type: String, required: true },
+        avatarUrl: { type: String, default: '' },
+        position: { type: String, default: '' },
+        currentSkillRating: { type: Number, required: true, default: 0 },
+        groupName: { type: String, required: true },
+        gamesCount: { type: Number, required: true, min: 0, default: 0 },
+        wins: { type: Number, required: true, min: 0, default: 0 },
+        losses: { type: Number, required: true, min: 0, default: 0 },
+        draws: { type: Number, required: true, min: 0, default: 0 },
+        winPercentage: { type: Number, required: true, min: 0, max: 100, default: 0 },
+        goalsFor: { type: Number, required: true, min: 0, default: 0 },
+        goalsAgainst: { type: Number, required: true, min: 0, default: 0 },
+        eventsCount: { type: Number, required: true, min: 0, default: 0 },
+        skillHistory: { type: [SkillHistoryPointSchema], default: [] },
+        achievements: { type: [ProfileAchievementSchema], default: [] },
+        lastUpdated: { type: Date, default: Date.now },
+    }, {
+        collection: 'stat_user_profile',
+        versionKey: false,
+    });
+    // Create compound unique index for userId + groupId
+    StatUserProfileSchema.index({ userId: 1, groupId: 1 }, { unique: true });
+    return StatUserProfileSchema;
+}

package/dist/ports/index.d.ts

@@ -7,3 +7,5 @@ export * from "./stat-group-profile.repository";
 export * from "./stat-group-season.repository";
 export * from "./stat-group-last-100-games.repository";
 export * from "./stat-group-activity-chart.repository";
+export * from "./stat-user-profile.repository";
+export * from "./stat-user-match-history.repository";

package/dist/ports/index.js

@@ -23,3 +23,5 @@ __exportStar(require("./stat-group-profile.repository"), exports);
 __exportStar(require("./stat-group-season.repository"), exports);
 __exportStar(require("./stat-group-last-100-games.repository"), exports);
 __exportStar(require("./stat-group-activity-chart.repository"), exports);
+__exportStar(require("./stat-user-profile.repository"), exports);
+__exportStar(require("./stat-user-match-history.repository"), exports);

package/dist/ports/stat-user-match-history.repository.d.ts

@@ -0,0 +1,19 @@
+import { StatUserMatchHistory, MatchHistoryFilter, MatchHistoryOptions, MatchHistoryResult } from "../types/stat-user-match-history.types";
+/**
+ * Repository interface for StatUserMatchHistory
+ * Provides paginated and filterable match history data
+ */
+export interface StatUserMatchHistoryRepository {
+    /**
+     * Find paginated match history for a user in a group
+     * @param filter - User ID, group ID, and optional season filter
+     * @param options - Pagination options
+     * @returns Paginated match history with metadata
+     */
+    find(filter: MatchHistoryFilter, options: MatchHistoryOptions): Promise<MatchHistoryResult>;
+    /**
+     * Create a new match history item
+     * @param item - Match history item to save
+     */
+    create(item: StatUserMatchHistory): Promise<void>;
+}

package/dist/ports/stat-user-match-history.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ports/stat-user-profile.repository.d.ts

@@ -0,0 +1,20 @@
+import { StatUserProfile } from "../types/stat-user-profile.types";
+/**
+ * Repository interface for StatUserProfile
+ * Provides pre-aggregated user profile data including basic info,
+ * statistics, skill history, and achievements
+ */
+export interface StatUserProfileRepository {
+    /**
+     * Find user profile data for a specific user in a specific group
+     * @param userId - User ID
+     * @param groupId - Group ID
+     * @returns User profile data or null if not found
+     */
+    findByUserAndGroup(userId: number, groupId: number): Promise<StatUserProfile | null>;
+    /**
+     * Create or update user profile data
+     * @param profile - User profile data to save
+     */
+    save(profile: StatUserProfile): Promise<void>;
+}

package/dist/ports/stat-user-profile.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/repositories/index.d.ts

@@ -7,3 +7,5 @@ export * from "./mongo/stat-group-profile.repository";
 export * from "./mongo/stat-group-season.repository";
 export * from "./mongo/stat-group-last-100-games.repository";
 export * from "./mongo/stat-group-activity-chart.repository";
+export * from "./mongo/stat-user-profile.repository";
+export * from "./mongo/stat-user-match-history.repository";

package/dist/repositories/index.js

@@ -23,3 +23,5 @@ __exportStar(require("./mongo/stat-group-profile.repository"), exports);
 __exportStar(require("./mongo/stat-group-season.repository"), exports);
 __exportStar(require("./mongo/stat-group-last-100-games.repository"), exports);
 __exportStar(require("./mongo/stat-group-activity-chart.repository"), exports);
+__exportStar(require("./mongo/stat-user-profile.repository"), exports);
+__exportStar(require("./mongo/stat-user-match-history.repository"), exports);

package/dist/repositories/mongo/stat-user-match-history.repository.d.ts

@@ -0,0 +1,14 @@
+import type { Model } from "mongoose";
+import type { StatUserMatchHistoryRepository } from "../../ports/stat-user-match-history.repository";
+import type { StatUserMatchHistoryDoc } from "../../mongo/schemas/stat-user-match-history.schema";
+import type { StatUserMatchHistory, MatchHistoryFilter, MatchHistoryOptions, MatchHistoryResult } from "../../types/stat-user-match-history.types";
+/**
+ * MongoDB implementation of StatUserMatchHistoryRepository
+ * Provides paginated and filterable match history data
+ */
+export declare class MongoStatUserMatchHistoryRepository implements StatUserMatchHistoryRepository {
+    private readonly model;
+    constructor(model: Model<StatUserMatchHistoryDoc>);
+    find(filter: MatchHistoryFilter, options: MatchHistoryOptions): Promise<MatchHistoryResult>;
+    create(item: StatUserMatchHistory): Promise<void>;
+}

package/dist/repositories/mongo/stat-user-match-history.repository.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStatUserMatchHistoryRepository = void 0;
+const errors_1 = require("../../errors");
+/**
+ * MongoDB implementation of StatUserMatchHistoryRepository
+ * Provides paginated and filterable match history data
+ */
+class MongoStatUserMatchHistoryRepository {
+    constructor(model) {
+        this.model = model;
+    }
+    async find(filter, options) {
+        try {
+            // Validate input
+            if (!filter.userId || filter.userId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'userId', filter.userId, 'must be a non-zero number');
+            }
+            if (!filter.groupId || filter.groupId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'groupId', filter.groupId, 'must be a non-zero number');
+            }
+            if (!options.page || options.page < 1) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'page', options.page, 'must be at least 1');
+            }
+            if (!options.limit || options.limit < 1) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'limit', options.limit, 'must be at least 1');
+            }
+            // Build query
+            const query = {
+                userId: filter.userId,
+                groupId: filter.groupId,
+            };
+            // Add season filter if not "All Seasons"
+            if (filter.season && filter.season !== 'All Seasons') {
+                query.seasonName = filter.season;
+            }
+            // Count total matches
+            const totalMatches = await this.model.countDocuments(query);
+            // Calculate pagination
+            const totalPages = Math.ceil(totalMatches / options.limit);
+            const skip = (options.page - 1) * options.limit;
+            // Fetch paginated results (sorted by date DESC)
+            const docs = await this.model
+                .find(query)
+                .sort({ date: -1 })
+                .skip(skip)
+                .limit(options.limit)
+                .lean();
+            // Map documents to domain types
+            const matches = docs.map(doc => ({
+                userId: doc.userId,
+                groupId: doc.groupId,
+                eventId: doc.eventId,
+                result: doc.result,
+                matchup: doc.matchup,
+                score: doc.score,
+                date: doc.date,
+                seasonName: doc.seasonName,
+                createdAt: doc.createdAt,
+            }));
+            return {
+                matches,
+                totalMatches,
+                totalPages,
+                currentPage: options.page,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('find', 'StatUserMatchHistory', `${filter.userId}:${filter.groupId}`, error);
+        }
+    }
+    async create(item) {
+        try {
+            // Validate input
+            if (!item.userId || item.userId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'userId', item.userId, 'must be a non-zero number');
+            }
+            if (!item.groupId || item.groupId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'groupId', item.groupId, 'must be a non-zero number');
+            }
+            if (!item.eventId || item.eventId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'eventId', item.eventId, 'must be a non-zero number');
+            }
+            // Create new match history item
+            await this.model.create({
+                userId: item.userId,
+                groupId: item.groupId,
+                eventId: item.eventId,
+                result: item.result,
+                matchup: item.matchup,
+                score: item.score,
+                date: item.date,
+                seasonName: item.seasonName,
+                createdAt: item.createdAt,
+            });
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('create', 'StatUserMatchHistory', `${item.userId}:${item.groupId}:${item.eventId}`, error);
+        }
+    }
+}
+exports.MongoStatUserMatchHistoryRepository = MongoStatUserMatchHistoryRepository;

package/dist/repositories/mongo/stat-user-profile.repository.d.ts

@@ -0,0 +1,14 @@
+import type { Model } from "mongoose";
+import type { StatUserProfileRepository } from "../../ports/stat-user-profile.repository";
+import type { StatUserProfileDoc } from "../../mongo/schemas/stat-user-profile.schema";
+import type { StatUserProfile } from "../../types/stat-user-profile.types";
+/**
+ * MongoDB implementation of StatUserProfileRepository
+ * Provides read and write access to pre-aggregated user profile data
+ */
+export declare class MongoStatUserProfileRepository implements StatUserProfileRepository {
+    private readonly model;
+    constructor(model: Model<StatUserProfileDoc>);
+    findByUserAndGroup(userId: number, groupId: number): Promise<StatUserProfile | null>;
+    save(profile: StatUserProfile): Promise<void>;
+}

package/dist/repositories/mongo/stat-user-profile.repository.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStatUserProfileRepository = void 0;
+const errors_1 = require("../../errors");
+/**
+ * MongoDB implementation of StatUserProfileRepository
+ * Provides read and write access to pre-aggregated user profile data
+ */
+class MongoStatUserProfileRepository {
+    constructor(model) {
+        this.model = model;
+    }
+    async findByUserAndGroup(userId, groupId) {
+        try {
+            // Validate input
+            if (!userId || userId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'userId', userId, 'must be a non-zero number');
+            }
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = await this.model.findOne({ userId, groupId }).lean();
+            if (!doc) {
+                return null;
+            }
+            // Map document to domain type
+            return {
+                userId: doc.userId,
+                groupId: doc.groupId,
+                username: doc.username,
+                fullName: doc.fullName,
+                avatarUrl: doc.avatarUrl,
+                position: doc.position,
+                currentSkillRating: doc.currentSkillRating,
+                groupName: doc.groupName,
+                gamesCount: doc.gamesCount,
+                wins: doc.wins,
+                losses: doc.losses,
+                draws: doc.draws,
+                winPercentage: doc.winPercentage,
+                goalsFor: doc.goalsFor,
+                goalsAgainst: doc.goalsAgainst,
+                eventsCount: doc.eventsCount,
+                skillHistory: doc.skillHistory.map(point => ({
+                    date: point.date,
+                    earnedRating: point.earnedRating,
+                    manualAdjustment: point.manualAdjustment,
+                })),
+                achievements: doc.achievements.map(achievement => ({
+                    icon: achievement.icon,
+                    name: achievement.name,
+                    description: achievement.description,
+                    count: achievement.count,
+                })),
+                lastUpdated: doc.lastUpdated,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findByUserAndGroup', 'StatUserProfile', `${userId}:${groupId}`, error);
+        }
+    }
+    async save(profile) {
+        try {
+            // Validate input
+            if (!profile.userId || profile.userId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'userId', profile.userId, 'must be a non-zero number');
+            }
+            if (!profile.groupId || profile.groupId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'groupId', profile.groupId, 'must be a non-zero number');
+            }
+            // Upsert the profile (create or update)
+            await this.model.updateOne({ userId: profile.userId, groupId: profile.groupId }, {
+                $set: {
+                    username: profile.username,
+                    fullName: profile.fullName,
+                    avatarUrl: profile.avatarUrl,
+                    position: profile.position,
+                    currentSkillRating: profile.currentSkillRating,
+                    groupName: profile.groupName,
+                    gamesCount: profile.gamesCount,
+                    wins: profile.wins,
+                    losses: profile.losses,
+                    draws: profile.draws,
+                    winPercentage: profile.winPercentage,
+                    goalsFor: profile.goalsFor,
+                    goalsAgainst: profile.goalsAgainst,
+                    eventsCount: profile.eventsCount,
+                    skillHistory: profile.skillHistory,
+                    achievements: profile.achievements,
+                    lastUpdated: profile.lastUpdated,
+                },
+            }, { upsert: true });
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('save', 'StatUserProfile', `${profile.userId}:${profile.groupId}`, error);
+        }
+    }
+}
+exports.MongoStatUserProfileRepository = MongoStatUserProfileRepository;

package/dist/types/index.d.ts

@@ -3,3 +3,5 @@ export * from "./stat-group-profile.types";
 export * from "./stat-group-season.types";
 export * from "./stat-group-last-100-games.types";
 export * from "./stat-group-activity-chart.types";
+export * from "./stat-user-profile.types";
+export * from "./stat-user-match-history.types";

package/dist/types/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./stat-group-profile.types"), exports);
 __exportStar(require("./stat-group-season.types"), exports);
 __exportStar(require("./stat-group-last-100-games.types"), exports);
 __exportStar(require("./stat-group-activity-chart.types"), exports);
+__exportStar(require("./stat-user-profile.types"), exports);
+__exportStar(require("./stat-user-match-history.types"), exports);

package/dist/types/stat-user-match-history.types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Statistics: User Match History Types
+ * Pre-aggregated user match history data for ballrush-api
+ */
+export interface StatUserMatchHistory {
+    userId: number;
+    groupId: number;
+    eventId: number;
+    result: 'Win' | 'Loss' | 'Draw';
+    matchup: string;
+    score: string;
+    date: Date;
+    seasonName: string;
+    createdAt: Date;
+}
+/**
+ * Filter options for match history queries
+ */
+export interface MatchHistoryFilter {
+    userId: number;
+    groupId: number;
+    season?: string;
+}
+/**
+ * Pagination options for match history queries
+ */
+export interface MatchHistoryOptions {
+    page: number;
+    limit: number;
+}
+/**
+ * Result type for paginated match history queries
+ */
+export interface MatchHistoryResult {
+    matches: StatUserMatchHistory[];
+    totalMatches: number;
+    totalPages: number;
+    currentPage: number;
+}

package/dist/types/stat-user-match-history.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Statistics: User Match History Types
+ * Pre-aggregated user match history data for ballrush-api
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/stat-user-profile.types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Statistics: User Profile Types
+ * Pre-aggregated user profile data for ballrush-api
+ */
+export interface SkillHistoryPoint {
+    date: Date;
+    earnedRating: number | null;
+    manualAdjustment: number | null;
+}
+export interface ProfileAchievement {
+    icon: string;
+    name: string;
+    description: string;
+    count: number;
+}
+export interface StatUserProfile {
+    userId: number;
+    groupId: number;
+    username: string;
+    fullName: string;
+    avatarUrl: string;
+    position: string;
+    currentSkillRating: number;
+    groupName: string;
+    gamesCount: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    winPercentage: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    eventsCount: number;
+    skillHistory: SkillHistoryPoint[];
+    achievements: ProfileAchievement[];
+    lastUpdated: Date;
+}

package/dist/types/stat-user-profile.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Statistics: User Profile Types
+ * Pre-aggregated user profile data for ballrush-api
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ballrush-core",
-    "version": "0.5.0",
+    "version": "0.5.1",
     "private": false,
     "license": "MIT",
     "main": "./dist/index.js",