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

package/src/domains/hardware/speed/index.ts

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

package/src/domains/hardware/star-laser/StarLaser.const.ts

@@ -0,0 +1,16 @@
+export const STAR_LASER_COMMAND = {
+  ACTIVATE: 'Activate',
+  DEACTIVATE: 'Deactivate',
+  INIT_ATTACK: 'Init Attack',
+  CONFIGURE: 'Configure',
+  NONE: 'None',
+} as const;
+
+export const STAR_LASER_STATUS = {
+  STANDBY: 'Standby',
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  ATTACKING: 'Attacking',
+  HIT: 'Hit',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/hardware/star-laser/StarLaser.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { STAR_LASER_COMMAND, STAR_LASER_STATUS } from './StarLaser.const';
+
+export const starLaserCommandSchema = z.enum(STAR_LASER_COMMAND);
+
+export const starLaserStatusSchema = z.enum(STAR_LASER_STATUS);
+
+export const starLaserConfigureModuleOptionsSchema = z.object({
+  kartId: z.number(),
+  starAttackTime: z.number().min(1).max(25),
+  laserAttackTime: z.number().min(1).max(25),
+});
+
+export const starLaserSendActionsOptionsSchema = z.object({
+  starAction: starLaserCommandSchema.optional(),
+  laserAction: starLaserCommandSchema.optional(),
+});
+
+export const starLaserModuleStatusSchema = z.object({
+  starStatus: starLaserStatusSchema,
+  laserStatus: starLaserStatusSchema,
+  starHitByKartId: z.number().nullable(),
+  laserHitByKartId: z.number().nullable(),
+});

package/src/domains/hardware/star-laser/StarLaser.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  starLaserCommandSchema,
+  starLaserConfigureModuleOptionsSchema,
+  starLaserModuleStatusSchema,
+  starLaserSendActionsOptionsSchema,
+  starLaserStatusSchema,
+} from './StarLaser.schema';
+
+export type StarLaserCommand = z.infer<typeof starLaserCommandSchema>;
+export type StarLaserStatus = z.infer<typeof starLaserStatusSchema>;
+export type StarLaserConfigureModuleOptions = z.infer<typeof starLaserConfigureModuleOptionsSchema>;
+export type StarLaserSendActionsOptions = z.infer<typeof starLaserSendActionsOptionsSchema>;
+export type StarLaserModuleStatus = z.infer<typeof starLaserModuleStatusSchema>;

package/src/domains/hardware/star-laser/index.ts

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

package/src/domains/hardware/steering-wheel/SteeringWheel.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const steeringWheelModuleStatusSchema = z.object({
+  isLeftButtonPressed: z.boolean(),
+  isRightButtonPressed: z.boolean(),
+});

package/src/domains/hardware/steering-wheel/SteeringWheel.types.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { steeringWheelModuleStatusSchema } from './SteeringWheel.schema';
+
+export type SteeringWheelModuleStatus = z.infer<typeof steeringWheelModuleStatusSchema>;

package/src/domains/hardware/steering-wheel/index.ts

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

package/src/domains/index.ts

@@ -0,0 +1,20 @@
+export * from './checkpoint';
+export * from './color';
+export * from './damage';
+export * from './command';
+export * from './flow';
+export * from './game';
+export * from './gameTrack';
+export * from './hardware';
+export * from './kart';
+export * from './kartTracking';
+export * from './powerUp';
+export * from './racingTeam';
+export * from './socket';
+export * from './ticketing';
+export * from './user';
+export * from './pagination';
+export * from './response';
+export * from './role';
+export * from './sounds';
+export * from './utils';

package/src/domains/kart/Kart.const.ts

@@ -0,0 +1,13 @@
+export const KART_STATUS = {
+  STAND_BY: 'standBy',
+  IN_GAME: 'in-game',
+  YELLOW_FLAG: 'yellow-flag',
+  EMERGENCY: 'emergency',
+  PITS: 'pits',
+  ELIMINATED: 'eliminated',
+} as const;
+
+export const KART_FINAL_STATE = {
+  VICTORY: 'Victory',
+  DEFEAT: 'Defeat',
+} as const;

