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

package/src/domains/command/Command.schema.ts

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+import {
+  configDiskSensorBallShooterModuleOptionsSchema,
+  configureBallSensorDiskThrowerModuleOptionsSchema,
+  flagConfigurationOptionsSchema,
+  flagShowMediaOptionsSchema,
+  playSoundOptionsSchema,
+  rgbConfigurationOptionsSchema,
+  rgbShowEffectOptionsSchema,
+  screenCountdownParamsSchema,
+  screenFinishViewInputSchema,
+  screenUpdateGameViewInputSchema,
+  speedChangeOptionsSchema,
+  speedConfigurationSchema,
+  starLaserConfigureModuleOptionsSchema,
+  starLaserSendActionsOptionsSchema,
+} from '../hardware';
+import { arithmeticExpressionSchema } from '../utils';
+
+// Helper for arithmetic expressions
+const arithmeticOrNumberSchema = z.union([z.number(), arithmeticExpressionSchema]);
+
+// --- Speed Commands ---
+export const changeSpeedActionCommandOptionsSchema = speedChangeOptionsSchema.omit({ speed: true }).extend({
+  speed: arithmeticOrNumberSchema,
+});
+
+export const speedModuleCommandSchema = z.union([
+  z.object({ module: z.literal('speed'), action: z.literal('activate') }),
+  z.object({ module: z.literal('speed'), action: z.literal('deactivate') }),
+  z.object({ module: z.literal('speed'), action: z.literal('change'), params: changeSpeedActionCommandOptionsSchema }),
+  z.object({ module: z.literal('speed'), action: z.literal('configure'), params: speedConfigurationSchema }),
+]);
+
+// --- Sound Commands ---
+export const playSoundActionCommandOptionsSchema = playSoundOptionsSchema.omit({ durationMs: true }).extend({
+  durationMs: arithmeticOrNumberSchema.optional(),
+});
+
+export const soundModuleCommandSchema = z.object({
+  module: z.literal('sound'),
+  action: z.literal('play'),
+  params: playSoundActionCommandOptionsSchema,
+});
+
+// --- Ball Sensor / Disk Thrower ---
+export const ballSensorDiskThrowerModuleCommandSchema = z.union([
+  z.object({ module: z.literal('ballSensorDiskThrower'), action: z.literal('activateSensor') }),
+  z.object({ module: z.literal('ballSensorDiskThrower'), action: z.literal('deactivateSensor') }),
+  z.object({
+    module: z.literal('ballSensorDiskThrower'),
+    action: z.literal('configureModule'),
+    params: configureBallSensorDiskThrowerModuleOptionsSchema,
+  }),
+  z.object({ module: z.literal('ballSensorDiskThrower'), action: z.literal('throwDisk') }),
+  z.object({ module: z.literal('ballSensorDiskThrower'), action: z.literal('activateDiskThrower') }),
+  z.object({ module: z.literal('ballSensorDiskThrower'), action: z.literal('deactivateDiskThrower') }),
+]);
+
+// --- Disk Sensor / Ball Shooter ---
+export const diskSensorBallShooterModuleCommandSchema = z.union([
+  z.object({
+    module: z.literal('diskSensorBallShooter'),
+    action: z.literal('configure'),
+    params: configDiskSensorBallShooterModuleOptionsSchema,
+  }),
+  z.object({ module: z.literal('diskSensorBallShooter'), action: z.literal('prepareShooter') }),
+  z.object({ module: z.literal('diskSensorBallShooter'), action: z.literal('shootBall') }),
+  z.object({ module: z.literal('diskSensorBallShooter'), action: z.literal('activateSensor') }),
+  z.object({ module: z.literal('diskSensorBallShooter'), action: z.literal('deactivateSensor') }),
+  z.object({ module: z.literal('diskSensorBallShooter'), action: z.literal('calibrateSensor') }),
+]);
+
+// --- Flag ---
+export const flagModuleCommandSchema = z.union([
+  z.object({ module: z.literal('flag'), action: z.literal('activate') }),
+  z.object({ module: z.literal('flag'), action: z.literal('deactivate') }),
+  z.object({ module: z.literal('flag'), action: z.literal('configure'), params: flagConfigurationOptionsSchema }),
+  z.object({
+    module: z.literal('flag'),
+    action: z.literal('showMediaIndefinitely'),
+    params: flagShowMediaOptionsSchema,
+  }),
+  z.object({
+    module: z.literal('flag'),
+    action: z.literal('showMediaTemporarily'),
+    params: flagShowMediaOptionsSchema,
+  }),
+]);
+
+// --- RGB ---
+export const rgbModuleCommandSchema = z.union([
+  z.object({ module: z.literal('rgb'), action: z.literal('configure'), params: rgbConfigurationOptionsSchema }),
+  z.object({ module: z.literal('rgb'), action: z.literal('showEffect'), params: rgbShowEffectOptionsSchema }),
+]);
+
+// --- Star Laser ---
+export const leftStarBackLaserModuleCommandSchema = z.union([
+  z.object({
+    module: z.literal('leftStarBackLaser'),
+    action: z.literal('action'),
+    params: starLaserSendActionsOptionsSchema,
+  }),
+  z.object({
+    module: z.literal('leftStarBackLaser'),
+    action: z.literal('configure'),
+    params: starLaserConfigureModuleOptionsSchema,
+  }),
+]);
+
+export const rightStarFrontLaserModuleCommandSchema = z.union([
+  z.object({
+    module: z.literal('rightStarFrontLaser'),
+    action: z.literal('action'),
+    params: starLaserSendActionsOptionsSchema,
+  }),
+  z.object({
+    module: z.literal('rightStarFrontLaser'),
+    action: z.literal('configure'),
+    params: starLaserConfigureModuleOptionsSchema,
+  }),
+]);
+
+// --- Screen (New) ---
+export const screenModuleCommandSchema = z.union([
+  z.object({ module: z.literal('screen'), action: z.literal('showHomeView') }),
+  z.object({
+    module: z.literal('screen'),
+    action: z.literal('showCountdownView'),
+    params: screenCountdownParamsSchema,
+  }),
+  z.object({
+    module: z.literal('screen'),
+    action: z.literal('updateGameView'),
+    params: screenUpdateGameViewInputSchema,
+  }),
+  z.object({
+    module: z.literal('screen'),
+    action: z.literal('showScreenVictoryView'),
+    params: screenFinishViewInputSchema,
+  }),
+  z.object({
+    module: z.literal('screen'),
+    action: z.literal('showScreenDefeatView'),
+    params: screenFinishViewInputSchema,
+  }),
+]);
+
+// --- Steering Wheel ---
+export const steeringWheelModuleCommandSchema = z.union([
+  z.object({ module: z.literal('steeringWheel'), action: z.literal('turnLedOn') }),
+  z.object({ module: z.literal('steeringWheel'), action: z.literal('turnLedOff') }),
+]);
+
+// --- All Commands Union ---
+export const allCommandsConfigSchema = z.union([
+  ballSensorDiskThrowerModuleCommandSchema,
+  diskSensorBallShooterModuleCommandSchema,
+  flagModuleCommandSchema,
+  rgbModuleCommandSchema,
+  speedModuleCommandSchema,
+  leftStarBackLaserModuleCommandSchema,
+  rightStarFrontLaserModuleCommandSchema,
+  screenModuleCommandSchema,
+  steeringWheelModuleCommandSchema,
+  soundModuleCommandSchema,
+]);

