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

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

package/src/domains/hardware/lights/Lights.const.ts

@@ -0,0 +1,11 @@
+export const LIGHTS_EFFECT = {
+  SHOW_UV_COLOR: 'SHOW_UV_COLOR',
+  POWER_OFF: 'POWER_OFF',
+  // GAME EFFECTS
+  START_GAME: 'START_GAME',
+  GAME_OVER: 'GAME_OVER',
+  FINAL_LAP: 'FINAL_LAP',
+  YELLOW_FLAG: 'YELLOW_FLAG',
+  RED_FLAG: 'RED_FLAG',
+  PULSE: 'PULSE',
+} as const;

package/src/domains/hardware/lights/Lights.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { LIGHTS_EFFECT } from './Lights.const';
+
+export const lightsEffectSchema = z.enum(LIGHTS_EFFECT);
+
+export const showLightsColorParamsSchema = z.object({
+  address: z.union([z.array(z.number()), z.literal('all')]),
+  timeDuration: z.number().min(1).max(25),
+  color: z.string(), // Hex RGB
+});
+
+export const showLightsEffectParamsSchema = z.object({
+  addresses: z.union([z.array(z.number()), z.literal('all')]),
+  effect: lightsEffectSchema,
+  timeDuration: z.number().min(1).max(25),
+});

package/src/domains/hardware/lights/Lights.types.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { lightsEffectSchema, showLightsColorParamsSchema, showLightsEffectParamsSchema } from './Lights.schema';
+
+export type LightsEffect = z.infer<typeof lightsEffectSchema>;
+export type ShowLightsColorParams = z.infer<typeof showLightsColorParamsSchema>;
+export type ShowLightsEffectParams = z.infer<typeof showLightsEffectParamsSchema>;

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

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

package/src/domains/hardware/rgb/RGB.const.ts

@@ -0,0 +1,8 @@
+export const RGB_STATUS = {
+  SHOWING_COLOR: 'Showing Color',
+  NOT_CONFIGURED: 'Not Configured',
+  CONFIGURING_RGB: 'Configuring RGB',
+  SHOWING_EFFECT: 'Showing Effect',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+} as const;

package/src/domains/hardware/rgb/RGB.schema.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { colorNameSchema } from '../../color';
+import { kartEffectSchema } from '../../hardware/kart-effect';
+import { RGB_STATUS } from './RGB.const';
+
+export const rgbStatusSchema = z.enum(RGB_STATUS);
+
+export const rgbModuleStatusSchema = z.object({
+  rgbStatus: rgbStatusSchema,
+  kartColor: colorNameSchema,
+});
+
+export const rgbConfigurationOptionsSchema = z.object({
+  kartColor: colorNameSchema,
+  brightness: z.number().min(0).max(100),
+  effectTime: z.number().min(1).max(25),
+});
+
+export const rgbShowEffectOptionsSchema = z.object({
+  effect: kartEffectSchema,
+});

package/src/domains/hardware/rgb/RGB.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import {
+  rgbConfigurationOptionsSchema,
+  rgbModuleStatusSchema,
+  rgbShowEffectOptionsSchema,
+  rgbStatusSchema,
+} from './RGB.schema';
+
+export type RGBStatus = z.infer<typeof rgbStatusSchema>;
+export type RGBModuleStatus = z.infer<typeof rgbModuleStatusSchema>;
+export type RGBConfigurationOptions = z.infer<typeof rgbConfigurationOptionsSchema>;
+export type RGBShowEffectOptions = z.infer<typeof rgbShowEffectOptionsSchema>;

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

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

package/src/domains/hardware/screen/Screen.const.ts

@@ -0,0 +1,17 @@
+export const SCREEN_STATUS = {
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+  DEBUG: 'Debug',
+} as const;
+
+export const SCREEN_VIEW = {
+  HOME: 'Home',
+  COUNTDOWN: 'Countdown',
+  RACE: 'Race',
+  GAME_SUMMARY: 'GameSummary',
+  INSTRUCTION_VIDEO: 'InstructionVideo',
+  BATTLE: 'Battle',
+  DEBUG: 'Debug',
+} as const;

