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

package/dist/domains/kart/Kart.schema.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+export declare const kartStatusSchema: z.ZodEnum<{
+    readonly STAND_BY: "standBy";
+    readonly IN_GAME: "in-game";
+    readonly YELLOW_FLAG: "yellow-flag";
+    readonly EMERGENCY: "emergency";
+    readonly PITS: "pits";
+    readonly ELIMINATED: "eliminated";
+}>;
+export declare const kartShieldSchema: z.ZodObject<{
+    isActive: z.ZodBoolean;
+    duration: z.ZodNumber;
+}, z.core.$strip>;
+export declare const kartGameSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>;
+}, z.core.$strip>;
+export declare const kartSchema: z.ZodObject<{
+    guid: z.ZodString;
+    id: z.ZodNumber;
+    mac: z.ZodString;
+    hostname: z.ZodString;
+    isConnected: z.ZodBoolean;
+    status: z.ZodEnum<{
+        readonly STAND_BY: "standBy";
+        readonly IN_GAME: "in-game";
+        readonly YELLOW_FLAG: "yellow-flag";
+        readonly EMERGENCY: "emergency";
+        readonly PITS: "pits";
+        readonly ELIMINATED: "eliminated";
+    }>;
+    shield: z.ZodObject<{
+        isActive: z.ZodBoolean;
+        duration: z.ZodNumber;
+    }, z.core.$strip>;
+    gameTrackId: z.ZodString;
+    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";
+    }>;
+    number: z.ZodNumber;
+    currentGame: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        type: z.ZodEnum<{
+            readonly Race: "Race";
+            readonly Battle: "Battle";
+        }>;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isSubscribedToHardwareStatus: z.ZodBoolean;
+    hardwareState: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        speed: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                readonly ACTIVATED: "Activated";
+                readonly DEACTIVATED: "Deactivated";
+                readonly UNKNOWN: "Unknown";
+                readonly ERROR: "Error";
+                readonly STANDBY: "Standby";
+                readonly CHANGING_SPEED: "Changing Speed";
+                readonly IN_EMERGENCY: "In Emergency";
+            }>;
+            current: z.ZodNumber;
+            configured: z.ZodNumber;
+        }, z.core.$strip>>;
+        rgb: z.ZodNullable<z.ZodEnum<{
+            readonly SHOWING_COLOR: "Showing Color";
+            readonly NOT_CONFIGURED: "Not Configured";
+            readonly CONFIGURING_RGB: "Configuring RGB";
+            readonly SHOWING_EFFECT: "Showing Effect";
+            readonly UNKNOWN: "Unknown";
+            readonly ERROR: "Error";
+        }>>;
+        flag: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                readonly ACTIVATED: "Activated";
+                readonly DEACTIVATED: "Deactivated";
+                readonly UNKNOWN: "Unknown";
+                readonly ERROR: "Error";
+                readonly STANDBY: "Standby";
+                readonly HIT: "Hit";
+                readonly SHOWING_IMAGE: "Showing Image";
+                readonly SHOWING_ANIMATION: "Showing Animation";
+            }>;
+            checkpointType: z.ZodNullable<z.ZodEnum<{
+                readonly TRACK: "Track";
+                readonly POWER_UP: "PowerUp";
+                readonly SHORTCUT: "Shortcut";
+                readonly UNKNOWN: "Unknown";
+            }>>;
+            checkpointAddress: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        screen: z.ZodNullable<z.ZodEnum<{
+            readonly ACTIVATED: "Activated";
+            readonly DEACTIVATED: "Deactivated";
+            readonly UNKNOWN: "Unknown";
+            readonly ERROR: "Error";
+            readonly DEBUG: "Debug";
+        }>>;
+        isConnectedToServer: z.ZodBoolean;
+        isSteeringWheelPressed: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    currentPowerUp: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        readonly BATTLE_GOD: "Battle God";
+        readonly BATTLE_STAR: "Battle Star";
+        readonly BATTLE_SHOT: "Battle Shot";
+        readonly BATTLE_NITRO: "Battle Nitro";
+        readonly BATTLE_PULSE: "Battle Pulse";
+        readonly BATTLE_TRAP: "Battle Trap";
+        readonly BATTLE_SHIELD: "Battle Shield";
+        readonly BATTLE_TURBO: "Battle Turbo";
+        readonly BATTLE_BLUE_SHOT: "Battle Blue Shot";
+    }>>>;
+    currentDamage: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        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";
+    }>>>;
+}, z.core.$strip>;