package/src/domains/command/Command.types.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import {
+  allCommandsConfigSchema,
+  ballSensorDiskThrowerModuleCommandSchema,
+  changeSpeedActionCommandOptionsSchema,
+  diskSensorBallShooterModuleCommandSchema,
+  flagModuleCommandSchema,
+  leftStarBackLaserModuleCommandSchema,
+  playSoundActionCommandOptionsSchema,
+  rgbModuleCommandSchema,
+  rightStarFrontLaserModuleCommandSchema,
+  screenModuleCommandSchema,
+  soundModuleCommandSchema,
+  speedModuleCommandSchema,
+  steeringWheelModuleCommandSchema,
+} from './Command.schema';
+
+export type ChangeSpeedActionCommandOptions = z.infer<typeof changeSpeedActionCommandOptionsSchema>;
+export type PlaySoundActionCommandOptions = z.infer<typeof playSoundActionCommandOptionsSchema>;
+
+export type BallSensorDiskThrowerModuleCommands = z.infer<typeof ballSensorDiskThrowerModuleCommandSchema>;
+export type DiskSensorBallShooterModuleCommands = z.infer<typeof diskSensorBallShooterModuleCommandSchema>;
+export type FlagModuleCommands = z.infer<typeof flagModuleCommandSchema>;
+export type RGBModuleCommands = z.infer<typeof rgbModuleCommandSchema>;
+export type SpeedModuleCommands = z.infer<typeof speedModuleCommandSchema>;
+export type LeftStarBackLaserModuleCommands = z.infer<typeof leftStarBackLaserModuleCommandSchema>;
+export type RightStarFrontLaserModuleCommands = z.infer<typeof rightStarFrontLaserModuleCommandSchema>;
+export type ScreenModuleCommands = z.infer<typeof screenModuleCommandSchema>;
+export type SteeringWheelModuleCommands = z.infer<typeof steeringWheelModuleCommandSchema>;
+export type SoundModuleCommands = z.infer<typeof soundModuleCommandSchema>;
+
+export type AllCommandsConfig = z.infer<typeof allCommandsConfigSchema>;