package/src/domains/kart/Kart.schema.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { colorNameSchema } from '../color';
+import { damageEffectNameSchema } from '../damage';
+import { gameTypeSchema } from '../game';
+import { kartHardwareStateSchema } from '../hardware';
+import { powerUpNameSchema } from '../powerUp/PowerUpAttributes.schema';
+import { KART_STATUS } from './Kart.const';
+
+export const kartStatusSchema = z.enum(KART_STATUS);
+
+export const kartShieldSchema = z.object({
+  isActive: z.boolean(),
+  duration: z.number(),
+});
+
+export const kartGameSchema = z.object({
+  id: z.number(),
+  type: gameTypeSchema,
+});
+
+export const kartSchema = z.object({
+  guid: z.string(),
+  id: z.number(),
+  mac: z.string(),
+  hostname: z.string(),
+  isConnected: z.boolean(),
+  status: kartStatusSchema,
+  shield: kartShieldSchema,
+  gameTrackId: z.string(),
+  color: colorNameSchema,
+  number: z.number(),
+  currentGame: kartGameSchema.nullable().optional(),
+  description: z.string().nullable().optional(),
+  isSubscribedToHardwareStatus: z.boolean(),
+  hardwareState: kartHardwareStateSchema.nullable().optional(),
+  currentPowerUp: powerUpNameSchema.nullable().optional(),
+  currentDamage: damageEffectNameSchema.nullable().optional(),
+});

package/src/domains/kart/Kart.types.ts

@@ -0,0 +1,7 @@
+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/src/domains/kart/KartHardwareState.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { checkpointTypeSchema } from '../checkpoint';
+import { flagStatusSchema, rgbStatusSchema, screenStatusSchema, speedStatusSchema } from '../hardware';
+
+export const kartHardwareStateSchema = z.object({
+  speed: z
+    .object({
+      status: speedStatusSchema,
+      current: z.number(),
+      configured: z.number(),
+    })
+    .nullable(),
+  rgb: rgbStatusSchema.nullable(),
+  flag: z
+    .object({
+      status: flagStatusSchema,
+      checkpointType: checkpointTypeSchema.nullable(),
+      checkpointAddress: z.number().nullable(),
+    })
+    .nullable(),
+  screen: screenStatusSchema.nullable(),
+  isConnectedToServer: z.boolean(),
+  isSteeringWheelPressed: z.boolean(),
+});

package/src/domains/kart/index.ts

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

package/src/domains/kartTracking/KartTracking.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { checkpointSchema } from '../checkpoint';
+
+export const checkpointEventSchema = checkpointSchema.extend({
+  index: z.number(),
+  timestampISO: z.object({
+    origin: z.string(),
+    server: z.string(),
+  }),
+});
+
+export const kartTrackingSchema = z.object({
+  macAddress: z.string(),
+  checkpointsEvents: z.array(checkpointEventSchema).optional(),
+});

package/src/domains/kartTracking/KartTracking.types.ts

@@ -0,0 +1,5 @@
+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/src/domains/kartTracking/index.ts

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

package/src/domains/pagination/Pagination.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const paginationMetadataSchema = z.object({
+  nextCursor: z.string().optional(),
+  hasMore: z.boolean().optional(),
+  limit: z.number(),
+});
+
+export const paginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) => {
+  return z.object({
+    data: z.array(itemSchema),
+    meta: paginationMetadataSchema,
+  });
+};

package/src/domains/pagination/Pagination.types.ts

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

package/src/domains/pagination/index.ts

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

package/src/domains/powerUp/PowerUp.const.ts

@@ -0,0 +1,23 @@
+export const 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',
+} as const;
+
+export const POWER_UP_TYPE = {
+  Damage: 'Damage',
+  Shield: 'Shield',
+  Speed: 'Speed',
+} as const;
+
+export const POWER_UP_TARGET = {
+  Self: 'Self',
+  Any: 'Any',
+  All: 'All',
+} as const;

package/src/domains/powerUp/PowerUp.schema.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { allCommandsConfigSchema } from '../command';
+import { damageEffectNameSchema, damageTargetSchema } from '../damage';
+import { powerUpNameSchema, powerUpTargetSchema } from './PowerUpAttributes.schema';
+
+export const powerUpCommandSchema = allCommandsConfigSchema;
+
+export const powerUpShieldSchema = z.object({
+  duration: z.number(),
+});
+
+export const powerUpLevelSchema = z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(5)]);
+
+export const powerUpSchema = z.object({
+  id: z.string(),
+  name: powerUpNameSchema,
+  imageName: z.string(),
+  description: z.string(),
+  level: powerUpLevelSchema,
+  assignationCommands: z.array(powerUpCommandSchema),
+  activationCommands: z.array(powerUpCommandSchema),
+  shield: powerUpShieldSchema.optional(),
+  networkDamage: z
+    .object({
+      name: damageEffectNameSchema,
+      target: damageTargetSchema,
+    })
+    .optional(),
+});

