volleyballsimtypes 0.0.478 → 0.0.480

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

@@ -0,0 +1,126 @@
+import { describe, it, expect } from '@jest/globals';
+import { NOTIFICATION_TYPES, NOTIFICATION_LOCALES } from './notification-type';
+import { NOTIFICATION_REGISTRY } from './registry';
+import { NOTIFICATION_CATALOG } from './catalog';
+import { renderPush, notificationPath, interpolate, translateNotification } from './render';
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function placeholders(value) {
+    return (value.match(/\{\{(\w+)\}\}/g) ?? []).sort((a, b) => a.localeCompare(b));
+}
+function flattenStrings(node, prefix = '') {
+    const out = [];
+    if (typeof node !== 'object' || node == null)
+        return out;
+    for (const [key, value] of Object.entries(node)) {
+        if (typeof value === 'string')
+            out.push([prefix + key, value]);
+        else if (typeof value === 'object' && value != null)
+            out.push(...flattenStrings(value, `${prefix}${key}.`));
+    }
+    return out;
+}
+describe('notification registry + catalog completeness', () => {
+    it('has exactly one descriptor per declared type', () => {
+        expect(Object.keys(NOTIFICATION_REGISTRY).sort((a, b) => a.localeCompare(b)))
+            .toEqual([...NOTIFICATION_TYPES].sort((a, b) => a.localeCompare(b)));
+    });
+    it('resolves every descriptor catalog key to a non-empty string in all 7 locales', () => {
+        for (const type of NOTIFICATION_TYPES) {
+            for (const key of NOTIFICATION_REGISTRY[type].catalogKeys) {
+                for (const locale of NOTIFICATION_LOCALES) {
+                    const value = readNested(NOTIFICATION_CATALOG[locale], key);
+                    expect([locale, key, (value ?? '').length > 0]).toEqual([locale, key, true]);
+                }
+            }
+        }
+    });
+    it('ships an identical key set across all 7 locales (no drift)', () => {
+        const enKeys = flattenStrings(NOTIFICATION_CATALOG.en).map(([key]) => key).sort((a, b) => a.localeCompare(b));
+        for (const locale of NOTIFICATION_LOCALES) {
+            const keys = flattenStrings(NOTIFICATION_CATALOG[locale]).map(([key]) => key).sort((a, b) => a.localeCompare(b));
+            expect([locale, keys]).toEqual([locale, enKeys]);
+        }
+    });
+    it('keeps placeholders identical across locales', () => {
+        for (const [key, enValue] of flattenStrings(NOTIFICATION_CATALOG.en)) {
+            const expected = placeholders(enValue);
+            for (const locale of NOTIFICATION_LOCALES) {
+                const value = readNested(NOTIFICATION_CATALOG[locale], key);
+                if (value == null)
+                    continue;
+                expect([locale, key, placeholders(value)]).toEqual([locale, key, expected]);
+            }
+        }
+    });
+    it('contains no em or en dashes', () => {
+        for (const locale of NOTIFICATION_LOCALES) {
+            for (const [key, value] of flattenStrings(NOTIFICATION_CATALOG[locale])) {
+                expect([locale, key, value.includes('—') || value.includes('–')]).toEqual([locale, key, false]);
+            }
+        }
+    });
+});
+describe('renderPush', () => {
+    it('renders a localized MATCH_RESULT win with a named opponent', () => {
+        const payload = { matchId: 'm1', result: 'WIN', side: 'HOME', awayTeam: { name: 'Rivals' } };
+        const en = renderPush('MATCH_RESULT', payload, 'en');
+        expect(en?.title).toBe('Match result');
+        expect(en?.body).toBe('You won against Rivals');
+        expect(en?.data.path).toBe('/match/m1');
+        expect(renderPush('MATCH_RESULT', payload, 'es')?.body).toBe('Ganaste contra Rivals');
+    });
+    it('uses the unnamed variant and root path when the opponent is unknown', () => {
+        const en = renderPush('MATCH_RESULT', { result: 'LOSS' }, 'en');
+        expect(en?.body).toBe('You lost your match');
+        expect(en?.data.path).toBe('/');
+    });
+    it('interpolates the injured player name and links to the infirmary', () => {
+        const en = renderPush('INJURY', { playerNickname: 'Ace', teamId: 't1' }, 'en');
+        expect(en?.title).toBe('Player injured');
+        expect(en?.body).toContain('Ace');
+        expect(en?.data.path).toBe('/infirmary');
+    });
+    it('uses a generic subject when the injury payload has no player name', () => {
+        const en = renderPush('INJURY', { teamId: 't1' }, 'en');
+        expect(en?.body.startsWith('A player')).toBe(true);
+    });
+    it('returns undefined for in-app-only types (COMPENSATION)', () => {
+        expect(renderPush('COMPENSATION', { currency: 100 }, 'en')).toBeUndefined();
+    });
+    it('falls back to generic copy and root path for an unknown type', () => {
+        const en = renderPush('SOMETHING_NEW', {}, 'en');
+        expect(en?.title).toBe('World Aces');
+        expect(en?.body).toBe('You have a new notification.');
+        expect(en?.data.path).toBe('/');
+    });
+    it('serializes the payload into the FCM data block', () => {
+        const en = renderPush('GRANT_RECEIVED', { pullType: 'MYTHIC' }, 'en');
+        expect(en?.data.type).toBe('GRANT_RECEIVED');
+        expect(JSON.parse(en?.data.payload ?? '{}')).toEqual({ pullType: 'MYTHIC' });
+    });
+});
+describe('translateNotification + interpolate + notificationPath', () => {
+    it('falls back to English then to the raw key', () => {
+        expect(translateNotification('fr', 'promotion.title')).toBe('Promotion');
+        expect(translateNotification('en', 'does.not.exist')).toBe('does.not.exist');
+    });
+    it('replaces placeholders and drops unknown ones', () => {
+        expect(interpolate('Hi {{name}}!', { name: 'X' })).toBe('Hi X!');
+        expect(interpolate('Hi {{name}}!', {})).toBe('Hi !');
+    });
+    it('derives the deep-link path per type', () => {
+        expect(notificationPath('SEASON_END', { leagueId: 'l1' })).toBe('/league/l1');
+        expect(notificationPath('SEASON_END', {})).toBe('/league');
+        expect(notificationPath('PROMOTION', { teamId: 't1' })).toBe('/team/t1');
+        expect(notificationPath('GRANT_RECEIVED', {})).toBe('/recruit');
+        expect(notificationPath('COMPENSATION', {})).toBe('/');
+    });
+});