package/dist/domains/kart/Kart.schema.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kartSchema = exports.kartGameSchema = exports.kartShieldSchema = exports.kartStatusSchema = void 0;
+const zod_1 = require("zod");
+const color_1 = require("../color");
+const damage_1 = require("../damage");
+const game_1 = require("../game");
+const KartHardwareState_schema_1 = require("../hardware/KartHardwareState.schema");
+const PowerUpAttributes_schema_1 = require("../powerUp/PowerUpAttributes.schema");
+const Kart_const_1 = require("./Kart.const");
+exports.kartStatusSchema = zod_1.z.enum(Kart_const_1.KART_STATUS);
+exports.kartShieldSchema = zod_1.z.object({
+    isActive: zod_1.z.boolean(),
+    duration: zod_1.z.number(),
+});
+exports.kartGameSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: game_1.gameTypeSchema,
+});
+exports.kartSchema = zod_1.z.object({
+    guid: zod_1.z.string(),
+    id: zod_1.z.number(),
+    mac: zod_1.z.string(),
+    hostname: zod_1.z.string(),
+    isConnected: zod_1.z.boolean(),
+    status: exports.kartStatusSchema,
+    shield: exports.kartShieldSchema,
+    gameTrackId: zod_1.z.string(),
+    color: color_1.colorNameSchema,
+    number: zod_1.z.number(),
+    currentGame: exports.kartGameSchema.nullable().optional(),
+    description: zod_1.z.string().nullable().optional(),
+    isSubscribedToHardwareStatus: zod_1.z.boolean(),
+    hardwareState: KartHardwareState_schema_1.kartHardwareStateSchema.nullable().optional(),
+    currentPowerUp: PowerUpAttributes_schema_1.powerUpNameSchema.nullable().optional(),
+    currentDamage: damage_1.damageEffectNameSchema.nullable().optional(),
+});

package/dist/domains/kart/Kart.types.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { kartGameSchema, kartSchema, kartShieldSchema, kartStatusSchema } from './Kart.schema';
+export type KartStatus = z.infer<typeof kartStatusSchema>;
+export type KartShield = z.infer<typeof kartShieldSchema>;
+export type KartGame = z.infer<typeof kartGameSchema>;
+export type Kart = z.infer<typeof kartSchema>;

package/dist/domains/kart/Kart.types.js

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

package/dist/domains/kart/KartHardwareState.schema.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const kartHardwareStateSchema: z.ZodObject<{
+    speed: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            readonly ACTIVATED: "Activated";
+            readonly DEACTIVATED: "Deactivated";
+            readonly UNKNOWN: "Unknown";
+            readonly ERROR: "Error";
+            readonly STANDBY: "Standby";
+            readonly CHANGING_SPEED: "Changing Speed";
+            readonly IN_EMERGENCY: "In Emergency";
+        }>;
+        current: z.ZodNumber;
+        configured: z.ZodNumber;
+    }, z.core.$strip>>;
+    rgb: z.ZodNullable<z.ZodEnum<{
+        readonly SHOWING_COLOR: "Showing Color";
+        readonly NOT_CONFIGURED: "Not Configured";
+        readonly CONFIGURING_RGB: "Configuring RGB";
+        readonly SHOWING_EFFECT: "Showing Effect";
+        readonly UNKNOWN: "Unknown";
+        readonly ERROR: "Error";
+    }>>;
+    flag: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            readonly ACTIVATED: "Activated";
+            readonly DEACTIVATED: "Deactivated";
+            readonly UNKNOWN: "Unknown";
+            readonly ERROR: "Error";
+            readonly STANDBY: "Standby";
+            readonly HIT: "Hit";
+            readonly SHOWING_IMAGE: "Showing Image";
+            readonly SHOWING_ANIMATION: "Showing Animation";
+        }>;
+        checkpointType: z.ZodNullable<z.ZodEnum<{
+            readonly TRACK: "Track";
+            readonly POWER_UP: "PowerUp";
+            readonly SHORTCUT: "Shortcut";
+            readonly UNKNOWN: "Unknown";
+        }>>;
+        checkpointAddress: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    screen: z.ZodNullable<z.ZodEnum<{
+        readonly ACTIVATED: "Activated";
+        readonly DEACTIVATED: "Deactivated";
+        readonly UNKNOWN: "Unknown";
+        readonly ERROR: "Error";
+        readonly DEBUG: "Debug";
+    }>>;
+    isConnectedToServer: z.ZodBoolean;
+    isSteeringWheelPressed: z.ZodBoolean;
+}, z.core.$strip>;