package/src/domains/powerUp/PowerUp.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { powerUpCommandSchema, powerUpLevelSchema, powerUpSchema, powerUpShieldSchema } from './PowerUp.schema';
+import { powerUpNameSchema, powerUpTargetSchema, powerUpTypeSchema } from './PowerUpAttributes.schema';
+
+export type PowerUpName = z.infer<typeof powerUpNameSchema>;
+export type PowerUpType = z.infer<typeof powerUpTypeSchema>;
+export type PowerUpTarget = z.infer<typeof powerUpTargetSchema>;
+export type PowerUpShield = z.infer<typeof powerUpShieldSchema>;
+export type PowerUp = z.infer<typeof powerUpSchema>;
+export type PowerUpLevel = z.infer<typeof powerUpLevelSchema>;
+
+export type PowerUpCommand = z.infer<typeof powerUpCommandSchema>;

package/src/domains/powerUp/PowerUpAttributes.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { POWER_UP_NAME, POWER_UP_TARGET, POWER_UP_TYPE } from './PowerUp.const';
+
+export const powerUpNameSchema = z.enum(POWER_UP_NAME);
+export const powerUpTypeSchema = z.enum(POWER_UP_TYPE);
+export const powerUpTargetSchema = z.enum(POWER_UP_TARGET);

package/src/domains/powerUp/index.ts

@@ -0,0 +1,4 @@
+export * from './PowerUp.const';
+export * from './PowerUpAttributes.schema';
+export * from './PowerUp.schema';
+export * from './PowerUp.types';

package/src/domains/racingTeam/RacingTeam.const.ts

@@ -0,0 +1,10 @@
+export const RACING_TEAM_ROLE = {
+  PILOT: 'PILOT',
+  TECHNICIAN: 'TECHNICIAN',
+} as const;
+
+export const JOIN_REQUEST_STATUS = {
+  PENDING: 'PENDING',
+  ACCEPTED: 'ACCEPTED',
+  REJECTED: 'REJECTED',
+} as const;

