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

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';

package/src/domains/hardware/ballShooter/BallShooter.const.ts

@@ -0,0 +1,13 @@
+export const BALL_SHOOTER_COMMAND = {
+  SHOOTER_OFF: 'Shooter Off',
+  SHOOTER_READY: 'Shooter Ready',
+  SHOOTER_ATTACK: 'Shooter Attack',
+} as const;
+
+export const BALL_SHOOTER_STATUS = {
+  SHOOTER_DEACTIVATED: 'Shooter Deactivated',
+  SHOOTER_PREPARING_ENGINES: 'Shooter Preparing Engines',
+  SHOOTER_ACCELERATING_ENGINES: 'Shooter Accelerating Engines',
+  SHOOTING_BALL: 'Shooting Ball',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/hardware/ballShooter/BallShooter.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { BALL_SHOOTER_COMMAND, BALL_SHOOTER_STATUS } from './BallShooter.const';
+
+export const ballShooterCommandSchema = z.enum(BALL_SHOOTER_COMMAND);
+
+export const ballShooterStatusSchema = z.enum(BALL_SHOOTER_STATUS);

package/src/domains/hardware/ballShooter/BallShooter.types.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { ballShooterCommandSchema, ballShooterStatusSchema } from './BallShooter.schema';
+
+export type BallShooterCommand = z.infer<typeof ballShooterCommandSchema>;
+export type BallShooterStatus = z.infer<typeof ballShooterStatusSchema>;

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

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

package/src/domains/hardware/diskSensor/DiskSensor.const.ts

@@ -0,0 +1,17 @@
+export const DISK_SENSOR_COMMAND = {
+  DEACTIVATE_SENSOR: 'Deactivate Sensor',
+  ACTIVATE_SENSOR: 'Activate Sensor',
+  CALIBRATE_SENSOR: 'Calibrate Sensor',
+  CONFIGURE_MODULE: 'Configure Module',
+} as const;
+
+export const DISK_SENSOR_STATUS = {
+  SENSOR_STANDBY: 'Sensor Standby',
+  SENSOR_DEACTIVATED: 'Sensor Deactivated',
+  SENSOR_ACTIVATED: 'Sensor Activated',
+  SENSOR_HIT: 'Sensor Hit',
+  SENSOR_CALIBRATED: 'Sensor Calibrated',
+  SENSOR_IN_ZONE: 'Sensor In Zone',
+  MODULE_IN_CONFIGURATION: 'Module In Configuration',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/hardware/diskSensor/DiskSensor.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { DISK_SENSOR_COMMAND, DISK_SENSOR_STATUS } from './DiskSensor.const';
+
+export const diskSensorCommandSchema = z.enum(DISK_SENSOR_COMMAND);
+
+export const diskSensorStatusSchema = z.enum(DISK_SENSOR_STATUS);
+
+export const configDiskSensorBallShooterModuleOptionsSchema = z.object({
+  prepareVoltagePercentage: z.number().min(0).max(100).optional(),
+  attackVoltagePercentage: z.number().min(0).max(100).optional(),
+  waitTimeAfterHit: z.number().min(1).max(25).optional(),
+});
+
+export const diskSensorBallShooterModuleStatusSchema = z.object({
+  diskSensorStatus: diskSensorStatusSchema,
+});

package/src/domains/hardware/diskSensor/DiskSensor.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import {
+  configDiskSensorBallShooterModuleOptionsSchema,
+  diskSensorBallShooterModuleStatusSchema,
+  diskSensorCommandSchema,
+  diskSensorStatusSchema,
+} from './DiskSensor.schema';
+
+export type DiskSensorCommand = z.infer<typeof diskSensorCommandSchema>;
+export type DiskSensorStatus = z.infer<typeof diskSensorStatusSchema>;
+export type ConfigDiskSensorBallShooterModuleOptions = z.infer<typeof configDiskSensorBallShooterModuleOptionsSchema>;
+export type DiskSensorBallShooterModuleStatus = z.infer<typeof diskSensorBallShooterModuleStatusSchema>;

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

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

package/src/domains/hardware/emergency/Emergency.const.ts

@@ -0,0 +1,12 @@
+export const EMERGENCY_ACTION_COMMAND = {
+  ACTIVATE: 'Activate',
+  DEACTIVATE: 'Deactivate',
+} as const;
+
+export const EMERGENCY_STATUS = {
+  STANDBY: 'Standby',
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  IN_EMERGENCY: 'In Emergency',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/hardware/emergency/Emergency.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { EMERGENCY_ACTION_COMMAND, EMERGENCY_STATUS } from './Emergency.const';
+
+export const emergencyActionCommandSchema = z.enum(EMERGENCY_ACTION_COMMAND);
+
+export const emergencyStatusSchema = z.enum(EMERGENCY_STATUS);
+
+export const emergencyModuleStatusSchema = z.object({
+  emergencyStatus: emergencyStatusSchema,
+});

package/src/domains/hardware/emergency/Emergency.types.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { emergencyActionCommandSchema, emergencyModuleStatusSchema, emergencyStatusSchema } from './Emergency.schema';
+
+export type EmergencyActionCommand = z.infer<typeof emergencyActionCommandSchema>;
+export type EmergencyStatus = z.infer<typeof emergencyStatusSchema>;
+export type EmergencyModuleStatus = z.infer<typeof emergencyModuleStatusSchema>;

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

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

package/src/domains/hardware/flag/Flag.const.ts

@@ -0,0 +1,84 @@
+export const FLAG_STATUS = {
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+  STANDBY: 'Standby',
+  HIT: 'Hit',
+  SHOWING_IMAGE: 'Showing Image',
+  SHOWING_ANIMATION: 'Showing Animation',
+} as const;
+
+export const FLAG_MEDIA_NAME = {
+  HEART_00: 'heart_00',
+  HEART_01: 'heart_01',
+  HEART_02: 'heart_02',
+  HEART_03: 'heart_03',
+  HEART_04: 'heart_04',
+  HEART_05: 'heart_05',
+  HEART_06: 'heart_06',
+  HEART_07: 'heart_07',
+  HEART_08: 'heart_08',
+  HEART_09: 'heart_09',
+  HEART_10: 'heart_10',
+  HEART_11: 'heart_11',
+  HEART_12: 'heart_12',
+
+  // Emojis
+  SMILE: 'smile',
+  POOP: 'poop',
+  HEART: 'heart',
+  LAUGH_WITH_TONGUE_FACE: 'laugh_with_tongue_face',
+  LAUGH_WITH_TONGUE_AND_GLASSES_FACE: 'laugh_with_tongue_and_glasses_face',
+  WINK_TO_SMILE_FACE: 'wink_to_smile_face',
+  LAUGH_WITH_TONGUE_AND_HELMET: 'laugh_with_tongue_and_helmet',
+  BLUE_SMILE_FACE: 'blue_smile_face',
+  BLUE_SMILE_FACE_TO_PINK: 'blue_smile_face_to_pink',
+  PINK_FACE_WITH_GLASSES_TO_BLUE: 'pink_face_with_glasses_to_blue',
+  BLUE_CRYING_FACE: 'blue_crying_face',
+  BLUSH_SMILE_FACE_TO_SMILE: 'blush_smile_face_to_smile',
+  CRYING_FACE: 'crying_face',
+  ANGRY_FACE: 'angry_face',
+  IN_LOVE_FACE: 'in_love_face',
+  FACE_WITH_GLASSES: 'face_with_glasses',
+  DEVIL: 'devil',
+  GHOST: 'ghost',
+  SKULL: 'skull',
+  LIKE: 'like',
+
+  // Flag Power-Ups
+  RANDOM_EFFECT: 'random_effect',
+  HELMET_BLACK_BACKGROUND: 'helmet_black_background',
+  ELECTROCUTED: 'electrocuted',
+  THUNDER_EXPLOSION: 'thunder_explosion',
+  SHIELD_BLUE_TO_PINK: 'shield_blue_to_pink',
+  FALLING_OIL_DROP: 'falling_oil_drop',
+  OIL_DROP_COLORS: 'oil_drop_colors',
+  TURBO: 'turbo',
+  FIREBALL: 'fireball',
+  HIT_EFFECT: 'hit_effect',
+  SLOW_SNAIL: 'slow_snail',
+  NITRO_BOTTLE: 'nitro_bottle',
+  ROCKET_LAUNCHING: 'rocket_launching',
+
+  // Game Effects
+  SPEED_METER_INCREASING: 'speed_meter_increasing',
+  THREE_TWO_ONE_RACE_START: 'three_two_one_race_start',
+  VICTORY: 'victory',
+  DANGER_YELLOW_AND_RED: 'danger_yellow_and_red',
+  DANGER_RED_AND_WHITE_RED: 'danger_red_and_white_red',
+  REPAIR_TOOLS: 'repair_tools',
+
+  // Logos
+  BR_CHANGE_COLOR: 'br_change_color',
+
+  // Static Power-Ups
+  STATIC_HELMET: 'static_helmet',
+  STATIC_LIGHTNING: 'static_lightning',
+  STATIC_SHIELD: 'static_shield',
+  STATIC_OIL_DROP: 'static_oil_drop',
+  STATIC_EXHAUST: 'static_exhaust',
+  STATIC_FIREBALL: 'static_fireball',
+  STATIC_BEATING_HEART: 'static_beating_heart',
+  STATIC_SPEED_PAD: 'static_speed_pad',
+} as const;

package/src/domains/hardware/flag/Flag.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { colorNameSchema } from '../../color';
+import { checkpointTypeSchema } from '../../checkpoint';
+import { FLAG_MEDIA_NAME, FLAG_STATUS } from './Flag.const';
+
+export const flagStatusSchema = z.enum(FLAG_STATUS);
+
+export const flagMediaNameSchema = z.enum(FLAG_MEDIA_NAME);
+
+export const flagModuleStatusSchema = z.object({
+  flagStatus: flagStatusSchema,
+  lastCheckpointAddress: z.number(),
+  lastCheckpointType: checkpointTypeSchema,
+});
+
+export const flagConfigurationOptionsSchema = z.object({
+  kartId: z.number(),
+  kartNumber: z.number(),
+  kartColor: colorNameSchema, // ensure colorNameSchema is imported
+  screenBrightness: z.number().min(0).max(100),
+  animationTime: z.number().min(1).max(25),
+});
+
+export const flagShowMediaOptionsSchema = z.object({
+  screens: z.object({
+    left: z.boolean(),
+    right: z.boolean(),
+    front: z.boolean(),
+    back: z.boolean(),
+  }),
+  mediaSourceName: flagMediaNameSchema,
+});

package/src/domains/hardware/flag/Flag.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  flagConfigurationOptionsSchema,
+  flagMediaNameSchema,
+  flagModuleStatusSchema,
+  flagShowMediaOptionsSchema,
+  flagStatusSchema,
+} from './Flag.schema';
+
+export type FlagStatus = z.infer<typeof flagStatusSchema>;
+export type FlagMediaName = z.infer<typeof flagMediaNameSchema>;
+export type FlagModuleStatus = z.infer<typeof flagModuleStatusSchema>;
+export type FlagConfigurationOptions = z.infer<typeof flagConfigurationOptionsSchema>;
+export type FlagShowMediaOptions = z.infer<typeof flagShowMediaOptionsSchema>;

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

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

package/src/domains/hardware/index.ts

@@ -0,0 +1,17 @@
+export * from './ballSensor';
+export * from './ballShooter';
+export * from './diskSensor';
+export * from './emergency';
+export * from './flag';
+export * from './kart-effect';
+export * from './lights';
+export * from './ModuleName.const';
+export * from './ModuleStatus.schema';
+export * from './ModuleStatus.types';
+export * from './KartHardwareState.schema'; // Added
+export * from './rgb';
+export * from './screen';
+export * from './sound';
+export * from './speed';
+export * from './star-laser';
+export * from './steering-wheel';

package/src/domains/hardware/kart-effect/KartEffect.const.ts

@@ -0,0 +1,20 @@
+export const KART_EFFECT = {
+  SHOW_COLOR_KART: 'Show Color Kart',
+  STAR_EFFECT: 'Star Effect',
+  RAY_EFFECT: 'Ray Effect',
+  RAY_HIT_EFFECT: 'Ray Hit Effect',
+  SPEED_BOOST_EFFECT: 'Speed Boost Effect',
+  CHARGED_POWER_EFFECT: 'Charged Power Effect',
+  ROULETTE_EFFECT: 'Roulette Effect',
+  SHIELD_EFFECT: 'Shield Effect',
+  BROKEN_SHIELD_EFFECT: 'Broken Shield Effect',
+  HIT_RIGHT_EFFECT: 'Hit Right Effect',
+  HIT_LEFT_EFFECT: 'Hit Left Effect',
+  HIT_FRONT_EFFECT: 'Hit Front Effect',
+  HIT_BACK_EFFECT: 'Hit Back Effect',
+  HIT_DISK_EFFECT: 'Hit Disk Effect',
+  BALL_SHOT_EFFECT: 'Ball Shot Effect',
+  DISK_SHOT_EFFECT: 'Disk Shot Effect',
+  EMERGENCY_EFFECT: 'Emergency Effect',
+  WAIT_EFFECT: 'Wait Effect',
+} as const;

package/src/domains/hardware/kart-effect/KartEffect.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { KART_EFFECT } from './KartEffect.const';
+
+export const kartEffectSchema = z.enum(KART_EFFECT);

package/src/domains/hardware/kart-effect/KartEffect.types.ts

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

package/src/domains/hardware/kart-effect/index.ts

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