package/dist/domains/kart/KartHardwareState.schema.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kartHardwareStateSchema = void 0;
+const zod_1 = require("zod");
+const checkpoint_1 = require("../checkpoint");
+const hardware_1 = require("../hardware");
+exports.kartHardwareStateSchema = zod_1.z.object({
+    speed: zod_1.z
+        .object({
+        status: hardware_1.speedStatusSchema,
+        current: zod_1.z.number(),
+        configured: zod_1.z.number(),
+    })
+        .nullable(),
+    rgb: hardware_1.rgbStatusSchema.nullable(),
+    flag: zod_1.z
+        .object({
+        status: hardware_1.flagStatusSchema,
+        checkpointType: checkpoint_1.checkpointTypeSchema.nullable(),
+        checkpointAddress: zod_1.z.number().nullable(),
+    })
+        .nullable(),
+    screen: hardware_1.screenStatusSchema.nullable(),
+    isConnectedToServer: zod_1.z.boolean(),
+    isSteeringWheelPressed: zod_1.z.boolean(),
+});

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

@@ -0,0 +1,3 @@
+export * from './Kart.const';
+export * from './Kart.schema';
+export * from './Kart.types';

package/dist/domains/kart/index.js

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

package/dist/domains/kartTracking/KartTracking.schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const checkpointEventSchema: 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;
+    index: z.ZodNumber;
+    timestampISO: z.ZodObject<{
+        origin: z.ZodString;
+        server: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const kartTrackingSchema: z.ZodObject<{
+    macAddress: z.ZodString;
+    checkpointsEvents: z.ZodOptional<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;
+        index: z.ZodNumber;
+        timestampISO: z.ZodObject<{
+            origin: z.ZodString;
+            server: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;

package/dist/domains/kartTracking/KartTracking.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kartTrackingSchema = exports.checkpointEventSchema = void 0;
+const zod_1 = require("zod");
+const checkpoint_1 = require("../checkpoint");
+exports.checkpointEventSchema = checkpoint_1.checkpointSchema.extend({
+    index: zod_1.z.number(),
+    timestampISO: zod_1.z.object({
+        origin: zod_1.z.string(),
+        server: zod_1.z.string(),
+    }),
+});
+exports.kartTrackingSchema = zod_1.z.object({
+    macAddress: zod_1.z.string(),
+    checkpointsEvents: zod_1.z.array(exports.checkpointEventSchema).optional(),
+});

package/dist/domains/kartTracking/KartTracking.types.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { checkpointEventSchema, kartTrackingSchema } from './KartTracking.schema';
+export type CheckpointEvent = z.infer<typeof checkpointEventSchema>;
+export type KartTracking = z.infer<typeof kartTrackingSchema>;

package/dist/domains/kartTracking/KartTracking.types.js

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

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

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

package/dist/domains/kartTracking/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("./KartTracking.schema"), exports);
+__exportStar(require("./KartTracking.types"), exports);

package/dist/domains/pagination/Pagination.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const paginationMetadataSchema: z.ZodObject<{
+    nextCursor: z.ZodOptional<z.ZodString>;
+    hasMore: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export declare const paginatedResponseSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    data: z.ZodArray<T>;
+    meta: z.ZodObject<{
+        nextCursor: z.ZodOptional<z.ZodString>;
+        hasMore: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/domains/pagination/Pagination.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginatedResponseSchema = exports.paginationMetadataSchema = void 0;
+const zod_1 = require("zod");
+exports.paginationMetadataSchema = zod_1.z.object({
+    nextCursor: zod_1.z.string().optional(),
+    hasMore: zod_1.z.boolean().optional(),
+    limit: zod_1.z.number(),
+});
+const paginatedResponseSchema = (itemSchema) => {
+    return zod_1.z.object({
+        data: zod_1.z.array(itemSchema),
+        meta: exports.paginationMetadataSchema,
+    });
+};
+exports.paginatedResponseSchema = paginatedResponseSchema;

package/dist/domains/pagination/Pagination.types.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { paginationMetadataSchema } from './Pagination.schema';
+export type Pagination = z.infer<typeof paginationMetadataSchema>;

package/dist/domains/pagination/Pagination.types.js

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

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

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

package/dist/domains/pagination/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("./Pagination.schema"), exports);
+__exportStar(require("./Pagination.types"), exports);

package/dist/domains/player/Player.const.d.ts

@@ -0,0 +1,4 @@
+export declare const PLAYER_TYPE: {
+    readonly ADULT: "ADULT";
+    readonly MINOR: "MINOR";
+};

package/dist/domains/player/Player.const.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAYER_TYPE = void 0;
+exports.PLAYER_TYPE = {
+    ADULT: 'ADULT',
+    MINOR: 'MINOR', // Managed by a Guardian
+};

package/dist/domains/player/Player.schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export declare const playerTypeSchema: z.ZodEnum<{
+    readonly ADULT: "ADULT";
+    readonly MINOR: "MINOR";
+}>;
+export declare const playerWaiverStatusSchema: z.ZodObject<{
+    isSigned: z.ZodDefault<z.ZodBoolean>;
+    waiverId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+    templateVersion: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, z.core.$strip>;
+export declare const playerStatsSchema: z.ZodObject<{
+    totalRaces: z.ZodDefault<z.ZodNumber>;
+    bestTimeMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    xp: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const playerSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    nickname: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    birthDate: z.ZodDate;
+    type: z.ZodDefault<z.ZodEnum<{
+        readonly ADULT: "ADULT";
+        readonly MINOR: "MINOR";
+    }>>;
+    ownerUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+    isGuest: z.ZodDefault<z.ZodBoolean>;
+    waiver: z.ZodObject<{
+        isSigned: z.ZodDefault<z.ZodBoolean>;
+        waiverId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        templateVersion: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    }, z.core.$strip>;
+    stats: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        totalRaces: z.ZodDefault<z.ZodNumber>;
+        bestTimeMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        xp: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const createPlayerSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+        readonly ADULT: "ADULT";
+        readonly MINOR: "MINOR";
+    }>>;
+    nickname: z.ZodString;
+    birthDate: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export declare const signWaiverSchema: z.ZodObject<{
+    signature: z.ZodOptional<z.ZodString>;
+    accepted: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export declare const createMinorPlayerSchema: z.ZodObject<{
+    nickname: z.ZodString;
+    birthDate: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;

package/dist/domains/player/Player.schema.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMinorPlayerSchema = exports.signWaiverSchema = exports.createPlayerSchema = exports.playerSchema = exports.playerStatsSchema = exports.playerWaiverStatusSchema = exports.playerTypeSchema = void 0;
+const zod_1 = require("zod");
+const Player_const_1 = require("./Player.const");
+exports.playerTypeSchema = zod_1.z.enum(Player_const_1.PLAYER_TYPE);
+exports.playerWaiverStatusSchema = zod_1.z.object({
+    isSigned: zod_1.z.boolean().default(false),
+    waiverId: zod_1.z.uuidv4().nullable().optional(),
+    templateVersion: zod_1.z.string().optional(),
+    expiresAt: zod_1.z.date().nullable().optional(),
+});
+exports.playerStatsSchema = zod_1.z.object({
+    totalRaces: zod_1.z.number().int().default(0),
+    bestTimeMs: zod_1.z.number().int().nullable().optional(),
+    xp: zod_1.z.number().int().default(0),
+});
+exports.playerSchema = zod_1.z.object({
+    id: zod_1.z.uuidv4(),
+    nickname: zod_1.z.string().min(2).max(20),
+    avatarUrl: zod_1.z.url().optional(),
+    birthDate: zod_1.z.date(),
+    type: exports.playerTypeSchema.default(Player_const_1.PLAYER_TYPE.ADULT),
+    ownerUserId: zod_1.z.uuidv4().nullable().optional(),
+    isGuest: zod_1.z.boolean().default(true),
+    waiver: exports.playerWaiverStatusSchema,
+    // TODO: Add the stats here, to aovid extra queries
+    stats: exports.playerStatsSchema.optional().nullable(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.createPlayerSchema = exports.playerSchema
+    .pick({
+    nickname: true,
+    type: true,
+})
+    .extend({
+    birthDate: zod_1.z.coerce.date(),
+});
+exports.signWaiverSchema = zod_1.z.object({
+    signature: zod_1.z.string().optional(), // Base64 or simply a boolean acceptance. Let's make it flexible.
+    accepted: zod_1.z.literal(true), // They must explicitly pass accepted: true
+});
+exports.createMinorPlayerSchema = zod_1.z.object({
+    nickname: zod_1.z.string().min(2).max(20),
+    birthDate: zod_1.z.coerce.date(),
+    // For a minor, the signature is implicitly granted by the tutor calling this endpoint
+});

package/dist/domains/player/Player.types.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { 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>;

package/dist/domains/player/Player.types.js

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

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

@@ -0,0 +1,3 @@
+export * from './Player.const';
+export * from './Player.schema';
+export * from './Player.types';

package/dist/domains/player/index.js

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

package/dist/domains/powerUp/PowerUp.const.d.ts

@@ -0,0 +1,21 @@
+export declare const POWER_UP_NAME: {
+    readonly BATTLE_GOD: "Battle God";
+    readonly BATTLE_STAR: "Battle Star";
+    readonly BATTLE_SHOT: "Battle Shot";
+    readonly BATTLE_NITRO: "Battle Nitro";
+    readonly BATTLE_PULSE: "Battle Pulse";
+    readonly BATTLE_TRAP: "Battle Trap";
+    readonly BATTLE_SHIELD: "Battle Shield";
+    readonly BATTLE_TURBO: "Battle Turbo";
+    readonly BATTLE_BLUE_SHOT: "Battle Blue Shot";
+};
+export declare const POWER_UP_TYPE: {
+    readonly Damage: "Damage";
+    readonly Shield: "Shield";
+    readonly Speed: "Speed";
+};
+export declare const POWER_UP_TARGET: {
+    readonly Self: "Self";
+    readonly Any: "Any";
+    readonly All: "All";
+};

package/dist/domains/powerUp/PowerUp.const.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POWER_UP_TARGET = exports.POWER_UP_TYPE = exports.POWER_UP_NAME = void 0;
+exports.POWER_UP_NAME = {
+    BATTLE_GOD: 'Battle God',
+    BATTLE_STAR: 'Battle Star',
+    BATTLE_SHOT: 'Battle Shot',
+    BATTLE_NITRO: 'Battle Nitro',
+    BATTLE_PULSE: 'Battle Pulse',
+    BATTLE_TRAP: 'Battle Trap',
+    BATTLE_SHIELD: 'Battle Shield',
+    BATTLE_TURBO: 'Battle Turbo',
+    BATTLE_BLUE_SHOT: 'Battle Blue Shot',
+};
+exports.POWER_UP_TYPE = {
+    Damage: 'Damage',
+    Shield: 'Shield',
+    Speed: 'Speed',
+};
+exports.POWER_UP_TARGET = {
+    Self: 'Self',
+    Any: 'Any',
+    All: 'All',
+};