package/src/domains/command/index.ts

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

package/src/domains/damage/Damage.const.ts

@@ -0,0 +1,19 @@
+export const DAMAGE_EFFECT = {
+  GENERIC: 'Generic',
+  TRAP_HIT: 'Trap Hit',
+  PULSE_HIT: 'Pulse Hit',
+  STAR_HIT_LEFT: 'Star Hit Left',
+  STAR_HIT_RIGHT: 'Star Hit Right',
+  SHOT_HIT: 'Shot Hit',
+  SHORTCUT: 'Shortcut',
+  BLUE_SHOT_HIT: 'Blue Shot Hit',
+} as const;
+
+export const DAMAGE_TARGET = {
+  ANY: 'Any',
+  ALL: 'All',
+  FIRST: 'First',
+  LAST: 'Last',
+  NEXT: 'Next',
+  PREVIOUS: 'Previous',
+} as const;

package/src/domains/damage/Damage.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { flagMediaNameSchema, kartEffectSchema } from '../hardware';
+import { soundNameSchema } from '../sounds';
+import { DAMAGE_EFFECT, DAMAGE_TARGET } from './Damage.const';
+
+export const damageEffectNameSchema = z.enum(DAMAGE_EFFECT);
+
+export const damageTargetSchema = z.enum(DAMAGE_TARGET);
+
+export const damageSchema = z.object({
+  name: damageEffectNameSchema,
+  target: damageTargetSchema,
+  sound: soundNameSchema,
+  rgbEffect: kartEffectSchema,
+  amount: z.number(),
+  flagMediaName: flagMediaNameSchema,
+});

package/src/domains/damage/Damage.types.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { damageEffectNameSchema, damageSchema, damageTargetSchema } from './Damage.schema';
+
+export type DamageEffectName = z.infer<typeof damageEffectNameSchema>;
+export type DamageTarget = z.infer<typeof damageTargetSchema>;
+export type Damage = z.infer<typeof damageSchema>;

package/src/domains/damage/index.ts

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