package/src/domains/racingTeam/RacingTeam.schema.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { paginatedResponseSchema } from '../pagination';
+import { JOIN_REQUEST_STATUS, RACING_TEAM_ROLE } from './RacingTeam.const';
+
+// --- Team Schemas ---
+
+export const racingTeamSchema = z.object({
+  id: z.string(),
+  name: z.string().min(3).max(50),
+  imageUrl: z.url().optional(),
+  adminUserId: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const createRacingTeamSchema = racingTeamSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+  adminUserId: true,
+});
+
+export const updateRacingTeamSchema = racingTeamSchema.partial();
+
+export const filterRacingTeamSchema = z.object({
+  name: z.string().optional(),
+  adminUserId: 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 racingTeamSummarySchema = racingTeamSchema.pick({
+  id: true,
+  name: true,
+  imageUrl: true,
+});
+
+export const paginatedRacingTeamSchema = paginatedResponseSchema(racingTeamSchema);
+export const paginatedRacingTeamSummarySchema = paginatedResponseSchema(racingTeamSummarySchema);
+
+// --- Membership Schemas ---
+
+export const joinRequestSchema = z.object({
+  id: z.string(),
+  racingTeamId: z.string(),
+  userId: z.string(),
+  status: z.enum(JOIN_REQUEST_STATUS),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const teamMemberSchema = z.object({
+  racingTeamId: z.string(),
+  userId: z.string(),
+  role: z.enum(RACING_TEAM_ROLE),
+  joinedAt: z.date(),
+});
+
+export const createJoinRequestSchema = z.object({
+  racingTeamId: z.string(),
+});
+
+export const answerJoinRequestSchema = z.object({
+  racingTeamId: z.string(),
+  targetUserId: z.string(),
+  accepted: z.boolean(),
+});

package/src/domains/racingTeam/RacingTeam.types.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import {
+  answerJoinRequestSchema,
+  createJoinRequestSchema,
+  createRacingTeamSchema,
+  joinRequestSchema,
+  paginatedRacingTeamSchema,
+  paginatedRacingTeamSummarySchema,
+  racingTeamSchema,
+  racingTeamSummarySchema,
+  teamMemberSchema,
+  updateRacingTeamSchema,
+} from './RacingTeam.schema';
+
+export type RacingTeam = z.infer<typeof racingTeamSchema>;
+export type CreateRacingTeamInput = z.infer<typeof createRacingTeamSchema>;
+export type UpdateRacingTeamInput = z.infer<typeof updateRacingTeamSchema>;
+export type PaginatedRacingTeam = z.infer<typeof paginatedRacingTeamSchema>;
+export type RacingTeamSummary = z.infer<typeof racingTeamSummarySchema>;
+export type PaginatedRacingTeamSummary = z.infer<typeof paginatedRacingTeamSummarySchema>;
+
+export type JoinRequest = z.infer<typeof joinRequestSchema>;
+export type TeamMember = z.infer<typeof teamMemberSchema>;
+export type CreateJoinRequest = z.infer<typeof createJoinRequestSchema>;
+export type AnswerJoinRequest = z.infer<typeof answerJoinRequestSchema>;

package/src/domains/racingTeam/index.ts

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

package/src/domains/response/Response.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export const errorResponseSchema = z.object({
+  status: z.literal('error'),
+  code: z.number(),
+  errorType: z.string(),
+  message: z.string(),
+});
+
+export const successResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
+  z.object({
+    status: z.literal('success'),
+    code: z.literal(200),
+    data: itemSchema.optional(),
+  });
+
+export const responseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
+  z.union([successResponseSchema(itemSchema), errorResponseSchema]);

package/src/domains/response/Response.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { errorResponseSchema, successResponseSchema } from './Response.schema';
+
+export type ErrorResponse = z.infer<typeof errorResponseSchema>;
+
+export type SuccessResponse<T> = {
+  status: 'success';
+  code: 200;
+  data?: T;
+};
+
+export type Response<T> = SuccessResponse<T> | ErrorResponse;

package/src/domains/response/index.ts

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

package/src/domains/role/Role.const.ts

@@ -0,0 +1,21 @@
+export const PERMISSION = {
+  FULL_ACCESS: 'FULL_ACCESS',
+
+  KARTS_MANAGE_HARDWARE: 'KARTS_MANAGE_HARDWARE',
+  KARTS_MANAGE_POWER_UPS: 'KARTS_MANAGE_POWER_UPS',
+
+  GAME_TRACK_MANAGE_GAMES: 'GAME_TRACK_MANAGE_GAMES',
+  GAME_TRACK_MANAGE_BASIC_INFO: 'GAME_TRACK_MANAGE_BASIC_INFO',
+  GAME_TRACK_MANAGE_HARDWARE: 'GAME_TRACK_MANAGE_HARDWARE',
+  GAME_TRACK_MANAGE_KARTS_CONFIG: 'GAME_TRACK_MANAGE_KARTS_CONFIG',
+  GAME_TRACK_MANAGE_CHECKPOINTS: 'GAME_TRACK_MANAGE_CHECKPOINTS',
+  GAME_TRACK_MANAGE_KARTS: 'GAME_TRACK_MANAGE_KARTS',
+
+  KARTS_TRACKING: 'KARTS_TRACKING',
+} as const;
+
+export const USER_ROLE = {
+  SUPER_ADMIN: 'SUPER_ADMIN',
+  OPERATOR: 'OPERATOR',
+  PLAYER: 'PLAYER',
+} as const;

package/src/domains/role/Role.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { PERMISSION, USER_ROLE } from './Role.const';
+
+export const permissionSchema = z.enum(PERMISSION);
+
+export const userRoleSchema = z.enum(USER_ROLE);

package/src/domains/role/Role.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { permissionSchema, userRoleSchema } from './Role.schema';
+
+export type Permission = z.infer<typeof permissionSchema>;
+
+export type UserRole = z.infer<typeof userRoleSchema>;
+
+export interface RoleDefinition {
+  role: UserRole;
+  permissions: Permission[];
+  description: string;
+}

package/src/domains/role/index.ts

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

package/src/domains/socket/SocketHardwareModulesEventsParams.ts

@@ -0,0 +1,107 @@
+import type {
+  ConfigDiskSensorBallShooterModuleOptions,
+  ConfigureBallSensorDiskThrowerModuleOptions,
+  FlagConfigurationOptions,
+  FlagShowMediaOptions,
+  PlaySoundOptions,
+  RGBConfigurationOptions,
+  RGBShowEffectOptions,
+  ScreenCountdownParams,
+  ScreenFinishViewInput,
+  ScreenHomeViewInput,
+  ScreenUpdateGameViewInput,
+  SpeedChangeOptions,
+  SpeedConfiguration,
+  StarLaserConfigureModuleOptions,
+  StarLaserSendActionsOptions,
+} from '../hardware';
+
+export type SocketHardwareDataSubscriptionEventsParams = {
+  'hardware:data:subscribe': undefined;
+  'hardware:data:unsubscribe': undefined;
+};
+
+export type SocketHardwareBallSensorDiskThrowerModuleEventsParams = {
+  'hardware:ball-sensor-disk-thrower:activateSensor': undefined;
+  'hardware:ball-sensor-disk-thrower:deactivateSensor': undefined;
+  'hardware:ball-sensor-disk-thrower:configureModule': ConfigureBallSensorDiskThrowerModuleOptions;
+  'hardware:ball-sensor-disk-thrower:throwDisk': undefined;
+  'hardware:ball-sensor-disk-thrower:activateDiskThrower': undefined;
+  'hardware:ball-sensor-disk-thrower:deactivateDiskThrower': undefined;
+};
+
+export type SocketHardwareDiskSensorBallShooterModuleEventsParams = {
+  'hardware:disk-sensor-ball-shooter:configure': ConfigDiskSensorBallShooterModuleOptions;
+  'hardware:disk-sensor-ball-shooter:prepareShooter': undefined;
+  'hardware:disk-sensor-ball-shooter:shootBall': undefined;
+  'hardware:disk-sensor-ball-shooter:activateSensor': undefined;
+  'hardware:disk-sensor-ball-shooter:deactivateSensor': undefined;
+  'hardware:disk-sensor-ball-shooter:calibrateSensor': undefined;
+};
+
+export type SocketHardwareFlagModuleEventsParams = {
+  'hardware:flag:activate': undefined;
+  'hardware:flag:deactivate': undefined;
+  'hardware:flag:configure': FlagConfigurationOptions;
+  'hardware:flag:showMediaIndefinitely': FlagShowMediaOptions;
+  'hardware:flag:showMediaTemporarily': FlagShowMediaOptions;
+};
+
+export type SocketHardwareRGBModuleEventsParams = {
+  'hardware:rgb:configure': RGBConfigurationOptions;
+  'hardware:rgb:showEffect': RGBShowEffectOptions;
+};
+
+export type SocketHardwareSpeedModuleEventsParams = {
+  'hardware:speed:activate': undefined;
+  'hardware:speed:deactivate': undefined;
+  'hardware:speed:update': SpeedChangeOptions;
+  'hardware:speed:configure': SpeedConfiguration;
+};
+
+export type SocketHardwareLeftStarBackLaserModuleEventsParams = {
+  'hardware:left-star-back-laser:action': StarLaserSendActionsOptions;
+  'hardware:left-star-back-laser:configure': StarLaserConfigureModuleOptions;
+};
+
+export type SocketHardwareRightStarFrontLaserModuleEventsParams = {
+  'hardware:right-star-front-laser:action': StarLaserSendActionsOptions;
+  'hardware:right-star-front-laser:configure': StarLaserConfigureModuleOptions;
+};
+
+export type SocketHardwareScreenModuleEventsParams = {
+  'hardware:screen:showHomeView': ScreenHomeViewInput;
+  'hardware:screen:showCountdownView': ScreenCountdownParams;
+  'hardware:screen:updateGameView': ScreenUpdateGameViewInput;
+  'hardware:screen:showScreenVictoryView': ScreenFinishViewInput;
+  'hardware:screen:showScreenDefeatView': ScreenFinishViewInput;
+};
+
+export type SocketHardwareSteeringWheelModuleEventsParams = {
+  'hardware:steering-wheel:turnLedOn': undefined;
+  'hardware:steering-wheel:turnLedOff': undefined;
+};
+
+export type SocketHardwareSoundModuleEventsParams = {
+  'hardware:sound:play': PlaySoundOptions;
+};
+
+// UNIQUE FOR GAME TRACK RPI
+export type SocketHardwareEmergencyModuleEventsParams = {
+  'hardware:emergency:activate': undefined;
+  'hardware:emergency:deactivate': undefined;
+};
+
+// Just the union of all the events params
+export type SocketHardwareModulesEventsParams = SocketHardwareBallSensorDiskThrowerModuleEventsParams &
+  SocketHardwareDiskSensorBallShooterModuleEventsParams &
+  SocketHardwareFlagModuleEventsParams &
+  SocketHardwareRGBModuleEventsParams &
+  SocketHardwareSpeedModuleEventsParams &
+  SocketHardwareDataSubscriptionEventsParams &
+  SocketHardwareLeftStarBackLaserModuleEventsParams &
+  SocketHardwareRightStarFrontLaserModuleEventsParams &
+  SocketHardwareScreenModuleEventsParams &
+  SocketHardwareSteeringWheelModuleEventsParams &
+  SocketHardwareSoundModuleEventsParams &
+  SocketHardwareEmergencyModuleEventsParams;