website refactor

core/racing/application/errors/RacingApplicationError.ts

@@ -1,4 +1,5 @@
-import type { ApplicationError, CommonApplicationErrorKind } from '@core/shared/errors';
+import type { ApplicationError } from '@core/shared/errors/ApplicationError';
+import type { CommonApplicationErrorKind } from '@core/shared/errors/ApplicationError';
 
 export abstract class RacingApplicationError
   extends Error

core/racing/application/ports/TeamRaceResultsProvider.ts

@@ -1,7 +1,7 @@
 import { TeamDrivingRaceFactsDto } from '../../domain/services/TeamDrivingRatingEventFactory';
 
 /**
- * Port: ITeamRaceResultsProvider
+ * Port: TeamRaceResultsProvider
  *
  * Provides race results for teams from the racing context.
  * This is a port that adapts the racing domain data to the rating system.

core/racing/application/queries/GetTeamRatingLedgerQuery.ts

@@ -17,7 +17,7 @@ export interface GetTeamRatingLedgerQuery {
 
 export class GetTeamRatingLedgerQueryHandler {
   constructor(
-    private readonly ratingEventRepo: ITeamRatingEventRepository
+    private readonly ratingEventRepo: TeamRatingEventRepository
   ) {}
 
   async execute(query: GetTeamRatingLedgerQuery): Promise<PaginatedTeamLedgerResult> {

core/racing/application/queries/GetTeamRatingsSummaryQuery.ts

@@ -15,8 +15,8 @@ export interface GetTeamRatingsSummaryQuery {
 
 export class GetTeamRatingsSummaryQueryHandler {
   constructor(
-    private readonly teamRatingRepo: ITeamRatingRepository,
-    private readonly ratingEventRepo: ITeamRatingEventRepository
+    private readonly teamRatingRepo: TeamRatingRepository,
+    private readonly ratingEventRepo: TeamRatingEventRepository
   ) {}
 
   async execute(query: GetTeamRatingsSummaryQuery): Promise<TeamRatingSummaryDto> {

core/racing/application/use-cases/AcceptSponsorshipRequestUseCase.test.ts

@@ -70,13 +70,13 @@ describe('AcceptSponsorshipRequestUseCase', () => {
 
   it('should send notification to sponsor, process payment, update wallets, and return result when accepting season sponsorship', async () => {
     const useCase = new AcceptSponsorshipRequestUseCase(
-      mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSeasonSponsorshipRepo as unknown as ISeasonSponsorshipRepository,
-      mockSeasonRepo as unknown as ISeasonRepository,
+      mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSeasonSponsorshipRepo as unknown as SeasonSponsorshipRepository,
+      mockSeasonRepo as unknown as SeasonRepository,
       mockNotificationService as unknown as NotificationService,
       processPayment,
-      mockWalletRepo as unknown as IWalletRepository,
-      mockLeagueWalletRepo as unknown as ILeagueWalletRepository,
+      mockWalletRepo as unknown as WalletRepository,
+      mockLeagueWalletRepo as unknown as LeagueWalletRepository,
       mockLogger as unknown as Logger,
     );
 
@@ -189,13 +189,13 @@ describe('AcceptSponsorshipRequestUseCase', () => {
 
   it('should return error when sponsorship request not found', async () => {
     const useCase = new AcceptSponsorshipRequestUseCase(
-      mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSeasonSponsorshipRepo as unknown as ISeasonSponsorshipRepository,
-      mockSeasonRepo as unknown as ISeasonRepository,
+      mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSeasonSponsorshipRepo as unknown as SeasonSponsorshipRepository,
+      mockSeasonRepo as unknown as SeasonRepository,
       mockNotificationService as unknown as NotificationService,
       processPayment,
-      mockWalletRepo as unknown as IWalletRepository,
-      mockLeagueWalletRepo as unknown as ILeagueWalletRepository,
+      mockWalletRepo as unknown as WalletRepository,
+      mockLeagueWalletRepo as unknown as LeagueWalletRepository,
       mockLogger as unknown as Logger,
     );
 
@@ -212,13 +212,13 @@ describe('AcceptSponsorshipRequestUseCase', () => {
 
   it('should return error when sponsorship request is not pending', async () => {
     const useCase = new AcceptSponsorshipRequestUseCase(
-      mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSeasonSponsorshipRepo as unknown as ISeasonSponsorshipRepository,
-      mockSeasonRepo as unknown as ISeasonRepository,
+      mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSeasonSponsorshipRepo as unknown as SeasonSponsorshipRepository,
+      mockSeasonRepo as unknown as SeasonRepository,
       mockNotificationService as unknown as NotificationService,
       processPayment,
-      mockWalletRepo as unknown as IWalletRepository,
-      mockLeagueWalletRepo as unknown as ILeagueWalletRepository,
+      mockWalletRepo as unknown as WalletRepository,
+      mockLeagueWalletRepo as unknown as LeagueWalletRepository,
       mockLogger as unknown as Logger,
     );
 

core/racing/application/use-cases/AcceptSponsorshipRequestUseCase.ts

@@ -39,13 +39,13 @@ export interface ProcessPaymentResult {
 
 export class AcceptSponsorshipRequestUseCase {
   constructor(
-    private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
-    private readonly seasonSponsorshipRepo: ISeasonSponsorshipRepository,
-    private readonly seasonRepository: ISeasonRepository,
+    private readonly sponsorshipRequestRepo: SponsorshipRequestRepository,
+    private readonly seasonSponsorshipRepo: SeasonSponsorshipRepository,
+    private readonly seasonRepository: SeasonRepository,
     private readonly notificationService: NotificationService,
     private readonly paymentProcessor: (input: ProcessPaymentInput) => Promise<ProcessPaymentResult>,
-    private readonly walletRepository: IWalletRepository,
-    private readonly leagueWalletRepository: ILeagueWalletRepository,
+    private readonly walletRepository: WalletRepository,
+    private readonly leagueWalletRepository: LeagueWalletRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/AppendTeamRatingEventsUseCase.ts

@@ -11,8 +11,8 @@ import { TeamRatingSnapshotCalculator } from '@core/racing/domain/services/TeamR
  */
 export class AppendTeamRatingEventsUseCase {
   constructor(
-    private readonly ratingEventRepository: ITeamRatingEventRepository,
-    private readonly ratingRepository: ITeamRatingRepository,
+    private readonly ratingEventRepository: TeamRatingEventRepository,
+    private readonly ratingRepository: TeamRatingRepository,
   ) {}
 
   /**

core/racing/application/use-cases/ApplyForSponsorshipUseCase.test.ts

@@ -40,9 +40,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should return error when sponsor does not exist', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue(null);
@@ -61,9 +61,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should return error when sponsorship pricing is not set up', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue({ id: 'sponsor1' });
@@ -83,9 +83,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should return error when entity is not accepting applications', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue({ id: 'sponsor1' });
@@ -109,9 +109,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should return error when no slots are available', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue({ id: 'sponsor1' });
@@ -135,9 +135,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should return error when sponsor has pending request', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue({ id: 'sponsor1' });
@@ -162,9 +162,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should return error when offered amount is less than minimum', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue({ id: 'sponsor1' });
@@ -189,9 +189,9 @@ describe('ApplyForSponsorshipUseCase', () => {
 
   it('should create sponsorship request and return result on success', async () => {
 
-    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      mockSponsorshipPricingRepo as unknown as ISponsorshipPricingRepository,
-      mockSponsorRepo as unknown as ISponsorRepository,
+    const useCase = new ApplyForSponsorshipUseCase(mockSponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      mockSponsorshipPricingRepo as unknown as SponsorshipPricingRepository,
+      mockSponsorRepo as unknown as SponsorRepository,
       mockLogger as unknown as Logger);
 
     mockSponsorRepo.findById.mockResolvedValue({ id: 'sponsor1' });

core/racing/application/use-cases/ApplyForSponsorshipUseCase.ts

@@ -29,9 +29,9 @@ export interface ApplyForSponsorshipResult {
 
 export class ApplyForSponsorshipUseCase {
   constructor(
-    private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
-    private readonly sponsorshipPricingRepo: ISponsorshipPricingRepository,
-    private readonly sponsorRepo: ISponsorRepository,
+    private readonly sponsorshipRequestRepo: SponsorshipRequestRepository,
+    private readonly sponsorshipPricingRepo: SponsorshipPricingRepository,
+    private readonly sponsorRepo: SponsorRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/ApplyPenaltyUseCase.ts

@@ -28,10 +28,10 @@ export interface ApplyPenaltyResult {
 
 export class ApplyPenaltyUseCase {
   constructor(
-    private readonly penaltyRepository: IPenaltyRepository,
-    private readonly protestRepository: IProtestRepository,
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly penaltyRepository: PenaltyRepository,
+    private readonly protestRepository: ProtestRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/ApproveLeagueJoinRequestUseCase.test.ts

@@ -33,8 +33,8 @@ describe('ApproveLeagueJoinRequestUseCase', () => {
 
   it('approve removes request and adds member', async () => {
 
-    const useCase = new ApproveLeagueJoinRequestUseCase(mockLeagueMembershipRepo as unknown as ILeagueMembershipRepository,
-      mockLeagueRepo as unknown as ILeagueRepository);
+    const useCase = new ApproveLeagueJoinRequestUseCase(mockLeagueMembershipRepo as unknown as LeagueMembershipRepository,
+      mockLeagueRepo as unknown as LeagueRepository);
 
     const leagueId = 'league-1';
     const joinRequestId = 'req-1';
@@ -83,8 +83,8 @@ describe('ApproveLeagueJoinRequestUseCase', () => {
 
   it('approve returns error when request missing', async () => {
 
-    const useCase = new ApproveLeagueJoinRequestUseCase(mockLeagueMembershipRepo as unknown as ILeagueMembershipRepository,
-      mockLeagueRepo as unknown as ILeagueRepository);
+    const useCase = new ApproveLeagueJoinRequestUseCase(mockLeagueMembershipRepo as unknown as LeagueMembershipRepository,
+      mockLeagueRepo as unknown as LeagueRepository);
 
     mockLeagueRepo.findById.mockResolvedValue(
       League.create({
@@ -112,8 +112,8 @@ describe('ApproveLeagueJoinRequestUseCase', () => {
 
   it('rejects approval when league is at capacity and does not mutate state', async () => {
 
-    const useCase = new ApproveLeagueJoinRequestUseCase(mockLeagueMembershipRepo as unknown as ILeagueMembershipRepository,
-      mockLeagueRepo as unknown as ILeagueRepository);
+    const useCase = new ApproveLeagueJoinRequestUseCase(mockLeagueMembershipRepo as unknown as LeagueMembershipRepository,
+      mockLeagueRepo as unknown as LeagueRepository);
 
     const leagueId = 'league-1';
     const joinRequestId = 'req-1';

core/racing/application/use-cases/ApproveLeagueJoinRequestUseCase.ts

@@ -21,8 +21,8 @@ export interface ApproveLeagueJoinRequestResult {
 
 export class ApproveLeagueJoinRequestUseCase {
   constructor(
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/ApproveTeamJoinRequestUseCase.test.ts

@@ -17,7 +17,7 @@ describe('ApproveTeamJoinRequestUseCase', () => {
       saveMembership: vi.fn(),
     };
     useCase = new ApproveTeamJoinRequestUseCase(
-      membershipRepository as unknown as ITeamMembershipRepository,
+      membershipRepository as unknown as TeamMembershipRepository,
     );
   });
 

core/racing/application/use-cases/ApproveTeamJoinRequestUseCase.ts

@@ -23,7 +23,7 @@ export type ApproveTeamJoinRequestErrorCode =
 
 export class ApproveTeamJoinRequestUseCase {
   constructor(
-    private readonly membershipRepository: ITeamMembershipRepository,
+    private readonly membershipRepository: TeamMembershipRepository,
   ) {}
 
   async execute(command: ApproveTeamJoinRequestInput): Promise<

core/racing/application/use-cases/CancelRaceUseCase.ts

@@ -24,7 +24,7 @@ export type CancelRaceResult = {
  */
 export class CancelRaceUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
+    private readonly raceRepository: RaceRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/CloseRaceEventStewardingUseCase.ts

@@ -26,9 +26,9 @@ export type CloseRaceEventStewardingResult = {
 export class CloseRaceEventStewardingUseCase {
   constructor(
     private readonly logger: Logger,
-    private readonly raceEventRepository: IRaceEventRepository,
-    private readonly raceRegistrationRepository: IRaceRegistrationRepository,
-    private readonly penaltyRepository: IPenaltyRepository,
+    private readonly raceEventRepository: RaceEventRepository,
+    private readonly raceRegistrationRepository: RaceRegistrationRepository,
+    private readonly penaltyRepository: PenaltyRepository,
     private readonly domainEventPublisher: DomainEventPublisher,
   ) {}
 

core/racing/application/use-cases/CompleteDriverOnboardingUseCase.test.ts

@@ -31,7 +31,7 @@ describe('CompleteDriverOnboardingUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger & { error: Mock };
     output = { present: vi.fn() } as unknown as typeof output;
-    useCase = new CompleteDriverOnboardingUseCase(driverRepository as unknown as IDriverRepository,
+    useCase = new CompleteDriverOnboardingUseCase(driverRepository as unknown as DriverRepository,
       logger);
   });
 

core/racing/application/use-cases/CompleteDriverOnboardingUseCase.ts

@@ -31,7 +31,7 @@ export type CompleteDriverOnboardingApplicationError = ApplicationErrorCode<
  */
 export class CompleteDriverOnboardingUseCase {
   constructor(
-    private readonly driverRepository: IDriverRepository,
+    private readonly driverRepository: DriverRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/CompleteRaceUseCase.ts

@@ -40,10 +40,10 @@ interface DriverRatingOutput {
 
 export class CompleteRaceUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly raceRegistrationRepository: IRaceRegistrationRepository,
-    private readonly resultRepository: IResultRepository,
-    private readonly standingRepository: IStandingRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly raceRegistrationRepository: RaceRegistrationRepository,
+    private readonly resultRepository: ResultRepository,
+    private readonly standingRepository: StandingRepository,
     private readonly getDriverRating: (input: DriverRatingInput) => Promise<DriverRatingOutput>,
   ) {}
 

core/racing/application/use-cases/CompleteRaceUseCaseWithRatings.test.ts

@@ -69,10 +69,10 @@ describe('CompleteRaceUseCaseWithRatings', () => {
 
     // Test without raceResultsProvider (backward compatible mode)
     useCase = new CompleteRaceUseCaseWithRatings(
-      raceRepository as unknown as IRaceRepository,
-      raceRegistrationRepository as unknown as IRaceRegistrationRepository,
-      resultRepository as unknown as IResultRepository,
-      standingRepository as unknown as IStandingRepository,
+      raceRepository as unknown as RaceRepository,
+      raceRegistrationRepository as unknown as RaceRegistrationRepository,
+      resultRepository as unknown as ResultRepository,
+      standingRepository as unknown as StandingRepository,
       driverRatingProvider,
       ratingUpdateService as unknown as RatingUpdateService,
     );
@@ -232,13 +232,13 @@ describe('CompleteRaceUseCaseWithRatings', () => {
     beforeEach(() => {
       // Create use case with raceResultsProvider for ledger mode
       useCaseWithLedger = new CompleteRaceUseCaseWithRatings(
-        raceRepository as unknown as IRaceRepository,
-        raceRegistrationRepository as unknown as IRaceRegistrationRepository,
-        resultRepository as unknown as IResultRepository,
-        standingRepository as unknown as IStandingRepository,
+        raceRepository as unknown as RaceRepository,
+        raceRegistrationRepository as unknown as RaceRegistrationRepository,
+        resultRepository as unknown as ResultRepository,
+        standingRepository as unknown as StandingRepository,
         driverRatingProvider,
         ratingUpdateService as unknown as RatingUpdateService,
-        raceResultsProvider as unknown as IRaceResultsProvider,
+        raceResultsProvider as unknown as RaceResultsProvider,
       );
     });
 

core/racing/application/use-cases/CompleteRaceUseCaseWithRatings.ts

@@ -35,13 +35,13 @@ interface DriverRatingProvider {
  * EVOLVED (Slice 7): Now uses ledger-based rating updates for transparency and auditability.
  */
 export class CompleteRaceUseCaseWithRatings {
-  constructor(private readonly raceRepository: IRaceRepository,
-    private readonly raceRegistrationRepository: IRaceRegistrationRepository,
-    private readonly resultRepository: IResultRepository,
-    private readonly standingRepository: IStandingRepository,
+  constructor(private readonly raceRepository: RaceRepository,
+    private readonly raceRegistrationRepository: RaceRegistrationRepository,
+    private readonly resultRepository: ResultRepository,
+    private readonly standingRepository: StandingRepository,
     private readonly driverRatingProvider: DriverRatingProvider,
     private readonly ratingUpdateService: RatingUpdateService,
-    private readonly raceResultsProvider?: IRaceResultsProvider, // Optional: for new ledger flow
+    private readonly raceResultsProvider?: RaceResultsProvider, // Optional: for new ledger flow
   ) {}
 
   async execute(command: CompleteRaceWithRatingsInput): Promise<

core/racing/application/use-cases/CreateLeagueSeasonScheduleRaceUseCase.test.ts

@@ -48,8 +48,8 @@ describe('CreateLeagueSeasonScheduleRaceUseCase', () => {
     seasonRepository.findById.mockResolvedValue(season);
     raceRepository.create.mockImplementation(async (race: Race) => race);
 
-    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger,
       { generateRaceId: () => 'race-123' },
     );
@@ -77,8 +77,8 @@ describe('CreateLeagueSeasonScheduleRaceUseCase', () => {
     const season = createSeasonWithinWindow({ leagueId: 'other-league' });
     seasonRepository.findById.mockResolvedValue(season);
 
-    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger,
       { generateRaceId: () => 'race-123' },
     );
@@ -105,8 +105,8 @@ describe('CreateLeagueSeasonScheduleRaceUseCase', () => {
     const season = createSeasonWithinWindow();
     seasonRepository.findById.mockResolvedValue(season);
 
-    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger,
       { generateRaceId: () => 'race-123' },
     );
@@ -144,8 +144,8 @@ describe('CreateLeagueSeasonScheduleRaceUseCase', () => {
     seasonRepository.findById.mockResolvedValue(season);
     raceRepository.create.mockRejectedValue(repositoryError);
 
-    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger,
       { generateRaceId: () => 'race-123' },
     );
@@ -170,8 +170,8 @@ describe('CreateLeagueSeasonScheduleRaceUseCase', () => {
   it('returns SEASON_NOT_FOUND when season does not exist', async () => {
     seasonRepository.findById.mockResolvedValue(null);
 
-    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger,
       { generateRaceId: () => 'race-123' },
     );
@@ -197,8 +197,8 @@ describe('CreateLeagueSeasonScheduleRaceUseCase', () => {
     const repositoryError = new Error('DB connection failed');
     seasonRepository.findById.mockRejectedValue(repositoryError);
 
-    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new CreateLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger,
       { generateRaceId: () => 'race-123' },
     );

core/racing/application/use-cases/CreateLeagueSeasonScheduleRaceUseCase.ts

@@ -18,8 +18,8 @@ export type CreateLeagueSeasonScheduleRaceErrorCode =
 
 export class CreateLeagueSeasonScheduleRaceUseCase {
   constructor(
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly raceRepository: IRaceRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly raceRepository: RaceRepository,
     private readonly logger: Logger,
     private readonly deps: { generateRaceId: () => string },
   ) {}

core/racing/application/use-cases/CreateLeagueWithSeasonAndScoringUseCase.ts

@@ -52,9 +52,9 @@ type ScoringPreset = {
 
 export class CreateLeagueWithSeasonAndScoringUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueScoringConfigRepository: LeagueScoringConfigRepository,
     private readonly getLeagueScoringPresetById: (input: { presetId: string }) => Promise<ScoringPreset | undefined>,
     private readonly logger: Logger,
   ) {}

core/racing/application/use-cases/CreateSeasonForLeagueUseCase.ts

@@ -96,8 +96,8 @@ type CreateSeasonForLeagueErrorCode = 'LEAGUE_NOT_FOUND' | 'VALIDATION_ERROR' |
  */
 export class CreateSeasonForLeagueUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly seasonRepository: SeasonRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/CreateSponsorUseCase.test.ts

@@ -25,7 +25,7 @@ describe('CreateSponsorUseCase', () => {
       error: vi.fn(),
     };
     useCase = new CreateSponsorUseCase(
-      sponsorRepository as unknown as ISponsorRepository,
+      sponsorRepository as unknown as SponsorRepository,
       logger as unknown as Logger,
     );
   });

core/racing/application/use-cases/CreateSponsorUseCase.ts

@@ -22,7 +22,7 @@ export type CreateSponsorResult = {
 
 export class CreateSponsorUseCase {
   constructor(
-    private readonly sponsorRepository: ISponsorRepository,
+    private readonly sponsorRepository: SponsorRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/CreateTeamUseCase.ts

@@ -31,8 +31,8 @@ export type CreateTeamErrorCode =
   | 'REPOSITORY_ERROR';
 
 export class CreateTeamUseCase {
-  constructor(private readonly teamRepository: ITeamRepository,
-    private readonly membershipRepository: ITeamMembershipRepository,
+  constructor(private readonly teamRepository: TeamRepository,
+    private readonly membershipRepository: TeamMembershipRepository,
     private readonly logger: Logger) {}
 
   async execute(

core/racing/application/use-cases/DashboardOverviewUseCase.ts

@@ -83,15 +83,15 @@ export interface DashboardOverviewResult {
 
 export class DashboardOverviewUseCase {
   constructor(
-    private readonly driverRepository: IDriverRepository,
-    private readonly raceRepository: IRaceRepository,
-    private readonly resultRepository: IResultRepository,
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly standingRepository: IStandingRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly raceRegistrationRepository: IRaceRegistrationRepository,
-    private readonly feedRepository: IFeedRepository,
-    private readonly socialRepository: ISocialGraphRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly resultRepository: ResultRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly standingRepository: StandingRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly raceRegistrationRepository: RaceRegistrationRepository,
+    private readonly feedRepository: FeedRepository,
+    private readonly socialRepository: SocialGraphRepository,
     private readonly getDriverAvatar: (driverId: string) => Promise<string>,
     private readonly getDriverStats: (
       driverId: string,

core/racing/application/use-cases/DeleteLeagueSeasonScheduleRaceUseCase.test.ts

@@ -57,8 +57,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     raceRepository.findById.mockResolvedValue(existing);
     raceRepository.delete.mockResolvedValue(undefined);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -76,8 +76,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     const season = createSeasonWithinWindow({ leagueId: 'other-league' });
     seasonRepository.findById.mockResolvedValue(season);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -101,8 +101,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     seasonRepository.findById.mockResolvedValue(season);
     raceRepository.findById.mockResolvedValue(null);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -133,8 +133,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     });
     raceRepository.findById.mockResolvedValue(existing);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -155,8 +155,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
   it('returns SEASON_NOT_FOUND when season does not exist', async () => {
     seasonRepository.findById.mockResolvedValue(null);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -179,8 +179,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     const repositoryError = new Error('DB connection failed');
     seasonRepository.findById.mockRejectedValue(repositoryError);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -212,8 +212,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     raceRepository.findById.mockResolvedValue(existing);
     raceRepository.delete.mockRejectedValue(repositoryError);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({
@@ -237,8 +237,8 @@ describe('DeleteLeagueSeasonScheduleRaceUseCase', () => {
     seasonRepository.findById.mockResolvedValue(season);
     raceRepository.findById.mockRejectedValue(repositoryError);
 
-    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as ISeasonRepository,
-      raceRepository as unknown as IRaceRepository,
+    const useCase = new DeleteLeagueSeasonScheduleRaceUseCase(seasonRepository as unknown as SeasonRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
 
     const result = await useCase.execute({

core/racing/application/use-cases/DeleteLeagueSeasonScheduleRaceUseCase.ts

@@ -15,8 +15,8 @@ export type DeleteLeagueSeasonScheduleRaceErrorCode =
 
 export class DeleteLeagueSeasonScheduleRaceUseCase {
   constructor(
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly raceRepository: IRaceRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly raceRepository: RaceRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/DriverStatsUseCase.ts

@@ -1,5 +1,5 @@
 /**
- * Application Use Case Interface: IDriverStatsUseCase
+ * Application Use Case Interface: DriverStatsUseCase
  * 
  * Use case for computing detailed driver statistics from race results and standings.
  * This is an application layer concern that orchestrates domain data.

core/racing/application/use-cases/FileProtestUseCase.ts

@@ -33,9 +33,9 @@ export interface FileProtestResult {
 
 export class FileProtestUseCase {
   constructor(
-    private readonly protestRepository: IProtestRepository,
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly protestRepository: ProtestRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
   ) {}
 
   async execute(command: FileProtestInput): Promise<Result<FileProtestResult, ApplicationErrorCode<FileProtestErrorCode, { message: string }>>> {

core/racing/application/use-cases/GetAllLeaguesWithCapacityAndScoringUseCase.ts

@@ -34,11 +34,11 @@ export type GetAllLeaguesWithCapacityAndScoringErrorCode = 'REPOSITORY_ERROR';
  */
 export class GetAllLeaguesWithCapacityAndScoringUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
-    private readonly gameRepository: IGameRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueScoringConfigRepository: LeagueScoringConfigRepository,
+    private readonly gameRepository: GameRepository,
     private readonly presetProvider: { getPresetById(presetId: string): LeagueScoringPreset | undefined },
   ) {}
 

core/racing/application/use-cases/GetAllLeaguesWithCapacityUseCase.test.ts

@@ -17,8 +17,8 @@ describe('GetAllLeaguesWithCapacityUseCase', () => {
 
   it('should return leagues with capacity information', async () => {
     const useCase = new GetAllLeaguesWithCapacityUseCase(
-      mockLeagueRepo as unknown as ILeagueRepository,
-      mockMembershipRepo as unknown as ILeagueMembershipRepository,
+      mockLeagueRepo as unknown as LeagueRepository,
+      mockMembershipRepo as unknown as LeagueMembershipRepository,
     );
 
     const league1 = { id: 'league1', name: 'Test League 1', settings: { maxDrivers: 10 } };
@@ -56,8 +56,8 @@ describe('GetAllLeaguesWithCapacityUseCase', () => {
 
   it('should return empty result when no leagues', async () => {
     const useCase = new GetAllLeaguesWithCapacityUseCase(
-      mockLeagueRepo as unknown as ILeagueRepository,
-      mockMembershipRepo as unknown as ILeagueMembershipRepository,
+      mockLeagueRepo as unknown as LeagueRepository,
+      mockMembershipRepo as unknown as LeagueMembershipRepository,
     );
 
     mockLeagueRepo.findAll.mockResolvedValue([]);

core/racing/application/use-cases/GetAllLeaguesWithCapacityUseCase.ts

@@ -24,8 +24,8 @@ export type GetAllLeaguesWithCapacityErrorCode = 'REPOSITORY_ERROR';
  */
 export class GetAllLeaguesWithCapacityUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetAllRacesPageDataUseCase.ts

@@ -29,8 +29,8 @@ export type GetAllRacesPageDataErrorCode = 'REPOSITORY_ERROR';
 
 export class GetAllRacesPageDataUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueRepository: LeagueRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetAllRacesUseCase.ts

@@ -15,8 +15,8 @@ export type GetAllRacesErrorCode = 'REPOSITORY_ERROR';
 
 export class GetAllRacesUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueRepository: LeagueRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetAllTeamsUseCase.ts

@@ -30,9 +30,9 @@ export interface GetAllTeamsResult {
 
 export class GetAllTeamsUseCase {
   constructor(
-    private readonly teamRepository: ITeamRepository,
-    private readonly membershipRepository: ITeamMembershipRepository,
-    private readonly statsRepository: ITeamStatsRepository,
+    private readonly teamRepository: TeamRepository,
+    private readonly membershipRepository: TeamMembershipRepository,
+    private readonly statsRepository: TeamStatsRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetDriverLiveriesUseCase.test.ts

@@ -4,7 +4,7 @@ import type { DriverLivery } from '../../domain/entities/DriverLivery';
 import { GetDriverLiveriesUseCase, type GetDriverLiveriesInput } from './GetDriverLiveriesUseCase';
 
 describe('GetDriverLiveriesUseCase', () => {
-  const mockLiveryRepository: ILiveryRepository = {
+  const mockLiveryRepository: LiveryRepository = {
     findDriverLiveryById: vi.fn(),
     findDriverLiveriesByDriverId: vi.fn(),
     findDriverLiveryByDriverAndCar: vi.fn(),

core/racing/application/use-cases/GetDriverLiveriesUseCase.ts

@@ -20,7 +20,7 @@ export type GetDriverLiveriesErrorCode = 'REPOSITORY_ERROR';
 
 export class GetDriverLiveriesUseCase implements UseCase<GetDriverLiveriesInput, GetDriverLiveriesOutput, GetDriverLiveriesErrorCode> {
   constructor(
-    private readonly liveryRepository: ILiveryRepository,
+    private readonly liveryRepository: LiveryRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetDriverTeamUseCase.ts

@@ -18,8 +18,8 @@ export interface GetDriverTeamResult {
 
 export class GetDriverTeamUseCase {
   constructor(
-    private readonly teamRepository: ITeamRepository,
-    private readonly membershipRepository: ITeamMembershipRepository,
+    private readonly teamRepository: TeamRepository,
+    private readonly membershipRepository: TeamMembershipRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetDriverUseCase.ts

@@ -7,7 +7,7 @@ export type GetDriverInput = {
 };
 
 export class GetDriverUseCase {
-  constructor(private readonly driverRepository: IDriverRepository) {}
+  constructor(private readonly driverRepository: DriverRepository) {}
 
   async execute(input: GetDriverInput): Promise<Result<Driver | null>> {
     try {

core/racing/application/use-cases/GetDriversLeaderboardUseCase.test.ts

@@ -7,7 +7,7 @@ import {
 
 describe('GetDriversLeaderboardUseCase', () => {
   const mockDriverFindAll = vi.fn();
-  const mockDriverRepo: IDriverRepository = {
+  const mockDriverRepo: DriverRepository = {
     findById: vi.fn(),
     findByIRacingId: vi.fn(),
     existsByIRacingId: vi.fn(),
@@ -19,12 +19,12 @@ describe('GetDriversLeaderboardUseCase', () => {
   };
 
   const mockRankingGetAllDriverRankings = vi.fn();
-  const mockRankingUseCase: IRankingUseCase = {
+  const mockRankingUseCase: RankingUseCase = {
     getAllDriverRankings: mockRankingGetAllDriverRankings,
   };
 
   const mockDriverStatsGetDriverStats = vi.fn();
-  const mockDriverStatsUseCase: IDriverStatsUseCase = {
+  const mockDriverStatsUseCase: DriverStatsUseCase = {
     getDriverStats: mockDriverStatsGetDriverStats,
   };
 

core/racing/application/use-cases/GetDriversLeaderboardUseCase.ts

@@ -1,4 +1,5 @@
-import type { Logger, UseCase } from '@core/shared/application';
+import type { Logger } from '@core/shared/domain/Logger';
+import type { UseCase } from '@core/shared/application/UseCase';
 import { Result } from '@core/shared/domain/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import type { Driver } from '../../domain/entities/Driver';
@@ -45,9 +46,9 @@ export type GetDriversLeaderboardErrorCode =
  */
 export class GetDriversLeaderboardUseCase implements UseCase<GetDriversLeaderboardInput, GetDriversLeaderboardResult, GetDriversLeaderboardErrorCode> {
   constructor(
-    private readonly driverRepository: IDriverRepository,
-    private readonly rankingUseCase: IRankingUseCase,
-    private readonly driverStatsUseCase: IDriverStatsUseCase,
+    private readonly driverRepository: DriverRepository,
+    private readonly rankingUseCase: RankingUseCase,
+    private readonly driverStatsUseCase: DriverStatsUseCase,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetEntitySponsorshipPricingUseCase.ts

@@ -39,7 +39,7 @@ export type GetEntitySponsorshipPricingErrorCode =
   | 'REPOSITORY_ERROR';
 
 export class GetEntitySponsorshipPricingUseCase {
-  constructor(private readonly sponsorshipPricingRepo: ISponsorshipPricingRepository,
+  constructor(private readonly sponsorshipPricingRepo: SponsorshipPricingRepository,
     private readonly logger: Logger) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueAdminPermissionsUseCase.ts

@@ -23,8 +23,8 @@ export type GetLeagueAdminPermissionsErrorCode =
 
 export class GetLeagueAdminPermissionsUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetLeagueAdminUseCase.ts

@@ -15,7 +15,7 @@ export type GetLeagueAdminErrorCode = 'LEAGUE_NOT_FOUND' | 'REPOSITORY_ERROR';
 
 export class GetLeagueAdminUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueDriverSeasonStatsUseCase.ts

@@ -48,11 +48,11 @@ export type GetLeagueDriverSeasonStatsErrorCode =
  * Orchestrates domain logic and returns the result.
  */
 export class GetLeagueDriverSeasonStatsUseCase {
-  constructor(private readonly standingRepository: IStandingRepository,
-    private readonly resultRepository: IResultRepository,
-    private readonly penaltyRepository: IPenaltyRepository,
-    private readonly raceRepository: IRaceRepository,
-    private readonly driverRepository: IDriverRepository,
+  constructor(private readonly standingRepository: StandingRepository,
+    private readonly resultRepository: ResultRepository,
+    private readonly penaltyRepository: PenaltyRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly driverRepository: DriverRepository,
     private readonly driverRatingPort: DriverRatingPort) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueFullConfigUseCase.ts

@@ -27,10 +27,10 @@ export type GetLeagueFullConfigErrorCode = 'LEAGUE_NOT_FOUND' | 'REPOSITORY_ERRO
  * Orchestrates domain logic and returns the configuration data.
  */
 export class GetLeagueFullConfigUseCase {
-  constructor(private readonly leagueRepository: ILeagueRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
-    private readonly gameRepository: IGameRepository) {}
+  constructor(private readonly leagueRepository: LeagueRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueScoringConfigRepository: LeagueScoringConfigRepository,
+    private readonly gameRepository: GameRepository) {}
 
   async execute(
     input: GetLeagueFullConfigInput,

core/racing/application/use-cases/GetLeagueJoinRequestsUseCase.test.ts

@@ -35,9 +35,9 @@ describe('GetLeagueJoinRequestsUseCase', () => {
     };
 
     useCase = new GetLeagueJoinRequestsUseCase(
-      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
-      driverRepository as unknown as IDriverRepository,
-      leagueRepository as unknown as ILeagueRepository,
+      leagueMembershipRepository as unknown as LeagueMembershipRepository,
+      driverRepository as unknown as DriverRepository,
+      leagueRepository as unknown as LeagueRepository,
     );
   });
 

core/racing/application/use-cases/GetLeagueJoinRequestsUseCase.ts

@@ -26,9 +26,9 @@ export interface GetLeagueJoinRequestsResult {
 
 export class GetLeagueJoinRequestsUseCase {
   constructor(
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueMembershipsUseCase.ts

@@ -25,9 +25,9 @@ export interface GetLeagueMembershipsResult {
 
 export class GetLeagueMembershipsUseCase {
   constructor(
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueOwnerSummaryUseCase.ts

@@ -24,10 +24,10 @@ export interface GetLeagueOwnerSummaryResult {
 
 export class GetLeagueOwnerSummaryUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly standingRepository: IStandingRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly standingRepository: StandingRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueProtestsUseCase.test.ts

@@ -42,10 +42,10 @@ describe('GetLeagueProtestsUseCase', () => {
     leagueRepository = {
       findById: vi.fn(),
     };
-    useCase = new GetLeagueProtestsUseCase(raceRepository as unknown as IRaceRepository,
-      protestRepository as unknown as IProtestRepository,
-      driverRepository as unknown as IDriverRepository,
-      leagueRepository as unknown as ILeagueRepository);
+    useCase = new GetLeagueProtestsUseCase(raceRepository as unknown as RaceRepository,
+      protestRepository as unknown as ProtestRepository,
+      driverRepository as unknown as DriverRepository,
+      leagueRepository as unknown as LeagueRepository);
   });
 
   it('should return protests with races and drivers', async () => {

core/racing/application/use-cases/GetLeagueProtestsUseCase.ts

@@ -29,10 +29,10 @@ export interface GetLeagueProtestsResult {
 
 export class GetLeagueProtestsUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly protestRepository: IProtestRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly protestRepository: ProtestRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueRosterJoinRequestsUseCase.test.ts

@@ -38,9 +38,9 @@ describe('GetLeagueRosterJoinRequestsUseCase', () => {
     };
 
     useCase = new GetLeagueRosterJoinRequestsUseCase(
-      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
-      driverRepository as unknown as IDriverRepository,
-      leagueRepository as unknown as ILeagueRepository,
+      leagueMembershipRepository as unknown as LeagueMembershipRepository,
+      driverRepository as unknown as DriverRepository,
+      leagueRepository as unknown as LeagueRepository,
     );
   });
 

core/racing/application/use-cases/GetLeagueRosterJoinRequestsUseCase.ts

@@ -26,9 +26,9 @@ export interface GetLeagueRosterJoinRequestsResult {
 
 export class GetLeagueRosterJoinRequestsUseCase {
   constructor(
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueRosterMembersUseCase.test.ts

@@ -39,9 +39,9 @@ describe('GetLeagueRosterMembersUseCase', () => {
     };
 
     useCase = new GetLeagueRosterMembersUseCase(
-      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
-      driverRepository as unknown as IDriverRepository,
-      leagueRepository as unknown as ILeagueRepository,
+      leagueMembershipRepository as unknown as LeagueMembershipRepository,
+      driverRepository as unknown as DriverRepository,
+      leagueRepository as unknown as LeagueRepository,
     );
   });
 

core/racing/application/use-cases/GetLeagueRosterMembersUseCase.ts

@@ -23,9 +23,9 @@ export interface GetLeagueRosterMembersResult {
 
 export class GetLeagueRosterMembersUseCase {
   constructor(
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly leagueRepository: LeagueRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueScheduleUseCase.test.ts

@@ -41,9 +41,9 @@ describe('GetLeagueScheduleUseCase', () => {
       warn: vi.fn(),
       error: vi.fn(),
     } as unknown as Logger;
-    useCase = new GetLeagueScheduleUseCase(leagueRepository as unknown as ILeagueRepository,
+    useCase = new GetLeagueScheduleUseCase(leagueRepository as unknown as LeagueRepository,
       seasonRepository as any,
-      raceRepository as unknown as IRaceRepository,
+      raceRepository as unknown as RaceRepository,
       logger);
   });
 

core/racing/application/use-cases/GetLeagueScheduleUseCase.ts

@@ -29,9 +29,9 @@ export interface GetLeagueScheduleResult {
 
 export class GetLeagueScheduleUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly raceRepository: IRaceRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly raceRepository: RaceRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetLeagueScoringConfigUseCase.ts

@@ -32,10 +32,10 @@ export interface GetLeagueScoringConfigResult {
 
 export class GetLeagueScoringConfigUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
-    private readonly gameRepository: IGameRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueScoringConfigRepository: LeagueScoringConfigRepository,
+    private readonly gameRepository: GameRepository,
     private readonly presetProvider: {
       getPresetById(presetId: string): LeagueScoringPreset | undefined;
     },

core/racing/application/use-cases/GetLeagueSeasonsUseCase.ts

@@ -22,8 +22,8 @@ export interface GetLeagueSeasonsResult {
 
 export class GetLeagueSeasonsUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly seasonRepository: SeasonRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueStandingsUseCase.ts

@@ -26,8 +26,8 @@ export type GetLeagueStandingsResult = {
  */
 export class GetLeagueStandingsUseCase {
   constructor(
-    private readonly standingRepository: IStandingRepository,
-    private readonly driverRepository: IDriverRepository,
+    private readonly standingRepository: StandingRepository,
+    private readonly driverRepository: DriverRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetLeagueStatsUseCase.ts

@@ -18,8 +18,8 @@ export type GetLeagueStatsErrorCode = 'LEAGUE_NOT_FOUND' | 'REPOSITORY_ERROR';
 
 export class GetLeagueStatsUseCase {
   constructor(
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly raceRepository: IRaceRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly raceRepository: RaceRepository,
     private readonly getDriverRating: (input: {
       driverId: string;
     }) => Promise<{ rating: number | null; ratingChange: number | null }>,

core/racing/application/use-cases/GetLeagueWalletUseCase.ts

@@ -35,9 +35,9 @@ export interface GetLeagueWalletResult {
  */
 export class GetLeagueWalletUseCase {
   constructor(
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueWalletRepository: ILeagueWalletRepository,
-    private readonly transactionRepository: ITransactionRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueWalletRepository: LeagueWalletRepository,
+    private readonly transactionRepository: TransactionRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase.test.ts

@@ -29,8 +29,8 @@ describe('GetPendingSponsorshipRequestsUseCase', () => {
       findById: vi.fn(),
     };
     useCase = new GetPendingSponsorshipRequestsUseCase(
-      sponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
-      sponsorRepo as unknown as ISponsorRepository,
+      sponsorshipRequestRepo as unknown as SponsorshipRequestRepository,
+      sponsorRepo as unknown as SponsorRepository,
     );
   });
 

core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase.ts

@@ -40,8 +40,8 @@ export type GetPendingSponsorshipRequestsErrorCode = 'REPOSITORY_ERROR';
 
 export class GetPendingSponsorshipRequestsUseCase {
   constructor(
-    private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
-    private readonly sponsorRepo: ISponsorRepository,
+    private readonly sponsorshipRequestRepo: SponsorshipRequestRepository,
+    private readonly sponsorRepo: SponsorRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetProfileOverviewUseCase.test.ts

@@ -60,10 +60,10 @@ describe('GetProfileOverviewUseCase', () => {
       getExtendedProfile: vi.fn(),
     };
 
-    useCase = new GetProfileOverviewUseCase(driverRepository as unknown as IDriverRepository,
-      teamRepository as unknown as ITeamRepository,
-      teamMembershipRepository as unknown as ITeamMembershipRepository,
-      socialRepository as unknown as ISocialGraphRepository,
+    useCase = new GetProfileOverviewUseCase(driverRepository as unknown as DriverRepository,
+      teamRepository as unknown as TeamRepository,
+      teamMembershipRepository as unknown as TeamMembershipRepository,
+      socialRepository as unknown as SocialGraphRepository,
       driverExtendedProfileProvider,
       driverStatsUseCase as unknown as any,
       rankingUseCase as unknown as any);

core/racing/application/use-cases/GetProfileOverviewUseCase.ts

@@ -72,13 +72,13 @@ export type GetProfileOverviewErrorCode =
   | 'REPOSITORY_ERROR';
  
 export class GetProfileOverviewUseCase {
-  constructor(private readonly driverRepository: IDriverRepository,
-    private readonly teamRepository: ITeamRepository,
-    private readonly teamMembershipRepository: ITeamMembershipRepository,
-    private readonly socialRepository: ISocialGraphRepository,
+  constructor(private readonly driverRepository: DriverRepository,
+    private readonly teamRepository: TeamRepository,
+    private readonly teamMembershipRepository: TeamMembershipRepository,
+    private readonly socialRepository: SocialGraphRepository,
     private readonly driverExtendedProfileProvider: DriverExtendedProfileProvider,
-    private readonly driverStatsUseCase: IDriverStatsUseCase,
-    private readonly rankingUseCase: IRankingUseCase) {}
+    private readonly driverStatsUseCase: DriverStatsUseCase,
+    private readonly rankingUseCase: RankingUseCase) {}
  
   async execute(
     input: GetProfileOverviewInput,

core/racing/application/use-cases/GetRaceDetailUseCase.test.ts

@@ -32,12 +32,12 @@ describe('GetRaceDetailUseCase', () => {
     leagueMembershipRepository = { getMembership: vi.fn() };
 
     useCase = new GetRaceDetailUseCase(
-      raceRepository as unknown as IRaceRepository,
-      leagueRepository as unknown as ILeagueRepository,
-      driverRepository as unknown as IDriverRepository,
-      raceRegistrationRepository as unknown as IRaceRegistrationRepository,
-      resultRepository as unknown as IResultRepository,
-      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
+      raceRepository as unknown as RaceRepository,
+      leagueRepository as unknown as LeagueRepository,
+      driverRepository as unknown as DriverRepository,
+      raceRegistrationRepository as unknown as RaceRegistrationRepository,
+      resultRepository as unknown as ResultRepository,
+      leagueMembershipRepository as unknown as LeagueMembershipRepository,
     );
   });
 

core/racing/application/use-cases/GetRaceDetailUseCase.ts

@@ -25,7 +25,7 @@ export type GetRaceDetailResult = {
   race: Race;
   league: League | null;
   registrations: RaceRegistration[];
-  drivers: NonNullable<Awaited<ReturnType<IDriverRepository['findById']>>>[];
+  drivers: NonNullable<Awaited<ReturnType<DriverRepository['findById']>>>[];
   userResult: RaceResult | null;
   isUserRegistered: boolean;
   canRegister: boolean;
@@ -33,12 +33,12 @@ export type GetRaceDetailResult = {
 
 export class GetRaceDetailUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly raceRegistrationRepository: IRaceRegistrationRepository,
-    private readonly resultRepository: IResultRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly raceRegistrationRepository: RaceRegistrationRepository,
+    private readonly resultRepository: ResultRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetRacePenaltiesUseCase.test.ts

@@ -16,8 +16,8 @@ describe('GetRacePenaltiesUseCase', () => {
   beforeEach(() => {
     penaltyRepository = { findByRaceId: vi.fn() };
     driverRepository = { findById: vi.fn() };
-    useCase = new GetRacePenaltiesUseCase(penaltyRepository as unknown as IPenaltyRepository,
-      driverRepository as unknown as IDriverRepository);
+    useCase = new GetRacePenaltiesUseCase(penaltyRepository as unknown as PenaltyRepository,
+      driverRepository as unknown as DriverRepository);
   });
 
   it('should return penalties with drivers', async () => {

core/racing/application/use-cases/GetRacePenaltiesUseCase.ts

@@ -25,8 +25,8 @@ export type GetRacePenaltiesErrorCode = 'REPOSITORY_ERROR';
 
 export class GetRacePenaltiesUseCase {
   constructor(
-    private readonly penaltyRepository: IPenaltyRepository,
-    private readonly driverRepository: IDriverRepository,
+    private readonly penaltyRepository: PenaltyRepository,
+    private readonly driverRepository: DriverRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetRaceProtestsUseCase.ts

@@ -25,8 +25,8 @@ export interface GetRaceProtestsResult {
 
 export class GetRaceProtestsUseCase {
   constructor(
-    private readonly protestRepository: IProtestRepository,
-    private readonly driverRepository: IDriverRepository,
+    private readonly protestRepository: ProtestRepository,
+    private readonly driverRepository: DriverRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetRaceRegistrationsUseCase.ts

@@ -22,8 +22,8 @@ export type GetRaceRegistrationsErrorCode = 'RACE_NOT_FOUND' | 'REPOSITORY_ERROR
 
 export class GetRaceRegistrationsUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly registrationRepository: IRaceRegistrationRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly registrationRepository: RaceRegistrationRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetRaceResultsDetailUseCase.ts

@@ -33,11 +33,11 @@ export type GetRaceResultsDetailResult = {
 
 export class GetRaceResultsDetailUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly resultRepository: IResultRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly penaltyRepository: IPenaltyRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly resultRepository: ResultRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly penaltyRepository: PenaltyRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetRaceWithSOFUseCase.ts

@@ -36,9 +36,9 @@ export class GetRaceWithSOFUseCase {
   private readonly sofCalculator: StrengthOfFieldCalculator;
 
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly registrationRepository: IRaceRegistrationRepository,
-    private readonly resultRepository: IResultRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly registrationRepository: RaceRegistrationRepository,
+    private readonly resultRepository: ResultRepository,
     private readonly getDriverRating: GetDriverRating,
     sofCalculator?: StrengthOfFieldCalculator,
   ) {

core/racing/application/use-cases/GetRacesPageDataUseCase.test.ts

@@ -11,8 +11,8 @@ import {
 
 describe('GetRacesPageDataUseCase', () => {
   let useCase: GetRacesPageDataUseCase;
-  let raceRepository: IRaceRepository;
-  let leagueRepository: ILeagueRepository;
+  let raceRepository: RaceRepository;
+  let leagueRepository: LeagueRepository;
   let logger: Logger;
   beforeEach(() => {
     const raceFindAll = vi.fn();
@@ -30,7 +30,7 @@ describe('GetRacesPageDataUseCase', () => {
       update: vi.fn(),
       delete: vi.fn(),
       exists: vi.fn(),
-    } as unknown as IRaceRepository;
+    } as unknown as RaceRepository;
 
     leagueRepository = {
       findById: vi.fn(),
@@ -41,7 +41,7 @@ describe('GetRacesPageDataUseCase', () => {
       delete: vi.fn(),
       exists: vi.fn(),
       searchByName: vi.fn(),
-    } as unknown as ILeagueRepository;
+    } as unknown as LeagueRepository;
 
     logger = {
       debug: vi.fn(),

core/racing/application/use-cases/GetRacesPageDataUseCase.ts

@@ -18,8 +18,8 @@ export type GetRacesPageDataErrorCode = 'REPOSITORY_ERROR';
 
 export class GetRacesPageDataUseCase {
   constructor(
-    private readonly raceRepository: IRaceRepository,
-    private readonly leagueRepository: ILeagueRepository,
+    private readonly raceRepository: RaceRepository,
+    private readonly leagueRepository: LeagueRepository,
     private readonly logger: Logger,
   ) {}
 

core/racing/application/use-cases/GetSeasonDetailsUseCase.ts

@@ -14,7 +14,7 @@ export interface GetSeasonDetailsResult {
 }
 
 export class GetSeasonDetailsUseCase {
-  constructor(private readonly seasonRepository: ISeasonRepository) {}
+  constructor(private readonly seasonRepository: SeasonRepository) {}
 
   async execute(
     input: GetSeasonDetailsInput,

core/racing/application/use-cases/GetSeasonSponsorshipsUseCase.ts

@@ -50,11 +50,11 @@ export type GetSeasonSponsorshipsErrorCode =
   | 'REPOSITORY_ERROR';
 
 export class GetSeasonSponsorshipsUseCase {
-  constructor(private readonly seasonSponsorshipRepository: ISeasonSponsorshipRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly raceRepository: IRaceRepository) {}
+  constructor(private readonly seasonSponsorshipRepository: SeasonSponsorshipRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly raceRepository: RaceRepository) {}
 
   async execute(
     input: GetSeasonSponsorshipsInput,

core/racing/application/use-cases/GetSponsorDashboardUseCase.test.ts

@@ -60,12 +60,12 @@ describe('GetSponsorDashboardUseCase', () => {
     };
 
     useCase = new GetSponsorDashboardUseCase(
-      sponsorRepository as unknown as ISponsorRepository,
-      seasonSponsorshipRepository as unknown as ISeasonSponsorshipRepository,
-      seasonRepository as unknown as ISeasonRepository,
-      leagueRepository as unknown as ILeagueRepository,
-      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
-      raceRepository as unknown as IRaceRepository,
+      sponsorRepository as unknown as SponsorRepository,
+      seasonSponsorshipRepository as unknown as SeasonSponsorshipRepository,
+      seasonRepository as unknown as SeasonRepository,
+      leagueRepository as unknown as LeagueRepository,
+      leagueMembershipRepository as unknown as LeagueMembershipRepository,
+      raceRepository as unknown as RaceRepository,
     );
   });
 

core/racing/application/use-cases/GetSponsorDashboardUseCase.ts

@@ -63,12 +63,12 @@ export type GetSponsorDashboardErrorCode = 'SPONSOR_NOT_FOUND' | 'REPOSITORY_ERR
 
 export class GetSponsorDashboardUseCase {
   constructor(
-    private readonly sponsorRepository: ISponsorRepository,
-    private readonly seasonSponsorshipRepository: ISeasonSponsorshipRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly raceRepository: IRaceRepository,
+    private readonly sponsorRepository: SponsorRepository,
+    private readonly seasonSponsorshipRepository: SeasonSponsorshipRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly raceRepository: RaceRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetSponsorSponsorshipsUseCase.test.ts

@@ -60,12 +60,12 @@ describe('GetSponsorSponsorshipsUseCase', () => {
     };
 
     useCase = new GetSponsorSponsorshipsUseCase(
-      sponsorRepository as unknown as ISponsorRepository,
-      seasonSponsorshipRepository as unknown as ISeasonSponsorshipRepository,
-      seasonRepository as unknown as ISeasonRepository,
-      leagueRepository as unknown as ILeagueRepository,
-      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
-      raceRepository as unknown as IRaceRepository,
+      sponsorRepository as unknown as SponsorRepository,
+      seasonSponsorshipRepository as unknown as SeasonSponsorshipRepository,
+      seasonRepository as unknown as SeasonRepository,
+      leagueRepository as unknown as LeagueRepository,
+      leagueMembershipRepository as unknown as LeagueMembershipRepository,
+      raceRepository as unknown as RaceRepository,
     );
   });
 

core/racing/application/use-cases/GetSponsorSponsorshipsUseCase.ts

@@ -60,12 +60,12 @@ export type GetSponsorSponsorshipsErrorCode = 'SPONSOR_NOT_FOUND' | 'REPOSITORY_
 
 export class GetSponsorSponsorshipsUseCase {
   constructor(
-    private readonly sponsorRepository: ISponsorRepository,
-    private readonly seasonSponsorshipRepository: ISeasonSponsorshipRepository,
-    private readonly seasonRepository: ISeasonRepository,
-    private readonly leagueRepository: ILeagueRepository,
-    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
-    private readonly raceRepository: IRaceRepository,
+    private readonly sponsorRepository: SponsorRepository,
+    private readonly seasonSponsorshipRepository: SeasonSponsorshipRepository,
+    private readonly seasonRepository: SeasonRepository,
+    private readonly leagueRepository: LeagueRepository,
+    private readonly leagueMembershipRepository: LeagueMembershipRepository,
+    private readonly raceRepository: RaceRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetSponsorUseCase.test.ts

@@ -22,7 +22,7 @@ describe('GetSponsorUseCase', () => {
     };
 
     useCase = new GetSponsorUseCase(
-      sponsorRepository as unknown as ISponsorRepository,
+      sponsorRepository as unknown as SponsorRepository,
     );
   });
 

core/racing/application/use-cases/GetSponsorUseCase.ts

@@ -21,7 +21,7 @@ export type GetSponsorErrorCode = 'SPONSOR_NOT_FOUND' | 'REPOSITORY_ERROR';
 
 export class GetSponsorUseCase {
   constructor(
-    private readonly sponsorRepository: ISponsorRepository,
+    private readonly sponsorRepository: SponsorRepository,
   ) {}
 
   async execute(input: GetSponsorInput): Promise<Result<GetSponsorResult, ApplicationErrorCode<GetSponsorErrorCode, { message: string }>>> {

core/racing/application/use-cases/GetTeamDetailsUseCase.ts

@@ -20,8 +20,8 @@ export interface GetTeamDetailsResult {
 
 export class GetTeamDetailsUseCase {
   constructor(
-    private readonly teamRepository: ITeamRepository,
-    private readonly membershipRepository: ITeamMembershipRepository,
+    private readonly teamRepository: TeamRepository,
+    private readonly membershipRepository: TeamMembershipRepository,
   ) {}
 
   async execute(

core/racing/application/use-cases/GetTeamJoinRequestsUseCase.ts

@@ -23,9 +23,9 @@ export type GetTeamJoinRequestsResult = {
 };
 
 export class GetTeamJoinRequestsUseCase {
-  constructor(private readonly membershipRepository: ITeamMembershipRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly teamRepository: ITeamRepository) {}
+  constructor(private readonly membershipRepository: TeamMembershipRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly teamRepository: TeamRepository) {}
 
   async execute(
     input: GetTeamJoinRequestsInput,

core/racing/application/use-cases/GetTeamMembersUseCase.ts

@@ -24,9 +24,9 @@ export type GetTeamMembersErrorCode = 'TEAM_NOT_FOUND' | 'REPOSITORY_ERROR';
  * Use Case for retrieving team members.
  */
 export class GetTeamMembersUseCase {
-  constructor(private readonly membershipRepository: ITeamMembershipRepository,
-    private readonly driverRepository: IDriverRepository,
-    private readonly teamRepository: ITeamRepository,
+  constructor(private readonly membershipRepository: TeamMembershipRepository,
+    private readonly driverRepository: DriverRepository,
+    private readonly teamRepository: TeamRepository,
     private readonly logger: Logger) {}
 
   async execute(

core/racing/application/use-cases/GetTeamMembershipUseCase.ts

@@ -21,7 +21,7 @@ export type GetTeamMembershipErrorCode = 'REPOSITORY_ERROR';
  * Use Case for retrieving a driver's membership in a team.
  */
 export class GetTeamMembershipUseCase {
-  constructor(private readonly membershipRepository: ITeamMembershipRepository,
+  constructor(private readonly membershipRepository: TeamMembershipRepository,
     private readonly logger: Logger) {}
 
   async execute(

core/racing/application/use-cases/GetTeamsLeaderboardUseCase.ts

@@ -40,8 +40,8 @@ export type GetTeamsLeaderboardErrorCode = 'LEAGUE_NOT_FOUND' | 'SEASON_NOT_FOUN
  */
 export class GetTeamsLeaderboardUseCase {
   constructor(
-    private readonly teamRepository: ITeamRepository,
-    private readonly teamMembershipRepository: ITeamMembershipRepository,
+    private readonly teamRepository: TeamRepository,
+    private readonly teamMembershipRepository: TeamMembershipRepository,
     private readonly getDriverStats: (driverId: string) => DriverStatsAdapter | null,
     private readonly logger: Logger,
   ) {}

core/racing/application/use-cases/GetTotalDriversUseCase.test.ts

@@ -17,7 +17,7 @@ describe('GetTotalDriversUseCase', () => {
       findAll: vi.fn(),
     };
 
-    useCase = new GetTotalDriversUseCase(driverRepository as unknown as IDriverRepository);
+    useCase = new GetTotalDriversUseCase(driverRepository as unknown as DriverRepository);
   });
 
   it('should return total number of drivers', async () => {

core/racing/application/use-cases/GetTotalDriversUseCase.ts

@@ -11,7 +11,7 @@ export interface GetTotalDriversResult {
 }
 
 export class GetTotalDriversUseCase {
-  constructor(private readonly driverRepository: IDriverRepository) {}
+  constructor(private readonly driverRepository: DriverRepository) {}
 
   async execute(
     _input: GetTotalDriversInput,

core/racing/application/use-cases/GetTotalLeaguesUseCase.test.ts

@@ -18,7 +18,7 @@ describe('GetTotalLeaguesUseCase', () => {
       findAll: vi.fn(),
     };
 
-    useCase = new GetTotalLeaguesUseCase(leagueRepository as unknown as ILeagueRepository);
+    useCase = new GetTotalLeaguesUseCase(leagueRepository as unknown as LeagueRepository);
   });
 
   it('should return total number of leagues', async () => {

core/racing/application/use-cases/GetTotalLeaguesUseCase.ts

@@ -11,7 +11,7 @@ export interface GetTotalLeaguesResult {
 }
 
 export class GetTotalLeaguesUseCase {
-  constructor(private readonly leagueRepository: ILeagueRepository) {}
+  constructor(private readonly leagueRepository: LeagueRepository) {}
 
   async execute(
     _input: GetTotalLeaguesInput,

core/racing/application/use-cases/GetTotalRacesUseCase.test.ts

@@ -29,7 +29,7 @@ describe('GetTotalRacesUseCase', () => {
       warn: vi.fn(),
       error: vi.fn(),
     };
-    useCase = new GetTotalRacesUseCase(raceRepository as unknown as IRaceRepository,
+    useCase = new GetTotalRacesUseCase(raceRepository as unknown as RaceRepository,
       logger as unknown as Logger);
   });
 

core/racing/application/use-cases/GetTotalRacesUseCase.ts

@@ -11,7 +11,7 @@ export interface GetTotalRacesResult {
 }
 
 export class GetTotalRacesUseCase {
-  constructor(private readonly raceRepository: IRaceRepository) {}
+  constructor(private readonly raceRepository: RaceRepository) {}
 
   async execute(
     _input: GetTotalRacesInput,