package/src/domains/flow/Flow.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { allCommandsConfigSchema } from '../command';
+
+export const flowSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string().optional(),
+  commands: z.array(allCommandsConfigSchema),
+});

package/src/domains/flow/Flow.types.ts

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

package/src/domains/flow/index.ts

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

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

@@ -0,0 +1,25 @@
+export const GAME_TYPE = {
+  Race: 'Race',
+  Battle: 'Battle',
+} as const;
+
+export const GAME_STATUS = {
+  NON_STARTED: 'non-started',
+  ACTIVE: 'active',
+  YELLOW_FLAG: 'yellow-flag',
+  RED_FLAG: 'red-flag',
+  FINISHED: 'finished',
+  KART_ELIMINATED: 'kart-eliminated',
+} as const;
+
+export const GAME_FINISHED_REASON = {
+  TIME_IS_OVER: 'TIME_IS_OVER',
+  GAME_KARTS_FINISHED: 'GAME_KARTS_FINISHED',
+  EMERGENCY: 'EMERGENCY',
+  BY_CONTROLLER: 'BY_CONTROLLER',
+} as const;
+
+export const GAME_WARNING_EVENT = {
+  YELLOW_FLAG: 'yellow-flag',
+  RED_FLAG: 'red-flag',
+} as const;

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { GAME_FINISHED_REASON, GAME_STATUS, GAME_TYPE, GAME_WARNING_EVENT } from './Game.const';
+
+export const gameTypeSchema = z.enum(GAME_TYPE);
+
+export const gameStatusSchema = z.enum(GAME_STATUS);
+
+export const gameFinishedReasonSchema = z.enum(GAME_FINISHED_REASON);
+
+export const gameWarningEventSchema = z.enum(GAME_WARNING_EVENT);
+
+export const gameKartStateSchema = z.object({
+  coins: z.number(),
+});
+
+export const kartRankingItemSchema = z.object({
+  kartGuid: z.string(),
+  position: z.number(),
+  time: z.number(),
+});
+
+export const gameSchema = z.object({
+  id: z.number(),
+  status: gameStatusSchema,
+  kartsGuids: z.array(z.string()),
+  powerUpsIds: z.array(z.string()),
+  gameTrackId: z.string(),
+  type: gameTypeSchema,
+  coins: z.number(),
+  time: z.number(),
+  speedConfig: z.number(),
+  createdAt: z.date(),
+  startedAt: z.date().optional(),
+  finishedAt: z.date().optional(),
+  finishedReason: gameFinishedReasonSchema.optional(),
+  kartsState: z.record(z.string(), gameKartStateSchema),
+  gameRanking: z.array(kartRankingItemSchema),
+});

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

@@ -0,0 +1,18 @@
+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/src/domains/game/battle/Battle.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { GAME_TYPE } from '../Game.const';
+import { gameKartStateSchema, gameSchema } from '../Game.schema';
+
+// --- Helper Schemas ---
+
+export const battleKartStateSchema = gameKartStateSchema.extend({
+  lives: z.number(),
+});
+
+// --- Main Battle Schema ---
+
+export const battleSchema = gameSchema.extend({
+  type: z.literal(GAME_TYPE.Battle),
+  lives: z.number(),
+  kartsState: z.record(z.string(), battleKartStateSchema),
+});

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

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

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

