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

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

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,22 @@
+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 './player';
+export * from './racingTeam';
+export * from './session';
+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/KartHardwareState.schema';
+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/player/Player.const.ts

@@ -0,0 +1,4 @@
+export const PLAYER_TYPE = {
+  ADULT: 'ADULT',
+  MINOR: 'MINOR', // Managed by a Guardian
+} as const;

package/src/domains/player/Player.schema.ts

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

package/src/domains/player/Player.types.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { playerSchema, playerStatsSchema, playerTypeSchema, playerWaiverStatusSchema } from './Player.schema';
+
+export type PlayerType = z.infer<typeof playerTypeSchema>;
+export type PlayerStats = z.infer<typeof playerStatsSchema>;
+export type PlayerWaiverStatus = z.infer<typeof playerWaiverStatusSchema>;
+
+export type Player = z.infer<typeof playerSchema>;

package/src/domains/player/index.ts

@@ -0,0 +1,3 @@
+export * from './Player.const';
+export * from './Player.schema';
+export * from './Player.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,22 @@
+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',
+  CASHIER: 'CASHIER',
+} 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/session/Session.const.ts

@@ -0,0 +1,7 @@
+export const SESSION_STATUS = {
+  CREATED: 'CREATED',
+  READY: 'READY',
+  STARTED: 'STARTED',
+  FINISHED: 'FINISHED',
+  CANCELLED: 'CANCELLED',
+} as const;