package/src/domains/hardware/screen/Screen.schema.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+
+import { damageEffectNameSchema } from '../../damage';
+import { kartHardwareStateSchema } from '../../hardware';
+import { powerUpNameSchema } from '../../powerUp/PowerUpAttributes.schema';
+import { SCREEN_STATUS, SCREEN_VIEW } from './Screen.const';
+import { KART_FINAL_STATE } from '../../kart';
+
+export const screenStatusSchema = z.enum(SCREEN_STATUS);
+export const screenViewSchema = z.enum(SCREEN_VIEW);
+// KART_FINAL_STATE is { FINISHED: 'finished', ... } as const. z.nativeEnum works with it.
+export const kartFinalStateSchema = z.enum(KART_FINAL_STATE);
+
+export const screenModuleStatusSchema = z.object({
+  latestView: screenViewSchema,
+  screenStatus: screenStatusSchema,
+});
+
+export const screenCurrentTotalSchema = z.object({
+  current: z.number().nullable(),
+  total: z.number().nullable(),
+});
+
+export const screenGameTimeLeftSchema = z.object({
+  minutes: z.number().nullable().optional(),
+  seconds: z.number().nullable().optional(),
+});
+
+export const screenViewBaseConfigSchema = z.object({
+  position: screenCurrentTotalSchema.optional(),
+  coins: z.number().nullable().optional(),
+  gameTimeLeft: screenGameTimeLeftSchema.optional(),
+  powerUp: z
+    .union([powerUpNameSchema, z.literal('Clear PowerUp')])
+    .nullable()
+    .optional(),
+  powerUpAnimationTimeSeconds: z.number().nullable().optional(),
+  damageEffect: z
+    .union([damageEffectNameSchema, z.literal('Yellow Flag'), z.literal('Red Flag')])
+    .nullable()
+    .optional(),
+  damageAnimationTimeSeconds: z
+    .union([z.literal('Infinite'), z.number()])
+    .nullable()
+    .optional(),
+});
+
+export const screenRaceViewConfigSchema = screenViewBaseConfigSchema.extend({
+  laps: screenCurrentTotalSchema.optional(),
+});
+
+export const screenBattleViewConfigSchema = screenViewBaseConfigSchema.extend({
+  lives: screenCurrentTotalSchema.optional(),
+});
+
+export const countDownNextViewRaceSchema = z.object({
+  nextView: z.literal('Race'),
+  config: screenRaceViewConfigSchema,
+});
+export const countDownNextViewBattleSchema = z.object({
+  nextView: z.literal('Battle'),
+  config: screenBattleViewConfigSchema,
+});
+
+export const screenCountdownParamsSchema = z.union([countDownNextViewRaceSchema, countDownNextViewBattleSchema]);
+
+export const updateRaceViewInputSchema = z.object({ view: z.literal('Race'), config: screenRaceViewConfigSchema });
+export const updateBattleViewInputSchema = z.object({
+  view: z.literal('Battle'),
+  config: screenBattleViewConfigSchema,
+});
+
+export const screenUpdateGameViewInputSchema = z.union([updateRaceViewInputSchema, updateBattleViewInputSchema]);
+
+export const screenFinishViewInputSchema = z.object({
+  kartNumber: z.number().optional(),
+  kartPosition: screenCurrentTotalSchema,
+  coins: z.number(),
+  finalState: kartFinalStateSchema.optional(),
+});
+
+export const screenDebugViewInputSchema = kartHardwareStateSchema.extend({
+  kartNumber: z.number(),
+});
+
+export const screenHomeViewInputSchema = z.object({
+  kartNumber: z.number().nullable().optional(),
+});

