@battle-racing/br-common-lib 3.8.0 → 4.1.0

package/dist/domains/game/Game.const.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAME_WARNING_EVENT = exports.GAME_FINISHED_REASON = exports.GAME_STATUS = exports.GAME_TYPE = void 0;
+exports.GAME_TYPE = {
+    Race: 'Race',
+    Battle: 'Battle',
+};
+exports.GAME_STATUS = {
+    NON_STARTED: 'non-started',
+    ACTIVE: 'active',
+    YELLOW_FLAG: 'yellow-flag',
+    RED_FLAG: 'red-flag',
+    FINISHED: 'finished',
+    KART_ELIMINATED: 'kart-eliminated',
+};
+exports.GAME_FINISHED_REASON = {
+    TIME_IS_OVER: 'TIME_IS_OVER',
+    GAME_KARTS_FINISHED: 'GAME_KARTS_FINISHED',
+    EMERGENCY: 'EMERGENCY',
+    BY_CONTROLLER: 'BY_CONTROLLER',
+};
+exports.GAME_WARNING_EVENT = {
+    YELLOW_FLAG: 'yellow-flag',
+    RED_FLAG: 'red-flag',
+};

package/dist/domains/game/Game.schema.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const gameTypeSchema: z.ZodEnum<{
+    readonly Race: "Race";
+    readonly Battle: "Battle";
+}>;
+export declare const gameStatusSchema: z.ZodEnum<{
+    readonly NON_STARTED: "non-started";
+    readonly ACTIVE: "active";
+    readonly YELLOW_FLAG: "yellow-flag";
+    readonly RED_FLAG: "red-flag";
+    readonly FINISHED: "finished";
+    readonly KART_ELIMINATED: "kart-eliminated";
+}>;
+export declare const gameFinishedReasonSchema: z.ZodEnum<{
+    readonly TIME_IS_OVER: "TIME_IS_OVER";
+    readonly GAME_KARTS_FINISHED: "GAME_KARTS_FINISHED";
+    readonly EMERGENCY: "EMERGENCY";
+    readonly BY_CONTROLLER: "BY_CONTROLLER";
+}>;
+export declare const gameWarningEventSchema: z.ZodEnum<{
+    readonly YELLOW_FLAG: "yellow-flag";
+    readonly RED_FLAG: "red-flag";
+}>;
+export declare const gameKartStateSchema: z.ZodObject<{
+    coins: z.ZodNumber;
+}, z.core.$strip>;
+export declare const kartRankingItemSchema: z.ZodObject<{
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    time: z.ZodNumber;
+}, z.core.$strip>;
+export declare const gameSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    status: z.ZodEnum<{
+        readonly NON_STARTED: "non-started";
+        readonly ACTIVE: "active";
+        readonly YELLOW_FLAG: "yellow-flag";
+        readonly RED_FLAG: "red-flag";
+        readonly FINISHED: "finished";
+        readonly KART_ELIMINATED: "kart-eliminated";
+    }>;
+    kartsGuids: z.ZodArray<z.ZodString>;
+    powerUpsIds: z.ZodArray<z.ZodString>;
+    gameTrackId: z.ZodString;
+    type: z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>;
+    coins: z.ZodNumber;
+    time: z.ZodNumber;
+    speedConfig: z.ZodNumber;
+    createdAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    finishedReason: z.ZodOptional<z.ZodEnum<{
+        readonly TIME_IS_OVER: "TIME_IS_OVER";
+        readonly GAME_KARTS_FINISHED: "GAME_KARTS_FINISHED";
+        readonly EMERGENCY: "EMERGENCY";
+        readonly BY_CONTROLLER: "BY_CONTROLLER";
+    }>>;
+    kartsState: z.ZodRecord<z.ZodString, z.ZodObject<{
+        coins: z.ZodNumber;
+    }, z.core.$strip>>;
+    gameRanking: z.ZodArray<z.ZodObject<{
+        kartGuid: z.ZodString;
+        position: z.ZodNumber;
+        time: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/domains/game/Game.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gameSchema = exports.kartRankingItemSchema = exports.gameKartStateSchema = exports.gameWarningEventSchema = exports.gameFinishedReasonSchema = exports.gameStatusSchema = exports.gameTypeSchema = void 0;
+const zod_1 = require("zod");
+const Game_const_1 = require("./Game.const");
+exports.gameTypeSchema = zod_1.z.enum(Game_const_1.GAME_TYPE);
+exports.gameStatusSchema = zod_1.z.enum(Game_const_1.GAME_STATUS);
+exports.gameFinishedReasonSchema = zod_1.z.enum(Game_const_1.GAME_FINISHED_REASON);
+exports.gameWarningEventSchema = zod_1.z.enum(Game_const_1.GAME_WARNING_EVENT);
+exports.gameKartStateSchema = zod_1.z.object({
+    coins: zod_1.z.number(),
+});
+exports.kartRankingItemSchema = zod_1.z.object({
+    kartGuid: zod_1.z.string(),
+    position: zod_1.z.number(),
+    time: zod_1.z.number(),
+});
+exports.gameSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    status: exports.gameStatusSchema,
+    kartsGuids: zod_1.z.array(zod_1.z.string()),
+    powerUpsIds: zod_1.z.array(zod_1.z.string()),
+    gameTrackId: zod_1.z.string(),
+    type: exports.gameTypeSchema,
+    coins: zod_1.z.number(),
+    time: zod_1.z.number(),
+    speedConfig: zod_1.z.number(),
+    createdAt: zod_1.z.date(),
+    startedAt: zod_1.z.date().optional(),
+    finishedAt: zod_1.z.date().optional(),
+    finishedReason: exports.gameFinishedReasonSchema.optional(),
+    kartsState: zod_1.z.record(zod_1.z.string(), exports.gameKartStateSchema),
+    gameRanking: zod_1.z.array(exports.kartRankingItemSchema),
+});