package/dist/esm/src/service/notification/payloads.d.ts

@@ -0,0 +1,34 @@
+export interface MatchResultTeam {
+    id?: string;
+    name?: string;
+}
+export interface MatchResultPayload {
+    matchId?: string;
+    homeTeam?: MatchResultTeam;
+    awayTeam?: MatchResultTeam;
+    result?: 'WIN' | 'LOSS';
+    side?: 'HOME' | 'AWAY';
+}
+export interface InjuryPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+    matchId?: string;
+}
+export interface InjuryRecoveredPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+}
+export interface SeasonEndPayload {
+    competitionId?: string;
+    leagueId?: string;
+    position?: number;
+}
+export interface PromotionPayload {
+    teamId?: string;
+    amount?: number;
+}
+export type NotificationPayload = MatchResultPayload | InjuryPayload | InjuryRecoveredPayload | SeasonEndPayload | PromotionPayload | Record<string, unknown>;

package/dist/esm/src/service/notification/payloads.js

@@ -0,0 +1,4 @@
+// Typed payload shapes per notification type, for call-site safety in the Sim/API. The DB `Notification.payload`
+// column is jsonb (free-form), so the registry reads payloads defensively (Record<string, unknown>); these
+// interfaces document the intended shape and can be used by emitters when constructing the payload.
+export {};

package/dist/esm/src/service/notification/registry.d.ts