package/src/domains/hardware/screen/Screen.types.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import {
+  countDownNextViewBattleSchema,
+  countDownNextViewRaceSchema,
+  screenBattleViewConfigSchema,
+  screenCountdownParamsSchema,
+  screenDebugViewInputSchema,
+  screenFinishViewInputSchema,
+  screenGameTimeLeftSchema,
+  screenHomeViewInputSchema,
+  screenModuleStatusSchema,
+  screenRaceViewConfigSchema,
+  screenStatusSchema,
+  screenUpdateGameViewInputSchema,
+  screenViewBaseConfigSchema,
+  screenViewSchema,
+  updateBattleViewInputSchema,
+  updateRaceViewInputSchema,
+} from './Screen.schema';
+
+export type ScreenStatus = z.infer<typeof screenStatusSchema>;
+export type ScreenView = z.infer<typeof screenViewSchema>;
+export type ScreenModuleStatus = z.infer<typeof screenModuleStatusSchema>;
+
+export type ScreenViewBaseConfig = z.infer<typeof screenViewBaseConfigSchema>;
+export type ScreenRaceViewConfig = z.infer<typeof screenRaceViewConfigSchema>;
+export type ScreenBattleViewConfig = z.infer<typeof screenBattleViewConfigSchema>;
+
+export type ScreenGameTimeLeft = z.infer<typeof screenGameTimeLeftSchema>;
+export type CountDownNextViewRace = z.infer<typeof countDownNextViewRaceSchema>;
+export type CountDownNextViewBattle = z.infer<typeof countDownNextViewBattleSchema>;
+export type ScreenCountdownParams = z.infer<typeof screenCountdownParamsSchema>;
+
+export type UpdateRaceViewInput = z.infer<typeof updateRaceViewInputSchema>;
+export type UpdateBattleViewInput = z.infer<typeof updateBattleViewInputSchema>;
+export type ScreenUpdateGameViewInput = z.infer<typeof screenUpdateGameViewInputSchema>;
+export type ScreenFinishViewInput = z.infer<typeof screenFinishViewInputSchema>;
+export type ScreenDebugViewInput = z.infer<typeof screenDebugViewInputSchema>;
+export type ScreenHomeViewInput = z.infer<typeof screenHomeViewInputSchema>;

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

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

package/src/domains/hardware/sound/Sound.const.ts

@@ -0,0 +1,3 @@
+export const PLAY_SOUND_DURATION = {
+  INFINITE: 'infinite',
+} as const;

package/src/domains/hardware/sound/Sound.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { soundNameSchema } from '../../sounds'; // Import from domains/sounds
+import { PLAY_SOUND_DURATION } from './Sound.const';
+
+export const playSoundOptionsSchema = z.object({
+  soundName: soundNameSchema,
+  durationMs: z.union([z.number(), z.literal(PLAY_SOUND_DURATION.INFINITE)]).optional(),
+});

package/src/domains/hardware/sound/Sound.types.ts

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

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

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

package/src/domains/hardware/speed/Speed.const.ts

@@ -0,0 +1,17 @@
+export const SPEED_STATUS = {
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+  STANDBY: 'Standby',
+  CHANGING_SPEED: 'Changing Speed',
+  IN_EMERGENCY: 'In Emergency',
+} as const;
+
+export const SPEED_ACTION_COMMAND = {
+  ACTIVATE: 'Activate',
+  DEACTIVATE: 'Deactivate',
+  CHANGE_SPEED: 'ChangeSpeed',
+  CONFIGURE: 'Configure',
+  RESTART: 'Restart',
+} as const;

package/src/domains/hardware/speed/Speed.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { SPEED_ACTION_COMMAND, SPEED_STATUS } from './Speed.const';
+
+export const speedStatusSchema = z.enum(SPEED_STATUS);
+
+export const speedModuleStatusSchema = z.object({
+  speedStatus: speedStatusSchema,
+  battery12V: z.number(),
+  currentSpeed: z.number(),
+  ADCVoltage: z.number(),
+  DACVoltage: z.number(),
+  currentDefaultSpeedConfig: z.number(),
+});
+
+export const speedActionCommandSchema = z.enum(SPEED_ACTION_COMMAND);
+
+export const speedChangeOptionsSchema = z.object({
+  speed: z.number().min(0).max(100),
+  forUnlimitedTime: z.boolean().optional(),
+});
+
+export const speedConfigurationSchema = z.object({
+  defaultSpeed: z.number().min(0).max(100),
+  timeDuration: z.number().min(1).max(25),
+});

package/src/domains/hardware/speed/Speed.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  speedActionCommandSchema,
+  speedChangeOptionsSchema,
+  speedConfigurationSchema,
+  speedModuleStatusSchema,
+  speedStatusSchema,
+} from './Speed.schema';
+
+export type SpeedStatus = z.infer<typeof speedStatusSchema>;
+export type SpeedModuleStatus = z.infer<typeof speedModuleStatusSchema>;
+export type SpeedActionCommand = z.infer<typeof speedActionCommandSchema>;
+export type SpeedChangeOptions = z.infer<typeof speedChangeOptionsSchema>;
+export type SpeedConfiguration = z.infer<typeof speedConfigurationSchema>;