package/dist/domains/game/Game.types.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { gameFinishedReasonSchema, gameKartStateSchema, gameSchema, gameStatusSchema, gameTypeSchema, gameWarningEventSchema, kartRankingItemSchema } from './Game.schema';
+export type GameType = z.infer<typeof gameTypeSchema>;
+export type GameStatus = z.infer<typeof gameStatusSchema>;
+export type GameFinishedReason = z.infer<typeof gameFinishedReasonSchema>;
+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>;

package/dist/domains/game/Game.types.js

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

package/dist/domains/game/battle/Battle.schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const battleKartStateSchema: z.ZodObject<{
+    coins: z.ZodNumber;
+    lives: z.ZodNumber;
+}, z.core.$strip>;
+export declare const battleSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    status: z.ZodEnum<{
+        readonly NON_STARTED: "non-started";
+        readonly ACTIVE: "active";
+        readonly YELLOW_FLAG: "yellow-flag";
+        readonly RED_FLAG: "red-flag";
+        readonly FINISHED: "finished";
+        readonly KART_ELIMINATED: "kart-eliminated";
+    }>;
+    kartsGuids: z.ZodArray<z.ZodString>;
+    powerUpsIds: z.ZodArray<z.ZodString>;
+    gameTrackId: z.ZodString;
+    coins: z.ZodNumber;
+    time: z.ZodNumber;
+    speedConfig: z.ZodNumber;
+    createdAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    finishedReason: z.ZodOptional<z.ZodEnum<{
+        readonly TIME_IS_OVER: "TIME_IS_OVER";
+        readonly GAME_KARTS_FINISHED: "GAME_KARTS_FINISHED";
+        readonly EMERGENCY: "EMERGENCY";
+        readonly BY_CONTROLLER: "BY_CONTROLLER";
+    }>>;
+    gameRanking: z.ZodArray<z.ZodObject<{
+        kartGuid: z.ZodString;
+        position: z.ZodNumber;
+        time: z.ZodNumber;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"Battle">;
+    lives: z.ZodNumber;
+    kartsState: z.ZodRecord<z.ZodString, z.ZodObject<{
+        coins: z.ZodNumber;
+        lives: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/domains/game/battle/Battle.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.battleSchema = exports.battleKartStateSchema = void 0;
+const zod_1 = require("zod");
+const Game_const_1 = require("../Game.const");
+const Game_schema_1 = require("../Game.schema");
+// --- Helper Schemas ---
+exports.battleKartStateSchema = Game_schema_1.gameKartStateSchema.extend({
+    lives: zod_1.z.number(),
+});
+// --- Main Battle Schema ---
+exports.battleSchema = Game_schema_1.gameSchema.extend({
+    type: zod_1.z.literal(Game_const_1.GAME_TYPE.Battle),
+    lives: zod_1.z.number(),
+    kartsState: zod_1.z.record(zod_1.z.string(), exports.battleKartStateSchema),
+});

package/dist/domains/game/battle/Battle.types.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { battleKartStateSchema, battleSchema } from './Battle.schema';
+export type BattleKartState = z.infer<typeof battleKartStateSchema>;
+export type Battle = z.infer<typeof battleSchema>;

package/dist/domains/game/battle/Battle.types.js

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

package/dist/domains/game/battle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Battle.schema';
+export * from './Battle.types';

package/dist/domains/game/battle/index.js

@@ -0,0 +1,18 @@
+"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("./Battle.schema"), exports);
+__exportStar(require("./Battle.types"), exports);

package/dist/domains/game/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Game.const';
+export * from './Game.schema';
+export * from './Game.types';
+export * from './battle';
+export * from './race';

package/dist/domains/game/index.js

@@ -0,0 +1,21 @@
+"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("./Game.const"), exports);
+__exportStar(require("./Game.schema"), exports);
+__exportStar(require("./Game.types"), exports);
+__exportStar(require("./battle"), exports);
+__exportStar(require("./race"), exports);

package/dist/domains/game/race/Race.schema.d.ts

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+export declare const kartProgressSchema: z.ZodObject<{
+    checkpointId: z.ZodString;
+    checkpointProgress: z.ZodNumber;
+    timestampISO: z.ZodObject<{
+        origin: z.ZodString;
+        server: z.ZodString;
+    }, z.core.$strip>;
+    lap: z.ZodNumber;
+    totalProgress: z.ZodNumber;
+}, z.core.$strip>;
+export declare const lapTimeSchema: z.ZodObject<{
+    lap: z.ZodNumber;
+    timeInSeconds: z.ZodNumber;
+    completedAt: z.ZodString;
+    completedAtCheckpointId: z.ZodString;
+    completedAtCheckpointProgress: z.ZodNumber;
+}, z.core.$strip>;
+export declare const raceKartStateSchema: z.ZodObject<{
+    coins: z.ZodNumber;
+    currentLap: z.ZodNumber;
+}, z.core.$strip>;
+export declare const raceRankingItemSchema: z.ZodObject<{
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    time: z.ZodNumber;
+    progress: z.ZodNumber;
+    lapsCompleted: z.ZodNumber;
+}, z.core.$strip>;
+export declare const rankingWithKartsAndLapTimesSchema: z.ZodObject<{
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    time: z.ZodNumber;
+    progress: z.ZodNumber;
+    lapsCompleted: z.ZodNumber;
+    lapTimes: z.ZodArray<z.ZodObject<{
+        lap: z.ZodNumber;
+        timeInSeconds: z.ZodNumber;
+        completedAt: z.ZodString;
+        completedAtCheckpointId: z.ZodString;
+        completedAtCheckpointProgress: z.ZodNumber;
+    }, z.core.$strip>>;
+    fastestLap: z.ZodNullable<z.ZodObject<{
+        lap: z.ZodNumber;
+        timeInSeconds: z.ZodNumber;
+        completedAt: z.ZodString;
+        completedAtCheckpointId: z.ZodString;
+        completedAtCheckpointProgress: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const raceSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    status: z.ZodEnum<{
+        readonly NON_STARTED: "non-started";
+        readonly ACTIVE: "active";
+        readonly YELLOW_FLAG: "yellow-flag";
+        readonly RED_FLAG: "red-flag";
+        readonly FINISHED: "finished";
+        readonly KART_ELIMINATED: "kart-eliminated";
+    }>;
+    kartsGuids: z.ZodArray<z.ZodString>;
+    powerUpsIds: z.ZodArray<z.ZodString>;
+    gameTrackId: z.ZodString;
+    coins: z.ZodNumber;
+    time: z.ZodNumber;
+    speedConfig: z.ZodNumber;
+    createdAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    finishedReason: z.ZodOptional<z.ZodEnum<{
+        readonly TIME_IS_OVER: "TIME_IS_OVER";
+        readonly GAME_KARTS_FINISHED: "GAME_KARTS_FINISHED";
+        readonly EMERGENCY: "EMERGENCY";
+        readonly BY_CONTROLLER: "BY_CONTROLLER";
+    }>>;
+    type: z.ZodLiteral<"Race">;
+    laps: z.ZodNumber;
+    kartsState: z.ZodRecord<z.ZodString, z.ZodObject<{
+        coins: z.ZodNumber;
+        currentLap: z.ZodNumber;
+    }, z.core.$strip>>;
+    kartsProgress: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        checkpointId: z.ZodString;
+        checkpointProgress: z.ZodNumber;
+        timestampISO: z.ZodObject<{
+            origin: z.ZodString;
+            server: z.ZodString;
+        }, z.core.$strip>;
+        lap: z.ZodNumber;
+        totalProgress: z.ZodNumber;
+    }, z.core.$strip>>>;
+    gameRanking: z.ZodArray<z.ZodObject<{
+        kartGuid: z.ZodString;
+        position: z.ZodNumber;
+        time: z.ZodNumber;
+        progress: z.ZodNumber;
+        lapsCompleted: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const raceWithDetailedRankingSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Race">;
+    id: z.ZodNumber;
+    coins: z.ZodNumber;
+    time: z.ZodNumber;
+    status: z.ZodEnum<{
+        readonly NON_STARTED: "non-started";
+        readonly ACTIVE: "active";
+        readonly YELLOW_FLAG: "yellow-flag";
+        readonly RED_FLAG: "red-flag";
+        readonly FINISHED: "finished";
+        readonly KART_ELIMINATED: "kart-eliminated";
+    }>;
+    kartsGuids: z.ZodArray<z.ZodString>;
+    powerUpsIds: z.ZodArray<z.ZodString>;
+    gameTrackId: z.ZodString;
+    speedConfig: z.ZodNumber;
+    createdAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    finishedReason: z.ZodOptional<z.ZodEnum<{
+        readonly TIME_IS_OVER: "TIME_IS_OVER";
+        readonly GAME_KARTS_FINISHED: "GAME_KARTS_FINISHED";
+        readonly EMERGENCY: "EMERGENCY";
+        readonly BY_CONTROLLER: "BY_CONTROLLER";
+    }>>;
+    kartsState: z.ZodRecord<z.ZodString, z.ZodObject<{
+        coins: z.ZodNumber;
+        currentLap: z.ZodNumber;
+    }, z.core.$strip>>;
+    laps: z.ZodNumber;
+    gameRanking: z.ZodArray<z.ZodObject<{
+        kartGuid: z.ZodString;
+        position: z.ZodNumber;
+        time: z.ZodNumber;
+        progress: z.ZodNumber;
+        lapsCompleted: z.ZodNumber;
+        lapTimes: z.ZodArray<z.ZodObject<{
+            lap: z.ZodNumber;
+            timeInSeconds: z.ZodNumber;
+            completedAt: z.ZodString;
+            completedAtCheckpointId: z.ZodString;
+            completedAtCheckpointProgress: z.ZodNumber;
+        }, z.core.$strip>>;
+        fastestLap: z.ZodNullable<z.ZodObject<{
+            lap: z.ZodNumber;
+            timeInSeconds: z.ZodNumber;
+            completedAt: z.ZodString;
+            completedAtCheckpointId: z.ZodString;
+            completedAtCheckpointProgress: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const kartLapTimesSchema: z.ZodObject<{
+    kartGuid: z.ZodString;
+    lapTimes: z.ZodArray<z.ZodObject<{
+        lap: z.ZodNumber;
+        timeInSeconds: z.ZodNumber;
+        completedAt: z.ZodString;
+        completedAtCheckpointId: z.ZodString;
+        completedAtCheckpointProgress: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/domains/game/race/Race.schema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kartLapTimesSchema = exports.raceWithDetailedRankingSchema = exports.raceSchema = exports.rankingWithKartsAndLapTimesSchema = exports.raceRankingItemSchema = exports.raceKartStateSchema = exports.lapTimeSchema = exports.kartProgressSchema = void 0;
+const zod_1 = require("zod");
+const Game_const_1 = require("../Game.const");
+const Game_schema_1 = require("../Game.schema");
+// --- Helper Schemas ---
+exports.kartProgressSchema = zod_1.z.object({
+    checkpointId: zod_1.z.string(),
+    checkpointProgress: zod_1.z.number(),
+    timestampISO: zod_1.z.object({
+        origin: zod_1.z.string(),
+        server: zod_1.z.string(),
+    }),
+    lap: zod_1.z.number(),
+    totalProgress: zod_1.z.number(),
+});
+exports.lapTimeSchema = zod_1.z.object({
+    lap: zod_1.z.number(),
+    timeInSeconds: zod_1.z.number(),
+    completedAt: zod_1.z.string(),
+    completedAtCheckpointId: zod_1.z.string(),
+    completedAtCheckpointProgress: zod_1.z.number(),
+});
+exports.raceKartStateSchema = Game_schema_1.gameKartStateSchema.extend({
+    currentLap: zod_1.z.number(),
+});
+exports.raceRankingItemSchema = Game_schema_1.kartRankingItemSchema.extend({
+    progress: zod_1.z.number(),
+    lapsCompleted: zod_1.z.number(),
+});
+exports.rankingWithKartsAndLapTimesSchema = exports.raceRankingItemSchema.extend({
+    lapTimes: zod_1.z.array(exports.lapTimeSchema),
+    fastestLap: exports.lapTimeSchema.nullable(),
+});
+// --- Main Race Schema ---
+exports.raceSchema = Game_schema_1.gameSchema.extend({
+    type: zod_1.z.literal(Game_const_1.GAME_TYPE.Race),
+    laps: zod_1.z.number(),
+    kartsState: zod_1.z.record(zod_1.z.string(), exports.raceKartStateSchema),
+    kartsProgress: zod_1.z.record(zod_1.z.string(), zod_1.z.array(exports.kartProgressSchema)),
+    gameRanking: zod_1.z.array(exports.raceRankingItemSchema),
+});
+exports.raceWithDetailedRankingSchema = exports.raceSchema.omit({ kartsProgress: true }).extend({
+    gameRanking: zod_1.z.array(exports.rankingWithKartsAndLapTimesSchema),
+});
+exports.kartLapTimesSchema = zod_1.z.object({
+    kartGuid: zod_1.z.string(),
+    lapTimes: zod_1.z.array(exports.lapTimeSchema),
+});

package/dist/domains/game/race/Race.types.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { kartLapTimesSchema, kartProgressSchema, lapTimeSchema, raceKartStateSchema, raceRankingItemSchema, raceSchema, raceWithDetailedRankingSchema, rankingWithKartsAndLapTimesSchema } from './Race.schema';
+export type KartProgress = z.infer<typeof kartProgressSchema>;
+export type LapTime = z.infer<typeof lapTimeSchema>;
+export type KartLapTimes = z.infer<typeof kartLapTimesSchema>;
+export type RaceKartState = z.infer<typeof raceKartStateSchema>;
+export type RaceRankingItem = z.infer<typeof raceRankingItemSchema>;
+export type RankingWithKartsAndLapTimes = z.infer<typeof rankingWithKartsAndLapTimesSchema>;
+export type Race = z.infer<typeof raceSchema>;
+export type RaceWithDetailedRanking = z.infer<typeof raceWithDetailedRankingSchema>;

package/dist/domains/game/race/Race.types.js

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

package/dist/domains/game/race/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Race.schema';
+export * from './Race.types';

package/dist/domains/game/race/index.js

@@ -0,0 +1,18 @@
+"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("./Race.schema"), exports);
+__exportStar(require("./Race.types"), exports);

package/dist/domains/gameTrack/GameTrack.schema.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const gameTrackGameDefaultValuesSchema: z.ZodObject<{
+    speed: z.ZodArray<z.ZodNumber>;
+    powerUpIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const gameTrackKartsConfigSchema: z.ZodObject<{
+    defaultSpeed: z.ZodNumber;
+    powerUpTime: z.ZodNumber;
+    rgbBrightness: z.ZodNumber;
+    flagBrightness: z.ZodNumber;
+    diskSensorBallShooter: z.ZodObject<{
+        prepareVoltagePercentage: z.ZodOptional<z.ZodNumber>;
+        attackVoltagePercentage: z.ZodOptional<z.ZodNumber>;
+        waitTimeAfterHit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    ballSensorDiskThrower: z.ZodObject<{
+        waitTimeAfterHit: z.ZodNumber;
+    }, z.core.$strip>;
+    lowSpeed: z.ZodNumber;
+}, z.core.$strip>;
+export declare const gameTrackKartConfigSchema: z.ZodObject<{
+    gameTrackId: z.ZodString;
+    kartId: z.ZodNumber;
+    color: z.ZodEnum<{
+        readonly Black: "Black";
+        readonly Red: "Red";
+        readonly Blue: "Blue";
+        readonly Green: "Green";
+        readonly Yellow: "Yellow";
+        readonly Violet: "Violet";
+        readonly Cyan: "Cyan";
+        readonly Magenta: "Magenta";
+        readonly Orange: "Orange";
+        readonly White: "White";
+        readonly GreenYellow: "GreenYellow";
+        readonly SaddleBrown: "SaddleBrown";
+    }>;
+    kartNumber: z.ZodNumber;
+    mac: z.ZodString;
+}, z.core.$strip>;
+export declare const gameTrackSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>;
+    checkpoints: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        address: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            readonly TRACK: "Track";
+            readonly POWER_UP: "PowerUp";
+            readonly SHORTCUT: "Shortcut";
+            readonly UNKNOWN: "Unknown";
+        }>;
+        progress: z.ZodNumber;
+    }, z.core.$strip>>;
+    kartsConfig: z.ZodObject<{
+        defaultSpeed: z.ZodNumber;
+        powerUpTime: z.ZodNumber;
+        rgbBrightness: z.ZodNumber;
+        flagBrightness: z.ZodNumber;
+        diskSensorBallShooter: z.ZodObject<{
+            prepareVoltagePercentage: z.ZodOptional<z.ZodNumber>;
+            attackVoltagePercentage: z.ZodOptional<z.ZodNumber>;
+            waitTimeAfterHit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        ballSensorDiskThrower: z.ZodObject<{
+            waitTimeAfterHit: z.ZodNumber;
+        }, z.core.$strip>;
+        lowSpeed: z.ZodNumber;
+    }, z.core.$strip>;
+    macAddress: z.ZodOptional<z.ZodString>;
+    isConnected: z.ZodBoolean;
+    gameDefaultValues: z.ZodOptional<z.ZodObject<{
+        speed: z.ZodArray<z.ZodNumber>;
+        powerUpIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/domains/gameTrack/GameTrack.schema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gameTrackSchema = exports.gameTrackKartConfigSchema = exports.gameTrackKartsConfigSchema = exports.gameTrackGameDefaultValuesSchema = void 0;
+const zod_1 = require("zod");
+const checkpoint_1 = require("../checkpoint");
+const color_1 = require("../color");
+const game_1 = require("../game");
+const hardware_1 = require("../hardware");
+exports.gameTrackGameDefaultValuesSchema = zod_1.z.object({
+    speed: zod_1.z.array(zod_1.z.number()),
+    powerUpIds: zod_1.z.array(zod_1.z.string()),
+});
+exports.gameTrackKartsConfigSchema = zod_1.z.object({
+    defaultSpeed: zod_1.z.number().min(0).max(100),
+    powerUpTime: zod_1.z.number().min(1).max(25),
+    rgbBrightness: zod_1.z.number().min(0).max(100),
+    flagBrightness: zod_1.z.number().min(0).max(100),
+    diskSensorBallShooter: hardware_1.configDiskSensorBallShooterModuleOptionsSchema,
+    ballSensorDiskThrower: hardware_1.configureBallSensorDiskThrowerModuleOptionsSchema,
+    lowSpeed: zod_1.z.number().min(0).max(100),
+});
+exports.gameTrackKartConfigSchema = zod_1.z.object({
+    gameTrackId: zod_1.z.string(),
+    kartId: zod_1.z.number(),
+    color: color_1.colorNameSchema,
+    kartNumber: zod_1.z.number(),
+    mac: zod_1.z.string(),
+});
+exports.gameTrackSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    type: game_1.gameTypeSchema,
+    checkpoints: zod_1.z.array(checkpoint_1.checkpointSchema),
+    kartsConfig: exports.gameTrackKartsConfigSchema,
+    macAddress: zod_1.z.string().optional(),
+    isConnected: zod_1.z.boolean(),
+    gameDefaultValues: exports.gameTrackGameDefaultValuesSchema.optional(),
+});

package/dist/domains/gameTrack/GameTrack.types.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { gameTrackGameDefaultValuesSchema, gameTrackKartConfigSchema, gameTrackKartsConfigSchema, gameTrackSchema } from './GameTrack.schema';
+export type GameTrackGameDefaultValues = z.infer<typeof gameTrackGameDefaultValuesSchema>;
+export type GameTrackKartsConfig = z.infer<typeof gameTrackKartsConfigSchema>;
+export type GameTrackKartConfig = z.infer<typeof gameTrackKartConfigSchema>;
+export type GameTrack = z.infer<typeof gameTrackSchema>;

package/dist/domains/gameTrack/GameTrack.types.js

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

package/dist/domains/gameTrack/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GameTrack.schema';
+export * from './GameTrack.types';