package/src/domains/game/index.ts

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

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { GAME_TYPE } from '../Game.const';
+import { gameKartStateSchema, gameSchema, kartRankingItemSchema } from '../Game.schema';
+
+// --- Helper Schemas ---
+
+export const kartProgressSchema = z.object({
+  checkpointId: z.string(),
+  checkpointProgress: z.number(),
+  timestampISO: z.object({
+    origin: z.string(),
+    server: z.string(),
+  }),
+  lap: z.number(),
+  totalProgress: z.number(),
+});
+
+export const lapTimeSchema = z.object({
+  lap: z.number(),
+  timeInSeconds: z.number(),
+  completedAt: z.string(),
+  completedAtCheckpointId: z.string(),
+  completedAtCheckpointProgress: z.number(),
+});
+
+export const raceKartStateSchema = gameKartStateSchema.extend({
+  currentLap: z.number(),
+});
+
+export const raceRankingItemSchema = kartRankingItemSchema.extend({
+  progress: z.number(),
+  lapsCompleted: z.number(),
+});
+
+export const rankingWithKartsAndLapTimesSchema = raceRankingItemSchema.extend({
+  lapTimes: z.array(lapTimeSchema),
+  fastestLap: lapTimeSchema.nullable(),
+});
+
+// --- Main Race Schema ---
+
+export const raceSchema = gameSchema.extend({
+  type: z.literal(GAME_TYPE.Race),
+  laps: z.number(),
+  kartsState: z.record(z.string(), raceKartStateSchema),
+  kartsProgress: z.record(z.string(), z.array(kartProgressSchema)),
+  gameRanking: z.array(raceRankingItemSchema),
+});
+
+export const raceWithDetailedRankingSchema = raceSchema.omit({ kartsProgress: true }).extend({
+  gameRanking: z.array(rankingWithKartsAndLapTimesSchema),
+});
+
+export const kartLapTimesSchema = z.object({
+  kartGuid: z.string(),
+  lapTimes: z.array(lapTimeSchema),
+});

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

@@ -0,0 +1,22 @@
+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/src/domains/game/race/index.ts

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

package/src/domains/gameTrack/GameTrack.schema.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { checkpointSchema } from '../checkpoint';
+import { colorNameSchema } from '../color';
+import { gameTypeSchema } from '../game';
+import {
+  configDiskSensorBallShooterModuleOptionsSchema,
+  configureBallSensorDiskThrowerModuleOptionsSchema,
+} from '../hardware';
+
+export const gameTrackGameDefaultValuesSchema = z.object({
+  speed: z.array(z.number()),
+  powerUpIds: z.array(z.string()),
+});
+
+export const gameTrackKartsConfigSchema = z.object({
+  defaultSpeed: z.number().min(0).max(100),
+  powerUpTime: z.number().min(1).max(25),
+  rgbBrightness: z.number().min(0).max(100),
+  flagBrightness: z.number().min(0).max(100),
+  diskSensorBallShooter: configDiskSensorBallShooterModuleOptionsSchema,
+  ballSensorDiskThrower: configureBallSensorDiskThrowerModuleOptionsSchema,
+  lowSpeed: z.number().min(0).max(100),
+});
+
+export const gameTrackKartConfigSchema = z.object({
+  gameTrackId: z.string(),
+  kartId: z.number(),
+  color: colorNameSchema,
+  kartNumber: z.number(),
+  mac: z.string(),
+});
+
+export const gameTrackSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: gameTypeSchema,
+  checkpoints: z.array(checkpointSchema),
+  kartsConfig: gameTrackKartsConfigSchema,
+  macAddress: z.string().optional(),
+  isConnected: z.boolean(),
+  gameDefaultValues: gameTrackGameDefaultValuesSchema.optional(),
+});

package/src/domains/gameTrack/GameTrack.types.ts

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

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

package/src/domains/hardware/KartHardwareState.schema.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { checkpointTypeSchema } from '../checkpoint';
+import { flagStatusSchema } from './flag';
+import { rgbStatusSchema } from './rgb';
+import { screenStatusSchema } from './screen';
+import { speedStatusSchema } from './speed';
+
+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/hardware/ModuleName.const.ts

@@ -0,0 +1,12 @@
+export const MODULE_NAME = {
+  SPEED: 'speed',
+  FLAG: 'flag',
+  RGB: 'rgb',
+  DISK_SENSOR_BALL_SHOOTER: 'disk-sensor-ball-shooter',
+  BALL_SENSOR_DISK_THROWER: 'ball-sensor-disk-thrower',
+  LEFT_STAR_BACK_LASER: 'left-star-back-laser',
+  RIGHT_STAR_FRONT_LASER: 'right-star-front-laser',
+  SCREEN: 'screen',
+  EMERGENCY: 'emergency',
+  LIGHTS: 'lights',
+} as const;

