@battle-racing/br-common-lib 4.6.1 → 4.7.0

package/dist/mcp-server/index.js

@@ -0,0 +1,174 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * MCP Server for Battle Racing Common Library
+ * This server allows other AI agents to query types, schemas and constants
+ * from the br-common-lib repository locally.
+ */
+const DOMAINS_DIR = path.resolve(__dirname, "../../src/domains");
+const server = new mcp_js_1.McpServer({
+    name: "br-common-lib-mcp",
+    version: "1.1.1",
+});
+/**
+ * List all available domains in src/domains
+ */
+async function listDomains() {
+    if (!fs.existsSync(DOMAINS_DIR)) {
+        throw new Error(`Domains directory not found at ${DOMAINS_DIR}`);
+    }
+    const entries = fs.readdirSync(DOMAINS_DIR, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+}
+/**
+ * Get details for a specific domain (recursive)
+ */
+async function getDomainDetails(domain) {
+    const domainPath = path.join(DOMAINS_DIR, domain);
+    if (!fs.existsSync(domainPath)) {
+        throw new Error(`Domain "${domain}" not found at ${domainPath}`);
+    }
+    let output = `## Domain: ${domain}\n\n`;
+    function readDirRecursive(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                readDirRecursive(fullPath);
+            }
+            else if (entry.name.endsWith(".types.ts") ||
+                entry.name.endsWith(".schema.ts") ||
+                entry.name.endsWith(".const.ts") ||
+                entry.name === "index.ts") {
+                const relativePath = path.relative(domainPath, fullPath);
+                const content = fs.readFileSync(fullPath, "utf-8");
+                output += `### File: ${relativePath}\n\`\`\`typescript\n${content}\n\`\`\`\n\n`;
+            }
+        }
+    }
+    readDirRecursive(domainPath);
+    return output;
+}
+/**
+ * Search for a symbol (type, constant, etc) across all domains
+ */
+async function searchSymbol(query) {
+    const domains = await listDomains();
+    let results = [];
+    for (const domain of domains) {
+        const domainPath = path.join(DOMAINS_DIR, domain);
+        function searchInDir(dir) {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    searchInDir(fullPath);
+                }
+                else if (entry.isFile() && (entry.name.endsWith(".ts"))) {
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    if (content.includes(query)) {
+                        const lines = content.split("\n");
+                        const matchLine = lines.find(l => l.includes(query)) || "";
+                        results.push({
+                            domain,
+                            file: path.relative(DOMAINS_DIR, fullPath),
+                            match: matchLine.trim()
+                        });
+                    }
+                }
+            }
+        }
+        searchInDir(domainPath);
+    }
+    if (results.length === 0)
+        return `No results found for "${query}"`;
+    return results
+        .map(r => `- [${r.domain}] ${r.file}: \`${r.match}\``)
+        .join("\n");
+}
+// Register tools using the high-level McpServer API (registerTool)
+server.registerTool("list_domains", {
+    description: "List all available domains in br-common-lib (e.g., kart, game, powerUp)",
+}, async () => {
+    const domains = await listDomains();
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Available domains: ${domains.join(", ")}`,
+            },
+        ],
+    };
+});
+server.registerTool("get_domain_details", {
+    description: "Get all types, schemas, and constants for a specific domain (recursive)",
+    inputSchema: zod_1.z.object({
+        domain: zod_1.z.string().describe("The name of the domain (e.g., 'kart')"),
+    }),
+}, async ({ domain }) => {
+    const details = await getDomainDetails(domain);
+    return {
+        content: [{ type: "text", text: details }],
+    };
+});
+server.registerTool("search_symbol", {
+    description: "Search for a specific type, constant or property across all domains",
+    inputSchema: zod_1.z.object({
+        query: zod_1.z.string().describe("The symbol or string to search for (e.g., 'hardwareState')"),
+    }),
+}, async ({ query }) => {
+    const results = await searchSymbol(query);
+    return {
+        content: [{ type: "text", text: results }],
+    };
+});
+// Start the server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("Battle Racing Common Lib MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battle-racing/br-common-lib",
-  "version": "4.6.1",
+  "version": "4.7.0",
   "description": "Common library for all Battle Racing Repositorios",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -30,10 +30,15 @@
   "license": "MIT",
   "private": false,
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@types/node": "^25.6.0",
     "typescript": "^5.8.3",
     "zod": "^4.2.1"
   },
   "peerDependencies": {
     "zod": "^4.2.1"
+  },
+  "dependencies": {
+    "@battle-racing/br-common-lib": "^4.6.1"
   }
 }

package/src/domains/game/Game.schema.ts

@@ -21,8 +21,11 @@ export const kartRankingItemSchema = z.object({
 
 export const gameSchema = z.object({
   id: z.number(),
+  gameTurnId: z.string().optional(),
+  isOfficial: z.boolean().default(true),
   status: gameStatusSchema,
   kartsGuids: z.array(z.string()),
+  playerKartMap: z.record(z.string(), z.string()).default({}),
   powerUpsIds: z.array(z.string()),
   gameTrackId: z.string(),
   type: gameTypeSchema,
@@ -36,3 +39,12 @@ export const gameSchema = z.object({
   kartsState: z.record(z.string(), gameKartStateSchema),
   gameRanking: z.array(kartRankingItemSchema),
 });
+
+export const assignKartSchema = z.object({
+  playerId: z.string(),
+  kartGuid: z.string(),
+});
+
+export const resumeGameSchema = z.object({
+  fromEvent: gameWarningEventSchema,
+});

package/src/domains/game/Game.types.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import {
+  assignKartSchema,
   gameFinishedReasonSchema,
   gameKartStateSchema,
   gameSchema,
@@ -7,6 +8,7 @@ import {
   gameTypeSchema,
   gameWarningEventSchema,
   kartRankingItemSchema,
+  resumeGameSchema,
 } from './Game.schema';
 
 export type GameType = z.infer<typeof gameTypeSchema>;
@@ -16,3 +18,5 @@ export type GameWarningEvent = z.infer<typeof gameWarningEventSchema>;
 export type GameKartState = z.infer<typeof gameKartStateSchema>;
 export type KartRankingItem = z.infer<typeof kartRankingItemSchema>;
 export type Game = z.infer<typeof gameSchema>;
+export type AssignKart = z.infer<typeof assignKartSchema>;
+export type ResumeGame = z.infer<typeof resumeGameSchema>;

package/src/domains/game/battle/Battle.schema.ts

@@ -15,3 +15,19 @@ export const battleSchema = gameSchema.extend({
   lives: z.number(),
   kartsState: z.record(z.string(), battleKartStateSchema),
 });
+
+export const startBattleSchema = z.object({
+  lives: z.number().int(),
+  coins: z.number().int().min(0),
+  kartsGuids: z.array(z.string()).min(1),
+  powerUpsIds: z.array(z.string()).min(1),
+  time: z.number().int().min(30).max(508),
+  speedConfig: z.number().int().min(20).max(100),
+  playerKartMap: z.record(z.string(), z.string()).optional(),
+});
+
+export const createBattleSchema = z.object({
+  gameTrackId: z.string(),
+  gameTurnId: z.string().optional(),
+  isOfficial: z.boolean().optional(),
+});

package/src/domains/game/battle/Battle.types.ts

@@ -1,5 +1,8 @@
 import { z } from 'zod';
-import { battleKartStateSchema, battleSchema } from './Battle.schema';
+import { battleKartStateSchema, battleSchema, createBattleSchema, startBattleSchema } from './Battle.schema';
 
 export type BattleKartState = z.infer<typeof battleKartStateSchema>;
 export type Battle = z.infer<typeof battleSchema>;
+
+export type StartBattle = z.infer<typeof startBattleSchema>;
+export type CreateBattle = z.infer<typeof createBattleSchema>;

package/src/domains/game/race/Race.schema.ts

@@ -30,6 +30,7 @@ export const raceKartStateSchema = gameKartStateSchema.extend({
 export const raceRankingItemSchema = kartRankingItemSchema.extend({
   progress: z.number(),
   lapsCompleted: z.number(),
+  fastestLap: lapTimeSchema.nullable().optional(),
 });
 
 export const rankingWithKartsAndLapTimesSchema = raceRankingItemSchema.extend({
@@ -55,3 +56,19 @@ export const kartLapTimesSchema = z.object({
   kartGuid: z.string(),
   lapTimes: z.array(lapTimeSchema),
 });
+
+export const startRaceSchema = z.object({
+  laps: z.number().int(),
+  coins: z.number().int().min(0).max(254),
+  kartsGuids: z.array(z.string()).min(1),
+  powerUpsIds: z.array(z.string()).min(1),
+  time: z.number().int().min(30).max(1200),
+  speedConfig: z.number().int().min(20).max(100),
+  playerKartMap: z.record(z.string(), z.string()).optional(),
+});
+
+export const createRaceSchema = startRaceSchema.partial().extend({
+  gameTrackId: z.string(),
+  gameTurnId: z.string().optional(),
+  isOfficial: z.boolean().optional(),
+});

package/src/domains/game/race/Race.types.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import {
+  createRaceSchema,
   kartLapTimesSchema,
   kartProgressSchema,
   lapTimeSchema,
@@ -8,6 +9,7 @@ import {
   raceSchema,
   raceWithDetailedRankingSchema,
   rankingWithKartsAndLapTimesSchema,
+  startRaceSchema,
 } from './Race.schema';
 
 export type KartProgress = z.infer<typeof kartProgressSchema>;
@@ -20,3 +22,6 @@ export type RankingWithKartsAndLapTimes = z.infer<typeof rankingWithKartsAndLapT
 
 export type Race = z.infer<typeof raceSchema>;
 export type RaceWithDetailedRanking = z.infer<typeof raceWithDetailedRankingSchema>;
+
+export type StartRace = z.infer<typeof startRaceSchema>;
+export type CreateRace = z.infer<typeof createRaceSchema>;

package/src/domains/player/Player.schema.ts

@@ -48,3 +48,9 @@ export const signWaiverSchema = z.object({
   signature: z.string().optional(), // Base64 or simply a boolean acceptance. Let's make it flexible.
   accepted: z.literal(true), // They must explicitly pass accepted: true
 });
+
+export const playerBasicInfoSchema = playerSchema.pick({
+  id: true,
+  nickname: true,
+  avatarUrl: true,
+});

package/src/domains/player/Player.types.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
-import { playerSchema, playerStatsSchema, playerTypeSchema, playerWaiverStatusSchema } from './Player.schema';
+import { playerBasicInfoSchema, playerSchema, playerStatsSchema, playerTypeSchema, playerWaiverStatusSchema } from './Player.schema';
 
 export type PlayerType = z.infer<typeof playerTypeSchema>;
 export type PlayerStats = z.infer<typeof playerStatsSchema>;
 export type PlayerWaiverStatus = z.infer<typeof playerWaiverStatusSchema>;
 
 export type Player = z.infer<typeof playerSchema>;
+export type PlayerBasicInfo = z.infer<typeof playerBasicInfoSchema>;

package/src/domains/ticketing/Ticketing.const.ts

@@ -22,8 +22,10 @@ export const GAME_TURN_STATUS = {
   CREATED: 'created',
   IN_QUEUE: 'in_queue',
   READY: 'ready',
+  BOARDING: 'boarding',
   PLAYING: 'playing',
   COMPLETED: 'completed',
+  CANCELLED: 'cancelled',
 } as const;
 
 export const GAME_TURN_CHECK = {

package/src/domains/ticketing/Ticketing.schema.ts

@@ -1,4 +1,5 @@
-import { z } from 'zod';
+import { trim, z } from 'zod';
+import { paginatedResponseSchema } from '../pagination';
 import {
   GAME_TICKET_STATUS,
   GAME_TURN_CHECK,
@@ -10,6 +11,7 @@ import {
   TICKET_USER_TYPE,
 } from './Ticketing.const';
 import { gameTypeSchema } from '../game';
+import { playerBasicInfoSchema } from '../player';
 
 export const gameTicketStatusSchema = z.enum(GAME_TICKET_STATUS);
 export const ticketUserTypeSchema = z.enum(TICKET_USER_TYPE);
@@ -59,6 +61,19 @@ export const purchaseSchema = z.object({
   updatedAt: z.date(),
 });
 
+export const filterPurchaseSchema = z.object({
+  purchaseNumber: z.coerce.number().optional(),
+  buyerUserId: z.string().optional(),
+  status: purchaseStatusSchema.optional(),
+  guestName: z.string().optional(),
+  guestContact: z.string().optional(),
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(10),
+  cursor: z.string().optional(),
+});
+
+export const paginatedPurchaseSchema = paginatedResponseSchema(purchaseSchema);
+
 export const createPurchaseInputSchema = z.object({
   buyerUserId: z.string().optional(),
   guestName: z.string().optional(),
@@ -92,14 +107,30 @@ export const gameTurnSchema = z.object({
   leaderPlayerId: z.string(),
   gameTickets: z.array(z.string()),
   playerIds: z.array(z.string()),
+  players: z.array(playerBasicInfoSchema).optional(),
+  gameIds: z.array(z.string()).default([]),
+  type: gameTypeSchema.optional(),
   status: gameTurnStatusSchema,
+  ticketType: ticketTypeSchema.default(TICKET_TYPE.RACE),
   tasks: z.array(gameTurnTaskSchema),
   createdAt: z.date(),
   updatedAt: z.date(),
   startedAt: z.date().optional(),
   completedAt: z.date().optional(),
+  cancelReason: z.string().optional(),
+  cancellAt: z.date().optional(),
+  cancelledByUserId: z.string().optional(),
 });
 
 export const gameTurnQueueItemSchema = gameTurnSchema.extend({
   position: z.number(),
 });
+
+export const cancelGameTurnInputSchema = z.object({
+  cancelReason: z.string().trim().max(500).optional(),
+});
+
+export const postponeGameTurnInputSchema = z.object({
+  positions: z.coerce.number().int().min(1),
+});
+

package/src/domains/ticketing/Ticketing.types.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import {
+  cancelGameTurnInputSchema,
   createPurchaseInputSchema,
+  filterPurchaseSchema,
   gameTicketSchema,
   gameTicketStatusSchema,
   gameTurnCheckSchema,
@@ -10,6 +12,8 @@ import {
   gameTurnTaskSchema,
   gameTurnTaskStatusSchema,
   gameTurnTaskTypeSchema,
+  paginatedPurchaseSchema,
+  postponeGameTurnInputSchema,
   purchaseSchema,
   ticketSummarySchema,
   ticketTypeSchema,
@@ -23,6 +27,8 @@ export type TicketSummary = z.infer<typeof ticketSummarySchema>;
 
 export type Purchase = z.infer<typeof purchaseSchema>;
 export type CreatePurchaseInput = z.infer<typeof createPurchaseInputSchema>;
+export type FilterPurchase = z.infer<typeof filterPurchaseSchema>;
+export type PaginatedPurchase = z.infer<typeof paginatedPurchaseSchema>;
 
 export type GameTicket = z.infer<typeof gameTicketSchema>;
 
@@ -33,3 +39,5 @@ export type GameTurnTaskStatus = z.infer<typeof gameTurnTaskStatusSchema>;
 export type GameTurnTask = z.infer<typeof gameTurnTaskSchema>;
 export type GameTurn = z.infer<typeof gameTurnSchema>;
 export type GameTurnQueueItem = z.infer<typeof gameTurnQueueItemSchema>;
+export type PostponeGameTurnInput = z.infer<typeof postponeGameTurnInputSchema>;
+export type CancelGameTurnInput = z.infer<typeof cancelGameTurnInputSchema>;

package/src/mcp-server/index.ts

@@ -0,0 +1,171 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * MCP Server for Battle Racing Common Library
+ * This server allows other AI agents to query types, schemas and constants
+ * from the br-common-lib repository locally.
+ */
+
+const DOMAINS_DIR = path.resolve(__dirname, "../../src/domains");
+
+const server = new McpServer({
+  name: "br-common-lib-mcp",
+  version: "1.1.1",
+});
+
+/**
+ * List all available domains in src/domains
+ */
+async function listDomains() {
+  if (!fs.existsSync(DOMAINS_DIR)) {
+    throw new Error(`Domains directory not found at ${DOMAINS_DIR}`);
+  }
+
+  const entries = fs.readdirSync(DOMAINS_DIR, { withFileTypes: true });
+  return entries
+    .filter((entry: fs.Dirent) => entry.isDirectory())
+    .map((entry: fs.Dirent) => entry.name);
+}
+
+/**
+ * Get details for a specific domain (recursive)
+ */
+async function getDomainDetails(domain: string) {
+  const domainPath = path.join(DOMAINS_DIR, domain);
+
+  if (!fs.existsSync(domainPath)) {
+    throw new Error(`Domain "${domain}" not found at ${domainPath}`);
+  }
+
+  let output = `## Domain: ${domain}\n\n`;
+
+  function readDirRecursive(dir: string) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        readDirRecursive(fullPath);
+      } else if (
+        entry.name.endsWith(".types.ts") ||
+        entry.name.endsWith(".schema.ts") ||
+        entry.name.endsWith(".const.ts") ||
+        entry.name === "index.ts"
+      ) {
+        const relativePath = path.relative(domainPath, fullPath);
+        const content = fs.readFileSync(fullPath, "utf-8");
+        output += `### File: ${relativePath}\n\`\`\`typescript\n${content}\n\`\`\`\n\n`;
+      }
+    }
+  }
+
+  readDirRecursive(domainPath);
+  return output;
+}
+
+/**
+ * Search for a symbol (type, constant, etc) across all domains
+ */
+async function searchSymbol(query: string) {
+  const domains = await listDomains();
+  let results: { domain: string; file: string; match: string }[] = [];
+
+  for (const domain of domains) {
+    const domainPath = path.join(DOMAINS_DIR, domain);
+    
+    function searchInDir(dir: string) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          searchInDir(fullPath);
+        } else if (entry.isFile() && (entry.name.endsWith(".ts"))) {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          if (content.includes(query)) {
+            const lines = content.split("\n");
+            const matchLine = lines.find(l => l.includes(query)) || "";
+            results.push({
+              domain,
+              file: path.relative(DOMAINS_DIR, fullPath),
+              match: matchLine.trim()
+            });
+          }
+        }
+      }
+    }
+    searchInDir(domainPath);
+  }
+
+  if (results.length === 0) return `No results found for "${query}"`;
+
+  return results
+    .map(r => `- [${r.domain}] ${r.file}: \`${r.match}\``)
+    .join("\n");
+}
+
+// Register tools using the high-level McpServer API (registerTool)
+server.registerTool(
+  "list_domains",
+  {
+    description: "List all available domains in br-common-lib (e.g., kart, game, powerUp)",
+  },
+  async () => {
+    const domains = await listDomains();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Available domains: ${domains.join(", ")}`,
+        },
+      ],
+    };
+  }
+);
+
+server.registerTool(
+  "get_domain_details",
+  {
+    description: "Get all types, schemas, and constants for a specific domain (recursive)",
+    inputSchema: z.object({
+      domain: z.string().describe("The name of the domain (e.g., 'kart')"),
+    }),
+  },
+  async ({ domain }) => {
+    const details = await getDomainDetails(domain);
+    return {
+      content: [{ type: "text", text: details }],
+    };
+  }
+);
+
+server.registerTool(
+  "search_symbol",
+  {
+    description: "Search for a specific type, constant or property across all domains",
+    inputSchema: z.object({
+      query: z.string().describe("The symbol or string to search for (e.g., 'hardwareState')"),
+    }),
+  },
+  async ({ query }) => {
+    const results = await searchSymbol(query);
+    return {
+      content: [{ type: "text", text: results }],
+    };
+  }
+);
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Battle Racing Common Lib MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});

package/dist/constants/checkpoint-type.d.ts

@@ -1,6 +0,0 @@
-export declare const CHECKPOINT_TYPE: {
-    readonly TRACK: "Track";
-    readonly POWER_UP: "PowerUp";
-    readonly SHORTCUT: "Shortcut";
-    readonly UNKNOWN: "Unknown";
-};

package/dist/constants/checkpoint-type.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHECKPOINT_TYPE = void 0;
-exports.CHECKPOINT_TYPE = {
-    TRACK: 'Track',
-    POWER_UP: 'PowerUp',
-    SHORTCUT: 'Shortcut',
-    UNKNOWN: 'Unknown',
-};

package/dist/constants/hardware/base-hardware-status.d.ts

@@ -1,6 +0,0 @@
-export declare const BASE_HARDWARE_STATUS: {
-    readonly ACTIVATED: "Activated";
-    readonly DEACTIVATED: "Deactivated";
-    readonly UNKNOWN: "Unknown";
-    readonly ERROR: "Error";
-};

package/dist/constants/hardware/base-hardware-status.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BASE_HARDWARE_STATUS = void 0;
-exports.BASE_HARDWARE_STATUS = {
-    ACTIVATED: 'Activated',
-    DEACTIVATED: 'Deactivated',
-    UNKNOWN: 'Unknown',
-    ERROR: 'Error',
-};

package/dist/constants/hardware/damage.d.ts

@@ -1,10 +0,0 @@
-export declare const DAMAGE_EFFECT: {
-    readonly GENERIC: "Generic";
-    readonly TRAP_HIT: "Trap Hit";
-    readonly PULSE_HIT: "Pulse Hit";
-    readonly STAR_HIT_LEFT: "Star Hit Left";
-    readonly STAR_HIT_RIGHT: "Star Hit Right";
-    readonly SHOT_HIT: "Shot Hit";
-    readonly SHORTCUT: "Shortcut";
-    readonly BLUE_SHOT_HIT: "Blue Shot Hit";
-};