@@ -0,0 +1,13 @@
+import { type NotificationType } from './notification-type';
+export type CatalogKeyResolver = string | ((payload: Record<string, unknown>) => string);
+export interface NotificationDescriptor {
+    emitsPush: boolean;
+    deepLink?: (payload: Record<string, unknown>) => string;
+    pushTitleKey?: CatalogKeyResolver;
+    pushBodyKey?: CatalogKeyResolver;
+    inAppMessageKey?: CatalogKeyResolver;
+    richRender?: NotificationType;
+    params?: (payload: Record<string, unknown>) => Record<string, string>;
+    catalogKeys: string[];
+}
+export declare const NOTIFICATION_REGISTRY: Record<NotificationType, NotificationDescriptor>;

package/dist/esm/src/service/notification/registry.js

@@ -0,0 +1,109 @@
+function readString(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+function teamPath(payload) {
+    const teamId = readString(payload.teamId);
+    return teamId != null ? `/team/${encodeURIComponent(teamId)}` : '/';
+}
+// MATCH_RESULT copy is recipient-relative: `result` is WIN/LOSS from the recipient's view and `side` marks
+// which team is theirs, so the OTHER team is the opponent. When side/names are missing, do not name a winner.
+function matchOpponent(payload) {
+    const homeTeam = typeof payload.homeTeam === 'object' && payload.homeTeam != null ? payload.homeTeam : {};
+    const awayTeam = typeof payload.awayTeam === 'object' && payload.awayTeam != null ? payload.awayTeam : {};
+    const homeName = readString(homeTeam.name);
+    const awayName = readString(awayTeam.name);
+    if (payload.side === 'HOME')
+        return awayName;
+    if (payload.side === 'AWAY')
+        return homeName;
+    return null;
+}
+function injuredName(payload) {
+    // Matches the old Sim injuredPlayerName fallback so a name-less payload never renders a subjectless sentence.
+    return readString(payload.playerNickname) ?? readString(payload.playerName) ?? 'A player';
+}
+export const NOTIFICATION_REGISTRY = {
+    MATCH_RESULT: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const matchId = readString(p.matchId);
+            return matchId != null ? `/match/${encodeURIComponent(matchId)}` : '/';
+        },
+        pushTitleKey: 'matchResult.title',
+        pushBodyKey: (p) => {
+            const outcome = p.result === 'WIN' ? 'won' : 'lost';
+            const named = matchOpponent(p) != null ? 'Named' : 'Unnamed';
+            return `matchResult.${outcome}${named}`;
+        },
+        params: (p) => ({ opponent: matchOpponent(p) ?? '' }),
+        richRender: 'MATCH_RESULT',
+        catalogKeys: ['matchResult.title', 'matchResult.wonNamed', 'matchResult.wonUnnamed', 'matchResult.lostNamed', 'matchResult.lostUnnamed']
+    },
+    INJURY: {
+        emitsPush: true,
+        deepLink: () => '/infirmary',
+        pushTitleKey: 'injury.title',
+        pushBodyKey: 'injury.body',
+        inAppMessageKey: 'injury.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injury.title', 'injury.body']
+    },
+    INJURY_RECOVERED: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'injuryRecovered.title',
+        pushBodyKey: 'injuryRecovered.body',
+        inAppMessageKey: 'injuryRecovered.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injuryRecovered.title', 'injuryRecovered.body']
+    },
+    SEASON_END: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const leagueId = readString(p.leagueId);
+            return leagueId != null ? `/league/${encodeURIComponent(leagueId)}` : '/league';
+        },
+        pushTitleKey: 'seasonEnd.title',
+        pushBodyKey: 'seasonEnd.body',
+        inAppMessageKey: 'seasonEnd.body',
+        catalogKeys: ['seasonEnd.title', 'seasonEnd.body']
+    },
+    GRANT_RECEIVED: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'grant.title',
+        pushBodyKey: 'grant.body',
+        inAppMessageKey: 'grant.body',
+        catalogKeys: ['grant.title', 'grant.body']
+    },
+    PROMOTION: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'promotion.title',
+        pushBodyKey: 'promotion.body',
+        inAppMessageKey: 'promotion.body',
+        catalogKeys: ['promotion.title', 'promotion.body']
+    },
+    DAILY_LOGIN: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'dailyLogin.title',
+        pushBodyKey: 'dailyLogin.body',
+        inAppMessageKey: 'dailyLogin.body',
+        catalogKeys: ['dailyLogin.title', 'dailyLogin.body']
+    },
+    WELCOME: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'welcome.title',
+        pushBodyKey: 'welcome.body',
+        richRender: 'WELCOME',
+        catalogKeys: ['welcome.title', 'welcome.body']
+    },
+    // In-app only (no push); the UI keeps a bespoke renderer (amount formatting) and its own `compensation` label.
+    COMPENSATION: {
+        emitsPush: false,
+        richRender: 'COMPENSATION',
+        catalogKeys: []
+    }
+};