package/src/domains/hardware/ModuleStatus.schema.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ballSensorDiskThrowerModuleStatusSchema } from './ballSensor';
+import { diskSensorBallShooterModuleStatusSchema } from './diskSensor';
+import { emergencyModuleStatusSchema } from './emergency';
+import { flagModuleStatusSchema } from './flag';
+import { MODULE_NAME } from './ModuleName.const';
+import { rgbModuleStatusSchema } from './rgb';
+import { speedModuleStatusSchema } from './speed';
+import { starLaserModuleStatusSchema } from './star-laser';
+import { steeringWheelModuleStatusSchema } from './steering-wheel';
+
+export const moduleNameSchema = z.enum(MODULE_NAME);
+
+export const moduleStatusSchema = z.union([
+  speedModuleStatusSchema,
+  rgbModuleStatusSchema,
+  flagModuleStatusSchema,
+  diskSensorBallShooterModuleStatusSchema,
+  ballSensorDiskThrowerModuleStatusSchema,
+  starLaserModuleStatusSchema,
+  steeringWheelModuleStatusSchema,
+  emergencyModuleStatusSchema,
+]);

package/src/domains/hardware/ModuleStatus.types.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { moduleNameSchema, moduleStatusSchema } from './ModuleStatus.schema';
+
+export type ModuleName = z.infer<typeof moduleNameSchema>;
+export type ModuleStatus = z.infer<typeof moduleStatusSchema>;

package/src/domains/hardware/ballSensor/BallSensor.const.ts

@@ -0,0 +1,13 @@
+export const BALL_SENSOR_COMMAND = {
+  DEACTIVATE_SENSOR: 'Deactivate Sensor',
+  ACTIVATE_SENSOR: 'Activate Sensor',
+  CONFIGURE_MODULE: 'Configure Module',
+} as const;
+
+export const BALL_SENSOR_STATUS = {
+  SENSOR_STANDBY: 'Sensor Standby',
+  SENSOR_DEACTIVATED: 'Sensor Deactivated',
+  SENSOR_ACTIVATED: 'Sensor Activated',
+  SENSOR_HIT: 'Sensor Hit',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/hardware/ballSensor/BallSensor.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { BALL_SENSOR_COMMAND, BALL_SENSOR_STATUS } from './BallSensor.const';
+
+export const ballSensorCommandSchema = z.enum(BALL_SENSOR_COMMAND);
+
+export const ballSensorStatusSchema = z.enum(BALL_SENSOR_STATUS);
+
+export const configureBallSensorDiskThrowerModuleOptionsSchema = z.object({
+  waitTimeAfterHit: z.number().min(1).max(25),
+});
+
+export const ballSensorDiskThrowerModuleStatusSchema = z.object({
+  ballSensorStatus: ballSensorStatusSchema,
+});

package/src/domains/hardware/ballSensor/BallSensor.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  ballSensorCommandSchema,
+  ballSensorDiskThrowerModuleStatusSchema,
+  ballSensorStatusSchema,
+  configureBallSensorDiskThrowerModuleOptionsSchema,
+} from './BallSensor.schema';
+
+export type BallSensorCommand = z.infer<typeof ballSensorCommandSchema>;
+export type BallSensorStatus = z.infer<typeof ballSensorStatusSchema>;
+export type ConfigureBallSensorDiskThrowerModuleOptions = z.infer<
+  typeof configureBallSensorDiskThrowerModuleOptionsSchema
+>;
+export type BallSensorDiskThrowerModuleStatus = z.infer<typeof ballSensorDiskThrowerModuleStatusSchema>;

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

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