package/dist/esm/src/service/notification/render.d.ts

@@ -0,0 +1,10 @@
+import { type NotificationLocale } from './notification-type';
+export interface RenderedPush {
+    title: string;
+    body: string;
+    data: Record<string, string>;
+}
+export declare function interpolate(template: string, params: Record<string, string>): string;
+export declare function translateNotification(locale: NotificationLocale, key: string, params?: Record<string, string>): string;
+export declare function renderPush(type: string, payload: Record<string, unknown>, locale: NotificationLocale): RenderedPush | undefined;
+export declare function notificationPath(type: string, payload: Record<string, unknown>): string;

package/dist/esm/src/service/notification/render.js

@@ -0,0 +1,58 @@
+import { DEFAULT_NOTIFICATION_LOCALE } from './notification-type';
+import { NOTIFICATION_REGISTRY } from './registry';
+import { NOTIFICATION_CATALOG } from './catalog';
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function lookupCatalog(locale, dotKey) {
+    return readNested(NOTIFICATION_CATALOG[locale], dotKey) ??
+        readNested(NOTIFICATION_CATALOG[DEFAULT_NOTIFICATION_LOCALE], dotKey) ??
+        dotKey;
+}
+function resolveKey(resolver, payload) {
+    if (resolver == null)
+        return undefined;
+    return typeof resolver === 'function' ? resolver(payload) : resolver;
+}
+export function interpolate(template, params) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => params[key] ?? '');
+}
+// Resolve one catalog key to a localized, interpolated string. Missing key/locale falls back to English,
+// then to the raw key. Exposed so consumers can render notification copy off the shared catalog too.
+export function translateNotification(locale, key, params = {}) {
+    return interpolate(lookupCatalog(locale, key), params);
+}
+// Build the localized push payload for a notification. Returns undefined for in-app-only types (emitsPush
+// false, e.g. COMPENSATION). Unknown/future types fall back to the generic copy and the root path, matching
+// the previous hardcoded fallback. Callers pass the recipient's locale (normalizeNotificationLocale first).
+export function renderPush(type, payload, locale) {
+    const buildData = (path) => ({ type, payload: JSON.stringify(payload), path });
+    const descriptor = NOTIFICATION_REGISTRY[type];
+    if (descriptor == null) {
+        return {
+            title: translateNotification(locale, 'generic.title'),
+            body: translateNotification(locale, 'generic.body'),
+            data: buildData('/')
+        };
+    }
+    if (!descriptor.emitsPush)
+        return undefined;
+    const params = descriptor.params?.(payload) ?? {};
+    const titleKey = resolveKey(descriptor.pushTitleKey, payload) ?? 'generic.title';
+    const bodyKey = resolveKey(descriptor.pushBodyKey, payload) ?? 'generic.body';
+    return {
+        title: translateNotification(locale, titleKey, params),
+        body: translateNotification(locale, bodyKey, params),
+        data: buildData(descriptor.deepLink?.(payload) ?? '/')
+    };
+}
+// Deep-link path for a type/payload, used for both the push data.path and the in-app click target.
+export function notificationPath(type, payload) {
+    return NOTIFICATION_REGISTRY[type]?.deepLink?.(payload) ?? '/';
+}

package/dist/esm/src/service/team/offensive-preference.d.ts

@@ -1,5 +1,7 @@
 import { Player } from '../player';
+export type TempoPreference = 'FAST' | 'HIGH';
 export interface OffensivePreference {
     readonly rotation: number;
     readonly order: Player[];
+    readonly tempos?: Record<string, TempoPreference>;
 }

package/dist/esm/src/service/team/schemas/tactics.z.d.ts

@@ -270,6 +270,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
     offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            FAST: "FAST";
+            HIGH: "HIGH";
+        }>>>;
     }, z.core.$strip>>>;
     systemSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         rotationSystem: z.ZodEnum<typeof RotationSystemEnum>;
@@ -278,6 +282,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
     offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            FAST: "FAST";
+            HIGH: "HIGH";
+        }>>>;
     }, z.core.$strip>>>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/dist/esm/src/service/team/schemas/tactics.z.js

@@ -45,11 +45,15 @@ const lineupSchema = z.object({
         });
     }
 });
+// Per-player tempo preference (set-tempo rework): absent key = Auto.
+const tempoPreferenceSchema = z.enum(['FAST', 'HIGH']);
 // One rotation's ranked attacker priority. `rotation` is the main setter's rotational slot (1..6); `order` lists
-// the attackers ranked best-first. Cross-field checks (starters only, no dupes) live in the superRefine below.
+// the attackers ranked best-first. `tempos` optionally forces a per-starter tempo (Auto when absent). Cross-field
+// checks (starters only in both order and tempos, no dupes) live in the superRefine below.
 const offensivePreferenceSchema = z.object({
     rotation: z.number().int().min(1).max(6),
-    order: z.array(playerInstanceSchema)
+    order: z.array(playerInstanceSchema),
+    tempos: z.record(z.string(), tempoPreferenceSchema).optional()
 });
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = z.object({
@@ -155,6 +159,12 @@ export const TacticsInputSchema = z.object({
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER', path });
                 }
             }
+            // Tempo preference keys are starter ids too (same rule as order).
+            for (const id of Object.keys(pref.tempos ?? {})) {
+                if (!starterIds.has(id)) {
+                    ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER', path });
+                }
+            }
         }
     };
     validateSystem(data.rotationSystem, data.designatedSetters, ['designatedSetters']);

package/dist/esm/src/service/team/schemas/tactics.z.test.js

@@ -168,6 +168,30 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
             expect(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER')).toBe(true);
         }
     });
+    it('accepts offensive preferences with a starter-keyed tempos map', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
+        }
+    });
+    it('rejects a tempos map keyed by a non-starter', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [reserve.id]: 'FAST' } }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    it('rejects an invalid tempo value', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [p2.id]: 'SLOW' } }]
+        }));
+        expect(res.success).toBe(false);
+    });
     it('still validates the flat fields when per-set overrides are present', () => {
         // Flat 5-1 with no setter is invalid even though every set entry is valid.
         const res = TacticsInputSchema.safeParse(baseInput({

package/dist/esm/src/service/team/schemas/team.z.d.ts

@@ -278,6 +278,10 @@ export declare const TeamInputSchema: z.ZodObject<{
         offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
+            tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                FAST: "FAST";
+                HIGH: "HIGH";
+            }>>>;
         }, z.core.$strip>>>;
         systemSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
             rotationSystem: z.ZodEnum<typeof import("..").RotationSystemEnum>;
@@ -286,6 +290,10 @@ export declare const TeamInputSchema: z.ZodObject<{
         offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
+            tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                FAST: "FAST";
+                HIGH: "HIGH";
+            }>>>;
         }, z.core.$strip>>>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.478",
+  "version": "0.0.480",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -37,6 +37,11 @@
       "import": "./dist/esm/src/data/common/index.js",
       "require": "./dist/cjs/src/data/common/index.js"
     },
+    "./notification": {
+      "types": "./dist/esm/src/service/notification/index.d.ts",
+      "import": "./dist/esm/src/service/notification/index.js",
+      "require": "./dist/cjs/src/service/notification/index.js"
+    },
     "./stat-config": {
       "types": "./dist/esm/src/stat-config/index.d.ts",
       "import": "./dist/esm/src/stat-config/index.js",