booking operations and trains scheduling also allocations

2026-08-27 00:52:50 +00:00 · 2026-06-10 00:48:32 +03:00
parent 675975bc08
commit 5774d7db9d
180 changed files with 13423 additions and 3877 deletions
--- a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
@@ -159,18 +159,20 @@ export class BookingPricingService {

  async buildEvalInputForBooking(booking: Booking): Promise<BookingEvaluationInput> {
    const containers = await Promise.all(
-      (booking.bookingContainers ?? []).map(async (bc) => {
-        const ct = await this.containerTypesService.findById(bc.containerTypeId);
-        const vgm = Number(bc.vgmPerUnitTons);
-        const qty = bc.quantity;
-        return {
-          containerTypeId: bc.containerTypeId,
-          quantity: qty,
-          vgmPerUnitTons: vgm,
-          totalVgmTons: qty * vgm,
-          isReefer: ct.isReefer,
-        };
-      }),
+      (booking.bookingContainers ?? [])
+        .filter((bc): bc is typeof bc & { containerTypeId: string } => bc.containerTypeId != null)
+        .map(async (bc) => {
+          const ct = await this.containerTypesService.findById(bc.containerTypeId);
+          const vgm = Number(bc.vgmPerUnitTons);
+          const qty = bc.quantity;
+          return {
+            containerTypeId: bc.containerTypeId,
+            quantity: qty,
+            vgmPerUnitTons: vgm,
+            totalVgmTons: qty * vgm,
+            isReefer: ct.isReefer,
+          };
+        }),
    );
    return {
      freightType: booking.freightType as 'CONTAINER' | 'BULK',
@@ -179,6 +181,7 @@ export class BookingPricingService {
      paymentCurrency: booking.paymentCurrency,
      tradeDirection: booking.tradeDirection,
      isHazardous: booking.isHazardous,
+      isGovernment: booking.isGovernment,
      allowConsolidation: booking.allowConsolidation,
      shippingLineId: booking.shippingLineId,
      containers,
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -54,6 +54,7 @@ import {
  type AuthUserPayload,
  resolveAuthUserId,
 } from '../../common/resolve-auth-user-id';
+import { assertFreightPermission } from '../../common/freight-permission.util';

@ApiTags('bookings')
@Controller('bookings')
@@ -75,10 +76,12 @@ export class BookingsController {
  create(
    @Body() dto: CreateBookingDto,
    @UploadedFiles() files: Express.Multer.File[],
-    @Request() req: { user?: { id?: string; sub?: string } },
+    @CurrentUser() user: TCurrentUser,
  ) {
-    const userId = req.user?.id ?? req.user?.sub;
-    return this.bookingsService.create(dto, files ?? [], userId);
+    if (dto.isGovernment) {
+      assertFreightPermission(user, FREIGHT_PERMS.bookings.staffAccept);
+    }
+    return this.bookingsService.create(dto, files ?? [], user?.id);
  }

  @Patch(':id')
@@ -244,6 +247,20 @@ export class BookingsController {
    return this.transitionService.enrichBookingResponse(booking);
  }

+  @Post(':id/government-expedite')
+  @BookingStaff(FREIGHT_PERMS.bookings.staffAccept)
+  @ApiOperation({ summary: 'Expedite government booking to PAID / ELIGIBLE for scheduling' })
+  async governmentExpedite(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    const booking = await this.bookingsService.governmentExpedite(
+      id,
+      resolveAuthUserId(user),
+    );
+    return this.transitionService.enrichBookingResponse(booking);
+  }
+
  @Post(':id/approval-steps/:stepId/approve')
  @BookingStaff([
    FREIGHT_PERMS.bookings.approveLineStaff,
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.spec.ts
@@ -0,0 +1,70 @@
+import { DataSource, Repository } from 'typeorm';
+
+import { Booking } from './entities/booking.entity';
+import { BookingsRepository } from './bookings.repository';
+
+function mockQueryBuilder() {
+  const qb = {
+    leftJoinAndSelect: jest.fn().mockReturnThis(),
+    leftJoin: jest.fn().mockReturnThis(),
+    where: jest.fn().mockReturnThis(),
+    andWhere: jest.fn().mockReturnThis(),
+    orderBy: jest.fn().mockReturnThis(),
+    addOrderBy: jest.fn().mockReturnThis(),
+    skip: jest.fn().mockReturnThis(),
+    take: jest.fn().mockReturnThis(),
+    getMany: jest.fn(),
+    getManyAndCount: jest.fn().mockResolvedValue([[], 0]),
+  };
+  return qb;
+}
+
+describe('BookingsRepository', () => {
+  let repository: jest.Mocked<Repository<Booking>>;
+  let dataSource: { getRepository: jest.Mock };
+  let bookingsRepository: BookingsRepository;
+
+  beforeEach(() => {
+    repository = {
+      createQueryBuilder: jest.fn(),
+    } as unknown as jest.Mocked<Repository<Booking>>;
+    dataSource = { getRepository: jest.fn() };
+    bookingsRepository = new BookingsRepository(repository, dataSource as unknown as DataSource);
+  });
+
+  it('findEligibleForScheduling does not filter by schedule date', async () => {
+    const qb = mockQueryBuilder();
+    const bookings = [
+      { id: 'b1', scheduledDate: new Date('2026-06-20T08:00:00.000Z') },
+      { id: 'b2', scheduledDate: new Date('2026-06-21T14:00:00.000Z') },
+    ];
+    qb.getMany.mockResolvedValue(bookings);
+    repository.createQueryBuilder.mockReturnValue(qb as never);
+
+    const result = await bookingsRepository.findEligibleForScheduling({
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+      freightType: 'CONTAINER',
+    });
+
+    expect(result).toHaveLength(2);
+    const dateFilters = qb.andWhere.mock.calls.filter(([clause]) =>
+      String(clause).includes('scheduled_date'),
+    );
+    expect(dateFilters).toHaveLength(0);
+  });
+
+  it('applyListFilters excludes assigned bookings when assignedToSchedule is false', async () => {
+    const qb = mockQueryBuilder();
+    repository.createQueryBuilder.mockReturnValue(qb as never);
+    dataSource.getRepository.mockReturnValue({ find: jest.fn().mockResolvedValue([]) });
+
+    await bookingsRepository.findAllPaginated({
+      page: 1,
+      pageSize: 10,
+      assignedToSchedule: 'false',
+    });
+
+    expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('NOT EXISTS'));
+  });
+});
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -1,7 +1,8 @@
 import { BaseRepository } from '@edr/api-common';
+import { SchedulingStatus } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, FindOptionsWhere, Repository, SelectQueryBuilder } from 'typeorm';
+import { DataSource, EntityManager, FindOptionsWhere, In, Repository, SelectQueryBuilder } from 'typeorm';

 import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { BookingApprovalStep } from './entities/booking-approval-step.entity';
@@ -9,6 +10,7 @@ import { BookingCargoModifier } from './entities/booking-cargo-modifier.entity';
 import { BookingContainer } from './entities/booking-container.entity';
 import { BookingRateSnapshot } from './entities/booking-rate-snapshot.entity';
 import { BookingReviewNote, ReviewNoteType } from './entities/booking-review-note.entity';
+import { TrainScheduleBooking } from '../train-schedules/entities/train-schedule-booking.entity';
 import { Booking } from './entities/booking.entity';
 import {
  BookingContractSignature,
@@ -20,6 +22,8 @@ import { ContainerWeightResult } from '../rule-engine/rule-engine.service';
 export interface BookingListFilterOptions {
  statuses?: string[];
  status?: string;
+  schedulingStatuses?: string[];
+  assignedToSchedule?: 'true' | 'false';
  companyId?: string;
  contractType?: string;
  serviceTypeId?: string;
@@ -427,17 +431,37 @@ export class BookingsRepository extends BaseRepository<Booking> {

    this.applyListFilters(qb, options);

-    const sortField =
-      options.sortBy === 'priorityScore'
-        ? 'booking.priorityScore'
-        : 'booking.createdAt';
-    qb.orderBy(sortField, options.sortOrder ?? 'DESC');
+    if (options.sortBy === 'isGovernment') {
+      qb.orderBy('booking.isGovernment', 'DESC')
+        .addOrderBy('booking.priorityScore', 'DESC')
+        .addOrderBy('booking.scheduledDate', 'ASC');
+    } else {
+      const sortField =
+        options.sortBy === 'priorityScore'
+          ? 'booking.priorityScore'
+          : options.sortBy === 'scheduledDate'
+            ? 'booking.scheduledDate'
+            : 'booking.createdAt';
+      qb.orderBy(sortField, options.sortOrder ?? 'DESC');
+    }

    const [items, total] = await qb
      .skip((page - 1) * pageSize)
      .take(pageSize)
      .getManyAndCount();

+    if (items.length) {
+      const links = await this.dataSource.getRepository(TrainScheduleBooking).find({
+        where: { bookingId: In(items.map((item) => item.id)) },
+        select: { bookingId: true, trainScheduleId: true },
+      });
+      const scheduleByBooking = new Map(links.map((link) => [link.bookingId, link.trainScheduleId]));
+      for (const item of items) {
+        (item as Booking & { trainScheduleId?: string | null }).trainScheduleId =
+          scheduleByBooking.get(item.id) ?? null;
+      }
+    }
+
    return { items, total };
  }

@@ -556,6 +580,26 @@ export class BookingsRepository extends BaseRepository<Booking> {
    } else if (options.consolidationPaired === 'false') {
      qb.andWhere('booking.consolidation_partner_id IS NULL');
    }
+    if (options.schedulingStatuses?.length) {
+      qb.andWhere('booking.scheduling_status IN (:...schedulingStatuses)', {
+        schedulingStatuses: options.schedulingStatuses,
+      });
+    }
+    if (options.assignedToSchedule === 'true') {
+      qb.andWhere(
+        `EXISTS (
+          SELECT 1 FROM freight.train_schedule_bookings tsb
+          WHERE tsb.booking_id = booking.id AND tsb.deleted_at IS NULL
+        )`,
+      );
+    } else if (options.assignedToSchedule === 'false') {
+      qb.andWhere(
+        `NOT EXISTS (
+          SELECT 1 FROM freight.train_schedule_bookings tsb
+          WHERE tsb.booking_id = booking.id AND tsb.deleted_at IS NULL
+        )`,
+      );
+    }
  }

  async findAndCountFiltered(where: FindOptionsWhere<Booking>, options: {
@@ -605,4 +649,99 @@ export class BookingsRepository extends BaseRepository<Booking> {
    }
    return repo.save(repo.create(data));
  }
+
+  private bookingRepo(manager?: EntityManager) {
+    return manager ? manager.getRepository(Booking) : this.repository;
+  }
+
+  findEligibleForScheduling(options: {
+    freightType?: string;
+    originStationId?: string;
+    destinationStationId?: string;
+    schedulingStatus?: string;
+  }): Promise<Booking[]> {
+    const qb = this.repository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoinAndSelect('booking.originYard', 'originYard')
+      .leftJoinAndSelect('booking.destinationYard', 'destinationYard')
+      .leftJoinAndSelect('booking.bookingContainers', 'bookingContainer')
+      .leftJoinAndSelect('bookingContainer.containerType', 'containerType')
+      .leftJoinAndSelect('booking.cargoType', 'cargoType')
+      .leftJoin(
+        TrainScheduleBooking,
+        'scheduleBooking',
+        'scheduleBooking.booking_id = booking.id',
+      )
+      .where('booking.status = :paidStatus', { paidStatus: 'PAID' })
+      .andWhere('scheduleBooking.id IS NULL');
+
+    if (options.freightType) {
+      qb.andWhere('booking.freightType = :freightType', { freightType: options.freightType });
+    }
+
+    if (options.originStationId) {
+      qb.andWhere('booking.originYardId = :originStationId', {
+        originStationId: options.originStationId,
+      });
+    }
+    if (options.destinationStationId) {
+      qb.andWhere('booking.destinationYardId = :destinationStationId', {
+        destinationStationId: options.destinationStationId,
+      });
+    }
+    if (options.schedulingStatus) {
+      qb.andWhere('booking.scheduling_status = :schedulingStatus', {
+        schedulingStatus: options.schedulingStatus,
+      });
+    }
+
+    return qb
+      .orderBy('booking.priority_score', 'DESC')
+      .addOrderBy('booking.scheduled_date', 'ASC')
+      .addOrderBy('booking.created_at', 'ASC')
+      .getMany();
+  }
+
+  findByIdsForScheduling(bookingIds: string[], manager?: EntityManager): Promise<Booking[]> {
+    if (!bookingIds.length) return Promise.resolve([]);
+    return this.bookingRepo(manager).find({
+      where: { id: In(bookingIds) },
+      relations: {
+        company: true,
+        originYard: true,
+        destinationYard: true,
+        bookingContainers: { containerType: true },
+        cargoType: true,
+      },
+      order: { priorityScore: 'DESC', createdAt: 'ASC' },
+    });
+  }
+
+  async updateSchedulingFields(
+    bookingId: string,
+    fields: Partial<
+      Pick<
+        Booking,
+        'schedulingStatus' | 'wagonsRequired' | 'scheduledAt' | 'holdStartedAt' | 'holdExpiresAt'
+      >
+    >,
+    manager?: EntityManager,
+  ): Promise<void> {
+    await this.bookingRepo(manager).update(bookingId, fields as never);
+  }
+
+  async setHoldWindowOnPaid(bookingId: string, manager?: EntityManager): Promise<void> {
+    const now = new Date();
+    const expires = new Date(now.getTime() + 3 * 60 * 60 * 1000);
+    await this.updateSchedulingFields(
+      bookingId,
+      {
+        schedulingStatus: SchedulingStatus.Holding,
+        holdStartedAt: now,
+        holdExpiresAt: expires,
+      },
+      manager,
+    );
+  }
 }
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -4,6 +4,7 @@ import {
  Injectable,
  NotFoundException,
 } from '@nestjs/common';
+import { SchedulingStatus } from '@edr/types';
 // import { CustomersService } from '../customers/customers.service';
 import { CompaniesService } from '../companies/companies.service';
 import { FilesService } from '../files/files.service';
@@ -64,6 +65,7 @@ export class BookingsService {
    paymentCurrency: string;
    tradeDirection: string;
    isHazardous?: boolean;
+    isGovernment?: boolean;
    allowConsolidation?: boolean;
    shippingLineId?: string | null;
    containers: CreateBookingContainerDto[];
@@ -92,6 +94,7 @@ export class BookingsService {
      paymentCurrency: dto.paymentCurrency,
      tradeDirection: dto.tradeDirection,
      isHazardous: dto.isHazardous ?? false,
+      isGovernment: dto.isGovernment ?? false,
      allowConsolidation:
        dto.freightType === 'CONTAINER' ? dto.allowConsolidation : false,
      shippingLineId: dto.shippingLineId,
@@ -178,8 +181,15 @@ export class BookingsService {
    //   customerId = customer.id;
    // }

-    let companyId = dto.companyId;
-    if (!companyId) {
+    const isGovernment = dto.isGovernment === true;
+
+    let companyId: string | null | undefined = dto.companyId;
+    if (isGovernment) {
+      if (!dto.governmentInstitution?.trim()) {
+        throw new BadRequestException('governmentInstitution is required for government bookings');
+      }
+      companyId = dto.companyId ?? null;
+    } else if (!companyId) {
      if (!userId) {
        throw new BadRequestException(
          'companyId is required or must be resolvable from auth token',
@@ -209,6 +219,7 @@ export class BookingsService {
      paymentCurrency: dto.paymentCurrency,
      tradeDirection: dto.tradeDirection,
      isHazardous: dto.isHazardous,
+      isGovernment,
      allowConsolidation,
      shippingLineId: dto.shippingLineId,
      containers,
@@ -220,7 +231,9 @@ export class BookingsService {

    const booking = await this.bookingsRepository.create({
      reference,
-      companyId,
+      companyId: companyId ?? null,
+      isGovernment,
+      governmentInstitution: isGovernment ? dto.governmentInstitution!.trim() : null,
      trainId: dto.trainId,
      contractType: dto.contractType,
      previousContractId: dto.previousContractId,
@@ -300,12 +313,13 @@ export class BookingsService {
    const freightType = (dto.freightType ?? existing.freightType) as FreightType;
    let containers =
      dto.containers ??
-      existing.bookingContainers?.map((bc) => ({
-        containerTypeId: bc.containerTypeId,
-        quantity: bc.quantity,
-        vgmPerUnitTons: Number(bc.vgmPerUnitTons),
-      })) ??
-      [];
+      (existing.bookingContainers ?? [])
+        .filter((bc): bc is typeof bc & { containerTypeId: string } => bc.containerTypeId != null)
+        .map((bc) => ({
+          containerTypeId: bc.containerTypeId,
+          quantity: bc.quantity,
+          vgmPerUnitTons: Number(bc.vgmPerUnitTons),
+        }));

    let cargoTypeId =
      dto.cargoTypeId !== undefined ? dto.cargoTypeId : existing.cargoTypeId;
@@ -403,6 +417,19 @@ export class BookingsService {
    return { booking, warnings };
  }

+  /** Parse comma-separated scheduling status query values. */
+  private parseSchedulingStatusFilter(filter: FilterBookingDto): {
+    schedulingStatuses?: string[];
+  } {
+    const raw = filter.schedulingStatuses;
+    if (!raw) return {};
+    const schedulingStatuses = raw
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+    return schedulingStatuses.length ? { schedulingStatuses } : {};
+  }
+
  /** Parse comma-separated or repeated status query values. */
  private parseStatusFilter(filter: FilterBookingDto): {
    statuses?: string[];
@@ -433,11 +460,14 @@ export class BookingsService {
    const page = filter.page ?? 1;
    const pageSize = filter.pageSize ?? 20;
    const statusFilter = this.parseStatusFilter(filter);
+    const schedulingStatusFilter = this.parseSchedulingStatusFilter(filter);

    return this.bookingsRepository.findAllPaginated({
      page,
      pageSize,
      ...statusFilter,
+      ...schedulingStatusFilter,
+      assignedToSchedule: filter.assignedToSchedule,
      companyId: filter.companyId,
      contractType: filter.contractType,
      serviceTypeId: filter.serviceTypeId,
@@ -695,12 +725,13 @@ export class BookingsService {
      return true;
    }
    if (dto.containers !== undefined) {
-      const existingContainers =
-        existing.bookingContainers?.map((bc) => ({
+      const existingContainers = (existing.bookingContainers ?? [])
+        .filter((bc): bc is typeof bc & { containerTypeId: string } => bc.containerTypeId != null)
+        .map((bc) => ({
          containerTypeId: bc.containerTypeId,
          quantity: bc.quantity,
          vgmPerUnitTons: Number(bc.vgmPerUnitTons),
-        })) ?? [];
+        }));
      if (JSON.stringify(existingContainers) !== JSON.stringify(containers)) {
        return true;
      }
@@ -714,4 +745,32 @@ export class BookingsService {
    }
    return false;
  }
+
+  /** Staff expedite: mark a government booking PAID and ready for scheduling (no commercial hold). */
+  async governmentExpedite(id: string, staffUserId: string): Promise<Booking> {
+    const booking = await this.findById(id);
+    if (!booking.isGovernment) {
+      throw new BadRequestException('Only government bookings can be expedited');
+    }
+    const blocked = ['PAID', 'IN_TRANSIT', 'COMPLETED', 'CANCELLED', 'REJECTED'];
+    if (blocked.includes(booking.status)) {
+      throw new BadRequestException(`Cannot expedite booking in status ${booking.status}`);
+    }
+
+    await this.bookingsRepository.update(id, {
+      status: 'PAID',
+      paymentStatus: 'PAID',
+      schedulingStatus: SchedulingStatus.Eligible,
+      holdStartedAt: null,
+      holdExpiresAt: null,
+    });
+    await this.bookingsRepository.createReviewNote(
+      id,
+      `Government booking expedited to PAID by staff (${staffUserId})`,
+      'STAFF_NOTE',
+      staffUserId,
+    );
+
+    return this.findById(id);
+  }
 }
--- a/apps/edr-freight-api/src/modules/bookings/consolidation.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/consolidation.service.ts
@@ -76,11 +76,12 @@ export class ConsolidationService {
  }

  async slotsFromBooking(booking: Booking): Promise<ConsolidationSlot[]> {
-    const lines =
-      booking.bookingContainers?.map((bc) => ({
+    const lines = (booking.bookingContainers ?? [])
+      .filter((bc): bc is typeof bc & { containerTypeId: string } => bc.containerTypeId != null)
+      .map((bc) => ({
        containerTypeId: bc.containerTypeId,
        quantity: bc.quantity,
-      })) ?? [];
+      }));
    return this.slotsFromContainerLines(lines);
  }

--- a/apps/edr-freight-api/src/modules/bookings/dto/create-booking.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/create-booking.dto.ts
@@ -12,6 +12,7 @@ import {
  IsString,
  IsUUID,
  Min,
+  MinLength,
  Validate,
  ValidateIf,
  ValidateNested,
@@ -66,7 +67,21 @@ export class CreateBookingDto {
  // @IsUUID()
  // customerId?: string;

+  @ApiPropertyOptional({ description: 'Staff only: government booking flag' })
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) => value === 'true' || value === true)
+  isGovernment?: boolean;
+
+  @ApiPropertyOptional({ description: 'Required when isGovernment is true' })
+  @ValidateIf((o) => o.isGovernment === true)
+  @IsString()
+  @MinLength(2)
+  @Transform(({ value }) => (typeof value === 'string' ? value.trim() : value))
+  governmentInstitution?: string;
+
  @ApiPropertyOptional({ format: 'uuid', description: 'Admin only: target company' })
+  @ValidateIf((o) => o.isGovernment !== true)
  @IsOptional()
  @IsUUID()
  companyId?: string;
--- a/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
@@ -84,8 +84,25 @@ export class FilterBookingDto {
  @Transform(({ value }) => (value ? parseInt(value, 10) : 20))
  pageSize?: number;

+  @ApiPropertyOptional({
+    description: 'Comma-separated scheduling statuses (NOT_SCHEDULED,HOLDING,ELIGIBLE,SCHEDULED)',
+  })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (value === undefined || value === null || value === '') return undefined;
+    if (Array.isArray(value)) return value.map(String).join(',');
+    return String(value);
+  })
+  schedulingStatuses?: string;
+
+  @ApiPropertyOptional({ enum: ['true', 'false'], description: 'Filter by train schedule assignment' })
+  @IsOptional()
+  @IsIn(['true', 'false'])
+  assignedToSchedule?: 'true' | 'false';
+
  @ApiPropertyOptional({ default: 'createdAt' })
  @IsOptional()
+  @IsIn(['createdAt', 'priorityScore', 'scheduledDate', 'isGovernment'])
  sortBy?: string;

  @ApiPropertyOptional({ enum: ['ASC', 'DESC'], default: 'DESC' })
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-container.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-container.entity.ts
@@ -15,12 +15,15 @@ export class BookingContainer extends BaseEntity {
  @JoinColumn({ name: 'booking_id' })
  booking?: Booking;

-  @Column({ name: 'container_type_id', type: 'uuid' })
-  containerTypeId!: string;
+  @Column({ name: 'container_type_id', type: 'uuid', nullable: true })
+  containerTypeId?: string | null;

-  @ManyToOne(() => ContainerType)
+  @ManyToOne(() => ContainerType, { nullable: true })
  @JoinColumn({ name: 'container_type_id' })
-  containerType?: ContainerType;
+  containerType?: ContainerType | null;
+
+  @Column({ name: 'container_number', type: 'varchar', length: 64, nullable: true })
+  containerNumber?: string | null;

  @Column({ name: 'quantity', type: 'smallint' })
  quantity!: number;
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-review-note.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-review-note.entity.ts
@@ -2,7 +2,7 @@ import { BaseEntity } from '@edr/api-common';
 import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { Booking } from './booking.entity';

-export const REVIEW_NOTE_TYPES = ['CHANGES_REQUESTED', 'REJECTION'] as const;
+export const REVIEW_NOTE_TYPES = ['CHANGES_REQUESTED', 'REJECTION', 'STAFF_NOTE'] as const;
 export type ReviewNoteType = (typeof REVIEW_NOTE_TYPES)[number];

@Entity({ schema: 'freight', name: 'booking_review_note' })
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -1,4 +1,5 @@
 import { BaseEntity } from '@edr/api-common';
+import { SchedulingStatus } from '@edr/types';
 import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 // import { Customer } from '../../customers/entities/customer.entity';
 import { Company } from '../../companies/entities/company.entity';
@@ -51,6 +52,16 @@ export type PaymentStatus = (typeof PAYMENT_STATUSES)[number];
 export const FREIGHT_TYPES = ['CONTAINER', 'BULK'] as const;
 export type FreightType = (typeof FREIGHT_TYPES)[number];

+export const SCHEDULING_STATUSES = [
+  SchedulingStatus.NotScheduled,
+  SchedulingStatus.Holding,
+  SchedulingStatus.Eligible,
+  SchedulingStatus.Scheduled,
+  SchedulingStatus.Dispatched,
+] as const;
+
+export type BookingSchedulingStatus = (typeof SCHEDULING_STATUSES)[number];
+
 /** Statuses where the customer may edit booking fields. */
 export const CUSTOMER_EDITABLE_STATUSES: BookingStatus[] = [
  'DRAFT',
@@ -69,16 +80,24 @@ export class Booking extends BaseEntity {
  // @JoinColumn({ name: 'customer_id' })
  // customer?: Customer;

-  @Column({ name: 'company_id', type: 'uuid' })
-  companyId!: string;
+  @Column({ name: 'company_id', type: 'uuid', nullable: true })
+  companyId?: string | null;

-  @ManyToOne(() => Company)
+  @ManyToOne(() => Company, { nullable: true })
  @JoinColumn({ name: 'company_id' })
-  company?: Company;
+  company?: Company | null;

+  @Column({ name: 'is_government', type: 'boolean', default: false })
+  isGovernment!: boolean;
+
+  @Column({ name: 'government_institution', type: 'varchar', length: 255, nullable: true })
+  governmentInstitution?: string | null;
+
+  /** @deprecated Fleet master data link — scheduling uses train_schedule_bookings instead. */
  @Column({ name: 'train_id', type: 'uuid', nullable: true })
  trainId?: string | null;

+  /** @deprecated Use train_schedule_bookings for operational scheduling. */
  @ManyToOne(() => Train, { nullable: true })
  @JoinColumn({ name: 'train_id' })
  train?: Train | null;
@@ -240,6 +259,21 @@ export class Booking extends BaseEntity {
  @JoinColumn({ name: 'consolidation_partner_id' })
  consolidationPartner?: Booking | null;

+  @Column({ name: 'wagons_required', type: 'numeric', precision: 6, scale: 2, nullable: true })
+  wagonsRequired?: number | null;
+
+  @Column({ name: 'scheduling_status', type: 'varchar', length: 30, default: 'NOT_SCHEDULED' })
+  schedulingStatus!: string;
+
+  @Column({ name: 'hold_started_at', type: 'timestamptz', nullable: true })
+  holdStartedAt?: Date | null;
+
+  @Column({ name: 'hold_expires_at', type: 'timestamptz', nullable: true })
+  holdExpiresAt?: Date | null;
+
+  @Column({ name: 'scheduled_at', type: 'timestamptz', nullable: true })
+  scheduledAt?: Date | null;
+
  @OneToMany(() => BookingContainer, (bc) => bc.booking)
  bookingContainers?: BookingContainer[];

--- a/apps/edr-freight-api/src/modules/cargoes/cargoes.service.ts
+++ b/apps/edr-freight-api/src/modules/cargoes/cargoes.service.ts
@@ -159,9 +159,12 @@ export class CargoesService {
    cargo.status = 'DELIVERED';
    if (dto?.deliveryRemarks) cargo.description = dto.deliveryRemarks;

-    const remaining = await this.cargoRepo.count({
-      where: { containerId: cargo.containerId, status: 'LOADED' },
-    });
+    const remaining =
+      cargo.containerId != null
+        ? await this.cargoRepo.count({
+            where: { containerId: cargo.containerId, status: 'LOADED' },
+          })
+        : 0;
    if (remaining === 0 && cargo.container) {
      cargo.container.status = 'AVAILABLE';
      await this.containerRepo.save(cargo.container);
--- a/apps/edr-freight-api/src/modules/cargoes/entities/cargoes.entity.ts
+++ b/apps/edr-freight-api/src/modules/cargoes/entities/cargoes.entity.ts
@@ -1,7 +1,9 @@
 // apps/edr-freight-api/src/modules/cargoes/entities/cargo.entity.ts
 import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
 import { BaseEntity } from '@edr/api-common';
+import { Booking } from '../../bookings/entities/booking.entity';
 import { Container } from '../../container-management/entities/container.entity';
+import { WagonBookingAllocation } from '../../train-schedules/entities/wagon-booking-allocation.entity';

@Entity({ name: 'cargoes', schema: 'freight' })
 export class Cargo extends BaseEntity {
@@ -11,8 +13,8 @@ export class Cargo extends BaseEntity {
  @Column({ name: 'shipment_id', type: 'uuid' })
  shipmentId!: string;

-  @Column({ name: 'container_id', type: 'uuid' })
-  containerId!: string;
+  @Column({ name: 'container_id', type: 'uuid', nullable: true })
+  containerId!: string | null;

  @Column({ name: 'cargo_type_id', type: 'uuid', nullable: true })
  cargoTypeId!: string | null; // optional link to cargo_types table
@@ -38,8 +40,24 @@ export class Cargo extends BaseEntity {
  @Column({ name: 'unloaded_at', type: 'timestamp', nullable: true })
  unloadedAt!: Date | null;

-  // Relationship to Container
-  @ManyToOne(() => Container, (container) => container.cargoes, { onDelete: 'RESTRICT' })
+  @Column({ name: 'wagon_booking_allocation_id', type: 'uuid', nullable: true })
+  wagonBookingAllocationId!: string | null;
+
+  @ManyToOne(() => WagonBookingAllocation, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'wagon_booking_allocation_id' })
+  wagonBookingAllocation?: WagonBookingAllocation | null;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId!: string | null;
+
+  @ManyToOne(() => Booking, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'booking_id' })
+  booking?: Booking | null;
+
+  @Column({ name: 'load_type', type: 'varchar', length: 20, nullable: true })
+  loadType!: string | null;
+
+  @ManyToOne(() => Container, (container) => container.cargoes, { onDelete: 'RESTRICT', nullable: true })
  @JoinColumn({ name: 'container_id' })
-  container!: Container;
+  container!: Container | null;
 }
--- a/apps/edr-freight-api/src/modules/container-management/entities/container.entity.ts
+++ b/apps/edr-freight-api/src/modules/container-management/entities/container.entity.ts
@@ -1,6 +1,9 @@
 // apps/edr-freight-api/src/modules/container-management/entities/container.entity.ts
 import { Entity, Column, ManyToOne, OneToMany, JoinColumn } from 'typeorm';
 import { BaseEntity } from '@edr/api-common';
+import { Booking } from '../../bookings/entities/booking.entity';
+import { BookingContainer } from '../../bookings/entities/booking-container.entity';
+import { WagonBookingAllocation } from '../../train-schedules/entities/wagon-booking-allocation.entity';
 import { Wagon } from '../../wagons/entities/wagon.entity';
 import { Cargo } from '../../cargoes/entities/cargoes.entity';

@@ -34,7 +37,27 @@ sealNumber!: string | null;
  @Column({ type: 'varchar', default: 'AVAILABLE' })
  status!: string; // AVAILABLE, LOADED, IN_TRANSIT, MAINTENANCE, DAMAGED

-  // Relationship to Wagon
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId!: string | null;
+
+  @ManyToOne(() => Booking, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'booking_id' })
+  booking?: Booking | null;
+
+  @Column({ name: 'wagon_booking_allocation_id', type: 'uuid', nullable: true })
+  wagonBookingAllocationId!: string | null;
+
+  @ManyToOne(() => WagonBookingAllocation, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'wagon_booking_allocation_id' })
+  wagonBookingAllocation?: WagonBookingAllocation | null;
+
+  @Column({ name: 'booking_container_id', type: 'uuid', nullable: true })
+  bookingContainerId!: string | null;
+
+  @ManyToOne(() => BookingContainer, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'booking_container_id' })
+  bookingContainer?: BookingContainer | null;
+
  @ManyToOne(() => Wagon, (wagon) => wagon.containers, { onDelete: 'SET NULL' })
  @JoinColumn({ name: 'wagon_id' })
  wagon!: Wagon | null;
--- a/apps/edr-freight-api/src/modules/overview/overview.repository.ts
+++ b/apps/edr-freight-api/src/modules/overview/overview.repository.ts
@@ -124,7 +124,7 @@ export class OverviewRepository {
        this.wagonRepository
          .createQueryBuilder('wagon')
          .where('wagon.deleted_at IS NULL')
-          .andWhere('wagon.status = :status', { status: 'AVAILABLE' })
+          .andWhere('wagon.status = :status', { status: Freight.WagonStatus.Available })
          .getCount(),
        this.containerRepository
          .createQueryBuilder('container')
--- a/apps/edr-freight-api/src/modules/payment/payment.service.ts
+++ b/apps/edr-freight-api/src/modules/payment/payment.service.ts
@@ -16,6 +16,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as Handlebars from "handlebars";
 import { ConfigService } from "@nestjs/config";
+import { SchedulingStatus } from "@edr/types";
 import { Booking } from "../bookings/entities/booking.entity";

 type PaymentMethod = PaymentEntity["method"];
@@ -168,7 +169,14 @@ export class PaymentService {
      const ordersStatus = bizContent.order_status;
      if (ordersStatus == "PAY_SUCCESS") {
        await this.datasource.transaction(async (mg) => {
-          await mg.update(Booking, { id: resp.refId }, { status: "PAID" });
+          const now = new Date();
+          const holdExpires = new Date(now.getTime() + 3 * 60 * 60 * 1000);
+          await mg.update(Booking, { id: resp.refId }, {
+            status: "PAID",
+            schedulingStatus: SchedulingStatus.Holding,
+            holdStartedAt: now,
+            holdExpiresAt: holdExpires,
+          });
          await mg.update(PaymentEntity, { id: resp.id }, { status: "success" });
        });
      }
--- a/apps/edr-freight-api/src/modules/rule-engine/government-priority.constants.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/government-priority.constants.ts
@@ -0,0 +1,2 @@
+/** Ensures government bookings outrank commercial priority (max ~1,500 today). */
+export const GOVERNMENT_PRIORITY_BONUS = 50_000;
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -36,6 +36,7 @@ import {
  SHIPPING_LINES_REPOSITORY,
 } from './interfaces/shipping-lines.repository.interface';
 import { DEFAULT_APPROVAL_RULE_ROWS } from './approval-rules.defaults';
+import { GOVERNMENT_PRIORITY_BONUS } from './government-priority.constants';

 export interface BookingContainerEvalInput {
  containerTypeId: string;
@@ -54,6 +55,7 @@ export interface BookingEvaluationInput {
  paymentCurrency: string;
  tradeDirection: string;
  isHazardous: boolean;
+  isGovernment?: boolean;
  allowConsolidation?: boolean;
  shippingLineId?: string | null;
  containers: BookingContainerEvalInput[];
@@ -180,6 +182,10 @@ export class RuleEngineService {
      }
    }

+    if (input.isGovernment) {
+      priorityScore += GOVERNMENT_PRIORITY_BONUS;
+    }
+
    let shippingLineMapped = false;
    if (input.shippingLineId) {
      const line = await this.shippingLinesRepo.findById(input.shippingLineId);
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/dto/preview-reschedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/dto/preview-reschedule.dto.ts
@@ -0,0 +1,46 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsDateString,
+  IsIn,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
+
+import { RESCHEDULE_TRIGGERS } from '../entities/scheduling-event.entity';
+
+export class PreviewRescheduleDto {
+  @ApiProperty({ type: [String] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('4', { each: true })
+  incomingBookingIds!: string[];
+
+  @ApiProperty({ enum: RESCHEDULE_TRIGGERS })
+  @IsIn([...RESCHEDULE_TRIGGERS])
+  trigger!: (typeof RESCHEDULE_TRIGGERS)[number];
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  reason?: string;
+
+  @ApiPropertyOptional({ example: '2026-06-22T08:00:00.000Z' })
+  @IsOptional()
+  @IsDateString()
+  newDepartureDate?: string;
+}
+
+export class ExecuteRescheduleDto extends PreviewRescheduleDto {
+  @ApiProperty({ type: [String], description: 'Booking IDs to assign after reschedule' })
+  @IsArray()
+  @IsUUID('4', { each: true })
+  finalBookingIds!: string[];
+
+  @ApiProperty({ type: [String], description: 'Booking IDs removed from the schedule' })
+  @IsArray()
+  @IsUUID('4', { each: true })
+  displacedBookingIds!: string[];
+}
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/entities/scheduling-event.entity.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/entities/scheduling-event.entity.ts
@@ -0,0 +1,33 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+export const RESCHEDULE_TRIGGERS = [
+  'GOVERNMENT_PREEMPT',
+  'TRAIN_MAINTENANCE',
+  'MANUAL',
+  'CAPACITY_REBALANCE',
+] as const;
+
+export type RescheduleTrigger = (typeof RESCHEDULE_TRIGGERS)[number];
+
+@Entity({ schema: 'freight', name: 'scheduling_events' })
+@Index(['trainScheduleId'])
+export class SchedulingEvent extends BaseEntity {
+  @Column({ name: 'train_schedule_id', type: 'uuid' })
+  trainScheduleId!: string;
+
+  @Column({ name: 'trigger', type: 'varchar', length: 40 })
+  trigger!: RescheduleTrigger;
+
+  @Column({ name: 'actor_user_id', type: 'uuid', nullable: true })
+  actorUserId?: string | null;
+
+  @Column({ name: 'reason', type: 'text', nullable: true })
+  reason?: string | null;
+
+  @Column({ name: 'plan_snapshot', type: 'jsonb' })
+  planSnapshot!: Record<string, unknown>;
+
+  @Column({ name: 'displaced_booking_ids', type: 'jsonb', default: '[]' })
+  displacedBookingIds!: string[];
+}
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.controller.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.controller.ts
@@ -0,0 +1,65 @@
+import { Body, Controller, Param, ParseUUIDPipe, Post } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { CurrentUser } from '@edr/api-common';
+
+import { TrainSchedulingManage } from '../../common/booking-guards';
+import {
+  type AuthUserPayload,
+  resolveAuthUserId,
+} from '../../common/resolve-auth-user-id';
+import { ExecuteRescheduleDto, PreviewRescheduleDto } from './dto/preview-reschedule.dto';
+import { SchedulingRescheduleService } from './scheduling-reschedule.service';
+
+@ApiTags('train-scheduling')
+@ApiBearerAuth()
+@Controller('train-scheduling/schedules/:id/reschedule')
+export class SchedulingRescheduleController {
+  constructor(private readonly schedulingRescheduleService: SchedulingRescheduleService) {}
+
+  @Post('preview')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Preview reschedule / government preempt plan' })
+  preview(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: PreviewRescheduleDto,
+  ) {
+    return this.schedulingRescheduleService.previewReschedule(id, dto);
+  }
+
+  @Post('execute')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Execute a confirmed reschedule plan' })
+  execute(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: ExecuteRescheduleDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.schedulingRescheduleService.executeReschedule(
+      id,
+      dto,
+      resolveAuthUserId(user),
+    );
+  }
+}
+
+@ApiTags('train-scheduling')
+@ApiBearerAuth()
+@Controller('train-scheduling/schedules/:id')
+export class SchedulingMaintenanceController {
+  constructor(private readonly schedulingRescheduleService: SchedulingRescheduleService) {}
+
+  @Post('maintenance')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Reschedule train for maintenance (new departure + rebalance)' })
+  maintenance(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: PreviewRescheduleDto & { newDepartureDate: string },
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.schedulingRescheduleService.maintenanceReschedule(
+      id,
+      dto,
+      resolveAuthUserId(user),
+    );
+  }
+}
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.module.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.module.ts
@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { BookingsModule } from '../bookings/bookings.module';
+import { TrainSchedulesModule } from '../train-schedules/train-schedules.module';
+import { TrainSchedulingModule } from '../train-scheduling/train-scheduling.module';
+import { SchedulingEvent } from './entities/scheduling-event.entity';
+import {
+  SchedulingMaintenanceController,
+  SchedulingRescheduleController,
+} from './scheduling-reschedule.controller';
+import { SchedulingRescheduleRepository } from './scheduling-reschedule.repository';
+import { SchedulingRescheduleService } from './scheduling-reschedule.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([SchedulingEvent]),
+    BookingsModule,
+    TrainSchedulesModule,
+    TrainSchedulingModule,
+  ],
+  controllers: [SchedulingRescheduleController, SchedulingMaintenanceController],
+  providers: [SchedulingRescheduleRepository, SchedulingRescheduleService],
+  exports: [SchedulingRescheduleService],
+})
+export class SchedulingRescheduleModule {}
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.repository.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.repository.ts
@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { SchedulingEvent, type RescheduleTrigger } from './entities/scheduling-event.entity';
+
+@Injectable()
+export class SchedulingRescheduleRepository {
+  constructor(
+    @InjectRepository(SchedulingEvent)
+    private readonly repository: Repository<SchedulingEvent>,
+  ) {}
+
+  /** Persist an audit record for a completed reschedule. */
+  async createEvent(data: {
+    trainScheduleId: string;
+    trigger: RescheduleTrigger;
+    actorUserId?: string;
+    reason?: string;
+    planSnapshot: Record<string, unknown>;
+    displacedBookingIds: string[];
+  }): Promise<SchedulingEvent> {
+    return this.repository.save(this.repository.create(data));
+  }
+}
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.spec.ts
@@ -0,0 +1,230 @@
+import { BadRequestException } from '@nestjs/common';
+
+import { compareSchedulingPriority } from '../scheduling/compare-scheduling-priority.util';
+import { SchedulingRescheduleService } from './scheduling-reschedule.service';
+
+const makeBooking = (
+  id: string,
+  reference: string,
+  extra: Record<string, unknown> = {},
+) => ({
+  id,
+  reference,
+  freightType: 'CONTAINER',
+  cargoTotalWeightVgm: 100,
+  scheduledDate: new Date('2026-06-20T08:00:00.000Z'),
+  originYardId: 'yard-origin',
+  destinationYardId: 'yard-destination',
+  status: 'PAID',
+  isGovernment: false,
+  priorityScore: 50,
+  bookingContainers: [
+    {
+      id: `${id}-line`,
+      wagonsRequired: 5,
+      quantity: 1,
+      vgmPerUnitTons: 100,
+    },
+  ],
+  ...extra,
+});
+
+describe('compareSchedulingPriority', () => {
+  it('orders government before commercial', () => {
+    const sorted = [
+      {
+        isGovernment: false,
+        priorityScore: 50000,
+        scheduledDate: new Date('2026-06-20'),
+      },
+      {
+        isGovernment: true,
+        priorityScore: 100,
+        scheduledDate: new Date('2026-06-25'),
+      },
+    ].sort(compareSchedulingPriority);
+
+    expect(sorted[0]?.isGovernment).toBe(true);
+  });
+});
+
+describe('SchedulingRescheduleService', () => {
+  let service: SchedulingRescheduleService;
+  let trainSchedulesRepository: Record<string, jest.Mock>;
+  let bookingsRepository: Record<string, jest.Mock>;
+  let trainSchedulingService: Record<string, jest.Mock>;
+  let schedulingRescheduleRepository: Record<string, jest.Mock>;
+
+  beforeEach(() => {
+    trainSchedulesRepository = {
+      findByIdWithFullGraph: jest.fn(),
+      updateStatus: jest.fn(),
+    };
+    bookingsRepository = {
+      findByIdsForScheduling: jest.fn(),
+      updateSchedulingFields: jest.fn(),
+    };
+    trainSchedulingService = {
+      previewTrainSchedule: jest.fn(),
+      unassignBooking: jest.fn(),
+      assignBookingsToSchedule: jest.fn(),
+    };
+    schedulingRescheduleRepository = {
+      createEvent: jest.fn().mockResolvedValue({ id: 'event-1' }),
+    };
+
+    service = new SchedulingRescheduleService(
+      trainSchedulesRepository as never,
+      bookingsRepository as never,
+      trainSchedulingService as never,
+      schedulingRescheduleRepository as never,
+    );
+  });
+
+  it('rejects reschedule on dispatched trains', async () => {
+    trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue({
+      id: 'sched-1',
+      status: 'DISPATCHED',
+      scheduleBookings: [],
+    });
+
+    await expect(
+      service.previewReschedule('sched-1', {
+        incomingBookingIds: ['gov-1'],
+        trigger: 'GOVERNMENT_PREEMPT',
+      }),
+    ).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('displaces lower-priority commercial when government incoming exceeds capacity', async () => {
+    const commercial = makeBooking('c1', 'BKG-COMM', { priorityScore: 10, isGovernment: false });
+    const government = makeBooking('g1', 'BKG-GOV', {
+      isGovernment: true,
+      priorityScore: 60000,
+      governmentInstitution: 'Ministry',
+    });
+
+    trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue({
+      id: 'sched-1',
+      status: 'DRAFT',
+      scheduledDepartureDate: new Date('2026-06-20T08:00:00.000Z'),
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+      scheduleBookings: [{ bookingId: 'c1', booking: commercial }],
+    });
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue([government]);
+
+    trainSchedulingService.previewTrainSchedule.mockImplementation(
+      async ({ bookingIds }: { bookingIds: string[] }) => ({
+        valid: bookingIds.length <= 1,
+        violations: bookingIds.length > 1 ? ['Train capacity exceeded'] : [],
+        warnings: [],
+      }),
+    );
+
+    const plan = await service.previewReschedule('sched-1', {
+      incomingBookingIds: ['g1'],
+      trigger: 'GOVERNMENT_PREEMPT',
+    });
+
+    expect(plan.retained.map((b) => b.id)).toEqual(['g1']);
+    expect(plan.displaced.map((b) => b.id)).toEqual(['c1']);
+    expect(plan.finalBookingIds).toEqual(['g1']);
+  });
+
+  it('readmits high-priority commercial when spare capacity remains', async () => {
+    const low = makeBooking('c-low', 'BKG-LOW', { priorityScore: 5 });
+    const high = makeBooking('c-high', 'BKG-HIGH', { priorityScore: 500 });
+    const government = makeBooking('g1', 'BKG-GOV', { isGovernment: true, priorityScore: 60000 });
+
+    trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue({
+      id: 'sched-1',
+      status: 'DRAFT',
+      scheduledDepartureDate: new Date('2026-06-20T08:00:00.000Z'),
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+      scheduleBookings: [
+        { bookingId: 'c-low', booking: low },
+        { bookingId: 'c-high', booking: high },
+      ],
+    });
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue([government]);
+
+    const fitAttempts = new Map<string, number>();
+    trainSchedulingService.previewTrainSchedule.mockImplementation(
+      async ({ bookingIds }: { bookingIds: string[] }) => {
+        const key = [...bookingIds].sort().join(',');
+        const attempt = (fitAttempts.get(key) ?? 0) + 1;
+        fitAttempts.set(key, attempt);
+
+        const fits =
+          bookingIds.length === 1 ||
+          (key === 'c-high,g1' && attempt > 1);
+
+        return {
+          valid: fits,
+          violations: fits ? [] : ['Train capacity exceeded'],
+          warnings: [],
+        };
+      },
+    );
+
+    const plan = await service.previewReschedule('sched-1', {
+      incomingBookingIds: ['g1'],
+      trigger: 'GOVERNMENT_PREEMPT',
+    });
+
+    expect(plan.retained.map((b) => b.id)).toEqual(['g1']);
+    expect(plan.readmitted.map((b) => b.id)).toEqual(['c-high']);
+    expect(plan.displaced.map((b) => b.id)).toEqual(['c-low']);
+    expect(plan.finalBookingIds).toEqual(['g1', 'c-high']);
+  });
+
+  it('maintenance reschedule updates departure and rebalances bookings', async () => {
+    const commercial = makeBooking('c1', 'BKG-COMM', { priorityScore: 10 });
+    const schedule = {
+      id: 'sched-1',
+      status: 'DRAFT',
+      scheduledDepartureDate: new Date('2026-06-20T08:00:00.000Z'),
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+      scheduleBookings: [{ bookingId: 'c1', booking: commercial }],
+    };
+
+    trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue(schedule);
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue([commercial]);
+    trainSchedulingService.previewTrainSchedule.mockResolvedValue({
+      valid: true,
+      violations: [],
+      warnings: [],
+    });
+    trainSchedulesRepository.updateStatus.mockResolvedValue(undefined);
+    trainSchedulingService.assignBookingsToSchedule.mockResolvedValue({ id: 'sched-1' });
+
+    const result = await service.maintenanceReschedule(
+      'sched-1',
+      {
+        incomingBookingIds: ['c1'],
+        trigger: 'TRAIN_MAINTENANCE',
+        reason: 'Locomotive service',
+        newDepartureDate: '2026-06-22T10:00:00.000Z',
+      },
+      'staff-1',
+    );
+
+    expect(trainSchedulesRepository.updateStatus).toHaveBeenCalledWith(
+      'sched-1',
+      'DRAFT',
+      { scheduledDepartureDate: new Date('2026-06-22T10:00:00.000Z') },
+    );
+    expect(schedulingRescheduleRepository.createEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        trigger: 'TRAIN_MAINTENANCE',
+        actorUserId: 'staff-1',
+        reason: 'Locomotive service',
+      }),
+    );
+    expect(result.plan.trigger).toBe('TRAIN_MAINTENANCE');
+    expect(result.plan.finalBookingIds).toEqual(['c1']);
+  });
+});
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts
@@ -0,0 +1,230 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { SchedulingStatus, TrainScheduleStatus } from '@edr/types';
+
+import { Booking } from '../bookings/entities/booking.entity';
+import { BookingsRepository } from '../bookings/bookings.repository';
+import { compareSchedulingPriority } from '../scheduling/compare-scheduling-priority.util';
+import { TrainSchedulesRepository } from '../train-schedules/train-schedules.repository';
+import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
+import { ExecuteRescheduleDto, PreviewRescheduleDto } from './dto/preview-reschedule.dto';
+import { SchedulingRescheduleRepository } from './scheduling-reschedule.repository';
+
+export interface RescheduleBookingSummary {
+  id: string;
+  reference: string;
+  isGovernment: boolean;
+  priorityScore: number;
+  governmentInstitution?: string | null;
+}
+
+export interface ReschedulePlan {
+  scheduleId: string;
+  trigger: PreviewRescheduleDto['trigger'];
+  retained: RescheduleBookingSummary[];
+  displaced: RescheduleBookingSummary[];
+  readmitted: RescheduleBookingSummary[];
+  finalBookingIds: string[];
+  warnings: string[];
+}
+
+@Injectable()
+export class SchedulingRescheduleService {
+  constructor(
+    private readonly trainSchedulesRepository: TrainSchedulesRepository,
+    private readonly bookingsRepository: BookingsRepository,
+    private readonly trainSchedulingService: TrainSchedulingService,
+    private readonly schedulingRescheduleRepository: SchedulingRescheduleRepository,
+  ) {}
+
+  /** Preview who is retained, displaced, and readmitted on a schedule. */
+  async previewReschedule(
+    scheduleId: string,
+    dto: PreviewRescheduleDto,
+  ): Promise<ReschedulePlan> {
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+    if (schedule.status === TrainScheduleStatus.Dispatched) {
+      throw new BadRequestException('Cannot reschedule a dispatched train');
+    }
+
+    const currentOnSchedule = (schedule.scheduleBookings ?? [])
+      .map((link) => link.booking)
+      .filter((b): b is Booking => Boolean(b));
+
+    const incoming = await this.bookingsRepository.findByIdsForScheduling(dto.incomingBookingIds);
+    if (incoming.length !== dto.incomingBookingIds.length) {
+      throw new BadRequestException('One or more incoming bookings were not found');
+    }
+
+    const mergedMap = new Map<string, Booking>();
+    for (const booking of [...currentOnSchedule, ...incoming]) {
+      mergedMap.set(booking.id, booking);
+    }
+    const sorted = [...mergedMap.values()].sort(compareSchedulingPriority);
+
+    const warnings: string[] = [];
+    const retained: Booking[] = [];
+
+    for (const booking of sorted) {
+      const candidate = [...retained, booking];
+      const fits = await this.bookingsFitOnSchedule(candidate, schedule, scheduleId);
+      if (fits) {
+        retained.push(booking);
+      } else if (currentOnSchedule.some((b) => b.id === booking.id)) {
+        warnings.push(`Booking ${booking.reference} will be displaced from the train`);
+      }
+    }
+
+    const retainedIds = new Set(retained.map((b) => b.id));
+    const displacedFromCurrent = currentOnSchedule.filter((b) => !retainedIds.has(b.id));
+    const readmitted: Booking[] = [];
+
+    const displacedCommercial = displacedFromCurrent
+      .filter((b) => !b.isGovernment)
+      .sort(compareSchedulingPriority);
+
+    for (const booking of displacedCommercial) {
+      const candidate = [...retained, ...readmitted, booking];
+      const fits = await this.bookingsFitOnSchedule(candidate, schedule, scheduleId);
+      if (fits) {
+        readmitted.push(booking);
+        warnings.push(`Booking ${booking.reference} readmitted after government placement`);
+      }
+    }
+
+    const finalIds = [...retained, ...readmitted].map((b) => b.id);
+    const displacedIds = new Set(displacedFromCurrent.map((b) => b.id));
+    for (const id of readmitted.map((b) => b.id)) {
+      displacedIds.delete(id);
+    }
+    const displaced = displacedFromCurrent.filter((b) => displacedIds.has(b.id));
+
+    return {
+      scheduleId,
+      trigger: dto.trigger,
+      retained: retained.map((b) => this.toSummary(b)),
+      displaced: displaced.map((b) => this.toSummary(b)),
+      readmitted: readmitted.map((b) => this.toSummary(b)),
+      finalBookingIds: finalIds,
+      warnings,
+    };
+  }
+
+  /** Execute a confirmed reschedule plan. */
+  async executeReschedule(
+    scheduleId: string,
+    dto: ExecuteRescheduleDto,
+    actorUserId?: string,
+  ) {
+    const plan = await this.previewReschedule(scheduleId, dto);
+    const expectedDisplaced = new Set(plan.displaced.map((b) => b.id));
+    const providedDisplaced = new Set(dto.displacedBookingIds);
+    if (
+      expectedDisplaced.size !== providedDisplaced.size ||
+      [...expectedDisplaced].some((id) => !providedDisplaced.has(id))
+    ) {
+      throw new BadRequestException('Displaced booking list does not match current preview');
+    }
+
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+
+    if (dto.newDepartureDate && schedule) {
+      await this.trainSchedulesRepository.updateStatus(
+        scheduleId,
+        schedule.status as TrainScheduleStatus,
+        { scheduledDepartureDate: new Date(dto.newDepartureDate) },
+      );
+    }
+
+    for (const bookingId of dto.displacedBookingIds) {
+      try {
+        await this.trainSchedulingService.unassignBooking(scheduleId, bookingId);
+      } catch {
+        await this.bookingsRepository.updateSchedulingFields(bookingId, {
+          schedulingStatus: SchedulingStatus.Eligible,
+          wagonsRequired: null,
+        });
+      }
+    }
+
+    const assignResult = await this.trainSchedulingService.assignBookingsToSchedule(scheduleId, {
+      bookingIds: dto.finalBookingIds,
+      forceAssign: dto.trigger === 'GOVERNMENT_PREEMPT',
+    });
+
+    await this.schedulingRescheduleRepository.createEvent({
+      trainScheduleId: scheduleId,
+      trigger: dto.trigger,
+      actorUserId,
+      reason: dto.reason,
+      planSnapshot: plan as unknown as Record<string, unknown>,
+      displacedBookingIds: dto.displacedBookingIds,
+    });
+
+    return { plan, schedule: assignResult };
+  }
+
+  /** Maintenance shortcut: new departure + rebalance. */
+  async maintenanceReschedule(
+    scheduleId: string,
+    dto: PreviewRescheduleDto & { newDepartureDate: string },
+    actorUserId?: string,
+  ) {
+    const currentIds = (
+      await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId)
+    )?.scheduleBookings?.map((l) => l.bookingId) ?? [];
+
+    const preview = await this.previewReschedule(scheduleId, {
+      ...dto,
+      trigger: 'TRAIN_MAINTENANCE',
+      incomingBookingIds: currentIds.length ? currentIds : dto.incomingBookingIds,
+    });
+
+    return this.executeReschedule(
+      scheduleId,
+      {
+        ...dto,
+        trigger: 'TRAIN_MAINTENANCE',
+        incomingBookingIds: dto.incomingBookingIds,
+        finalBookingIds: preview.finalBookingIds,
+        displacedBookingIds: preview.displaced.map((b) => b.id),
+      },
+      actorUserId,
+    );
+  }
+
+  private async bookingsFitOnSchedule(
+    bookings: Booking[],
+    schedule: { scheduledDepartureDate: Date; originStationId: string; destinationStationId: string },
+    scheduleId: string,
+  ): Promise<boolean> {
+    if (!bookings.length) return true;
+    const preview = await this.trainSchedulingService.previewTrainSchedule({
+      bookingIds: bookings.map((b) => b.id),
+      scheduleDate: schedule.scheduledDepartureDate.toISOString(),
+      originStationId: schedule.originStationId,
+      destinationStationId: schedule.destinationStationId,
+      targetScheduleId: scheduleId,
+    });
+    return preview.valid;
+  }
+
+  private toSummary(booking: Booking): RescheduleBookingSummary {
+    return {
+      id: booking.id,
+      reference: booking.reference,
+      isGovernment: booking.isGovernment,
+      priorityScore: booking.priorityScore,
+      governmentInstitution: booking.governmentInstitution,
+    };
+  }
+}
--- a/apps/edr-freight-api/src/modules/scheduling/compare-scheduling-priority.util.ts
+++ b/apps/edr-freight-api/src/modules/scheduling/compare-scheduling-priority.util.ts
@@ -0,0 +1,19 @@
+export interface SchedulingPriorityBooking {
+  isGovernment?: boolean;
+  priorityScore?: number | null;
+  scheduledDate: Date | string;
+}
+
+/** Government first, then priority score, then earliest scheduled date. */
+export function compareSchedulingPriority(
+  a: SchedulingPriorityBooking,
+  b: SchedulingPriorityBooking,
+): number {
+  const govDiff = Number(Boolean(b.isGovernment)) - Number(Boolean(a.isGovernment));
+  if (govDiff !== 0) return govDiff;
+
+  const priorityDiff = (b.priorityScore ?? 0) - (a.priorityScore ?? 0);
+  if (priorityDiff !== 0) return priorityDiff;
+
+  return new Date(a.scheduledDate).getTime() - new Date(b.scheduledDate).getTime();
+}
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
@@ -1,4 +1,5 @@
 import { BaseEntity } from '@edr/api-common';
+import { TrainScheduleStatus as TrainScheduleStatusEnum } from '@edr/types';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany, OneToOne } from 'typeorm';

 import { Yard } from '../../rule-engine/entities/yard.entity';
@@ -7,11 +8,11 @@ import { TrainSet } from '../../train-sets/entities/train-set.entity';
 import { TrainScheduleBooking } from './train-schedule-booking.entity';

 export const TRAIN_SCHEDULE_STATUSES = [
-  'DRAFT',
-  'SCHEDULED',
-  'DISPATCHED',
-  'ARRIVED',
-  'CANCELLED',
+  TrainScheduleStatusEnum.Draft,
+  TrainScheduleStatusEnum.Scheduled,
+  TrainScheduleStatusEnum.Dispatched,
+  TrainScheduleStatusEnum.Arrived,
+  TrainScheduleStatusEnum.Cancelled,
 ] as const;

 export type TrainScheduleStatus = (typeof TRAIN_SCHEDULE_STATUSES)[number];
@@ -57,6 +58,27 @@ export class TrainSchedule extends BaseEntity {
  @Column({ name: 'status', type: 'varchar', length: 20, default: 'DRAFT' })
  status!: TrainScheduleStatus;

+  @Column({ name: 'train_number', type: 'varchar', length: 20, nullable: true })
+  trainNumber?: string | null;
+
+  @Column({ name: 'direction', type: 'varchar', length: 10, nullable: true })
+  direction?: string | null;
+
+  @Column({ name: 'actual_departure_at', type: 'timestamptz', nullable: true })
+  actualDepartureAt?: Date | null;
+
+  @Column({ name: 'actual_arrival_at', type: 'timestamptz', nullable: true })
+  actualArrivalAt?: Date | null;
+
+  @Column({ name: 'prepared_by_user_id', type: 'uuid', nullable: true })
+  preparedByUserId?: string | null;
+
+  @Column({ name: 'checked_by_user_id', type: 'uuid', nullable: true })
+  checkedByUserId?: string | null;
+
+  @Column({ name: 'max_wagons', type: 'int', default: 53 })
+  maxWagons!: number;
+
  @OneToMany(() => TrainScheduleBooking, (scheduleBooking) => scheduleBooking.trainSchedule)
  scheduleBookings?: TrainScheduleBooking[];
 }
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/wagon-allocation-bulk-load.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/wagon-allocation-bulk-load.entity.ts
@@ -0,0 +1,53 @@
+import { BaseEntity } from '@edr/api-common';
+import { BulkPricingUnit } from '@edr/types';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Booking } from '../../bookings/entities/booking.entity';
+import { CargoType } from '../../rule-engine/entities/cargo-type.entity';
+import { WagonBookingAllocation } from './wagon-booking-allocation.entity';
+
+export const BULK_PRICING_UNITS = [
+  BulkPricingUnit.PerWagon,
+  BulkPricingUnit.PerTon,
+  BulkPricingUnit.PerItem,
+] as const;
+
+@Entity({ schema: 'freight', name: 'wagon_allocation_bulk_loads' })
+@Index(['bookingId'])
+export class WagonAllocationBulkLoad extends BaseEntity {
+  @Column({ name: 'wagon_booking_allocation_id', type: 'uuid', unique: true })
+  wagonBookingAllocationId!: string;
+
+  @ManyToOne(() => WagonBookingAllocation, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'wagon_booking_allocation_id' })
+  allocation?: WagonBookingAllocation;
+
+  @Column({ name: 'booking_id', type: 'uuid' })
+  bookingId!: string;
+
+  @ManyToOne(() => Booking)
+  @JoinColumn({ name: 'booking_id' })
+  booking?: Booking;
+
+  @Column({ name: 'cargo_type_id', type: 'uuid', nullable: true })
+  cargoTypeId?: string | null;
+
+  @ManyToOne(() => CargoType, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'cargo_type_id' })
+  cargoType?: CargoType | null;
+
+  @Column({ name: 'cargo_description', type: 'text', nullable: true })
+  cargoDescription?: string | null;
+
+  @Column({ name: 'pricing_unit', type: 'varchar', length: 20, default: BulkPricingUnit.PerTon })
+  pricingUnit!: string;
+
+  @Column({ name: 'quantity', type: 'numeric', precision: 12, scale: 3, default: 0 })
+  quantity!: number;
+
+  @Column({ name: 'weight_tons', type: 'numeric', precision: 10, scale: 3, default: 0 })
+  weightTons!: number;
+
+  @Column({ name: 'truck_plate_number', type: 'varchar', length: 32, nullable: true })
+  truckPlateNumber?: string | null;
+}
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/wagon-allocation-container-item.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/wagon-allocation-container-item.entity.ts
@@ -0,0 +1,54 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { BookingContainer } from '../../bookings/entities/booking-container.entity';
+import { Container } from '../../container-management/entities/container.entity';
+import { ContainerType } from '../../rule-engine/entities/container-type.entity';
+import { WagonBookingAllocation } from './wagon-booking-allocation.entity';
+
+@Entity({ schema: 'freight', name: 'wagon_allocation_container_items' })
+@Index(['wagonBookingAllocationId'])
+export class WagonAllocationContainerItem extends BaseEntity {
+  @Column({ name: 'wagon_booking_allocation_id', type: 'uuid' })
+  wagonBookingAllocationId!: string;
+
+  @ManyToOne(() => WagonBookingAllocation, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'wagon_booking_allocation_id' })
+  allocation?: WagonBookingAllocation;
+
+  @Column({ name: 'booking_container_id', type: 'uuid', nullable: true })
+  bookingContainerId?: string | null;
+
+  @ManyToOne(() => BookingContainer, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'booking_container_id' })
+  bookingContainer?: BookingContainer | null;
+
+  @Column({ name: 'container_id', type: 'uuid', nullable: true })
+  containerId?: string | null;
+
+  @ManyToOne(() => Container, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'container_id' })
+  container?: Container | null;
+
+  @Column({ name: 'container_number', type: 'varchar', length: 64, nullable: true })
+  containerNumber?: string | null;
+
+  @Column({ name: 'container_type_id', type: 'uuid', nullable: true })
+  containerTypeId?: string | null;
+
+  @ManyToOne(() => ContainerType, { nullable: true })
+  @JoinColumn({ name: 'container_type_id' })
+  containerType?: ContainerType | null;
+
+  @Column({ name: 'position_on_wagon', type: 'smallint', nullable: true })
+  positionOnWagon?: number | null;
+
+  @Column({ name: 'seal_number', type: 'varchar', length: 64, nullable: true })
+  sealNumber?: string | null;
+
+  @Column({ name: 'chassis_number', type: 'varchar', length: 64, nullable: true })
+  chassisNumber?: string | null;
+
+  @Column({ name: 'gross_weight_tons', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  grossWeightTons?: number | null;
+}
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/wagon-booking-allocation.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/wagon-booking-allocation.entity.ts
@@ -1,8 +1,22 @@
 import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { AllocationLoadType, AllocationStatus } from '@edr/types';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';

 import { Booking } from '../../bookings/entities/booking.entity';
 import { TrainSetWagon } from '../../train-sets/entities/train-set-wagon.entity';
+import { WagonAllocationContainerItem } from './wagon-allocation-container-item.entity';
+
+export const ALLOCATION_LOAD_TYPES = [
+  AllocationLoadType.Container,
+  AllocationLoadType.Bulk,
+] as const;
+
+export const ALLOCATION_STATUSES = [
+  AllocationStatus.Planned,
+  AllocationStatus.Reserved,
+  AllocationStatus.Loaded,
+  AllocationStatus.Departed,
+] as const;

@Entity({ schema: 'freight', name: 'wagon_booking_allocations' })
@Index(['trainSetWagonId', 'bookingId'])
@@ -23,4 +37,19 @@ export class WagonBookingAllocation extends BaseEntity {

  @Column({ name: 'allocated_weight_tons', type: 'numeric', precision: 10, scale: 3 })
  allocatedWeightTons!: number;
+
+  @Column({ name: 'load_type', type: 'varchar', length: 20, nullable: true })
+  loadType?: string | null;
+
+  @Column({ name: 'status', type: 'varchar', length: 20, default: 'PLANNED' })
+  status!: string;
+
+  @Column({ name: 'confirmed_at', type: 'timestamptz', nullable: true })
+  confirmedAt?: Date | null;
+
+  @Column({ name: 'confirmed_by_user_id', type: 'uuid', nullable: true })
+  confirmedByUserId?: string | null;
+
+  @OneToMany(() => WagonAllocationContainerItem, (item) => item.allocation)
+  containerItems?: WagonAllocationContainerItem[];
 }
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts
@@ -1,7 +1,7 @@
 import { BaseRepository } from '@edr/api-common';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { DeepPartial, EntityManager, In, Repository } from 'typeorm';

 import { TrainScheduleBooking } from './entities/train-schedule-booking.entity';

@@ -13,4 +13,38 @@ export class TrainScheduleBookingsRepository extends BaseRepository<TrainSchedul
  ) {
    super(repository);
  }
+
+  private repo(manager?: EntityManager) {
+    return manager ? manager.getRepository(TrainScheduleBooking) : this.repository;
+  }
+
+  async createMany(
+    records: DeepPartial<TrainScheduleBooking>[],
+    manager?: EntityManager,
+  ): Promise<TrainScheduleBooking[]> {
+    if (!records.length) return [];
+    const repo = this.repo(manager);
+    return repo.save(repo.create(records));
+  }
+
+  async deleteByScheduleAndBooking(
+    trainScheduleId: string,
+    bookingId: string,
+    manager?: EntityManager,
+  ): Promise<void> {
+    await this.repo(manager).delete({ trainScheduleId, bookingId });
+  }
+
+  async existsForBooking(bookingId: string, manager?: EntityManager): Promise<boolean> {
+    const count = await this.repo(manager).count({ where: { bookingId } });
+    return count > 0;
+  }
+
+  findByBookingIds(bookingIds: string[], manager?: EntityManager): Promise<TrainScheduleBooking[]> {
+    if (!bookingIds.length) return Promise.resolve([]);
+    return this.repo(manager).find({
+      where: { bookingId: In(bookingIds) },
+      select: { id: true, bookingId: true, trainScheduleId: true },
+    });
+  }
 }
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.module.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.module.ts
@@ -3,22 +3,38 @@ import { TypeOrmModule } from '@nestjs/typeorm';

 import { TrainScheduleBooking } from './entities/train-schedule-booking.entity';
 import { TrainSchedule } from './entities/train-schedule.entity';
+import { WagonAllocationBulkLoad } from './entities/wagon-allocation-bulk-load.entity';
+import { WagonAllocationContainerItem } from './entities/wagon-allocation-container-item.entity';
 import { WagonBookingAllocation } from './entities/wagon-booking-allocation.entity';
 import { TrainScheduleBookingsRepository } from './train-schedule-bookings.repository';
 import { TrainSchedulesRepository } from './train-schedules.repository';
+import { WagonAllocationBulkLoadsRepository } from './wagon-allocation-bulk-loads.repository';
+import { WagonAllocationContainerItemsRepository } from './wagon-allocation-container-items.repository';
 import { WagonBookingAllocationsRepository } from './wagon-booking-allocations.repository';

@Module({
-  imports: [TypeOrmModule.forFeature([TrainSchedule, TrainScheduleBooking, WagonBookingAllocation])],
+  imports: [
+    TypeOrmModule.forFeature([
+      TrainSchedule,
+      TrainScheduleBooking,
+      WagonBookingAllocation,
+      WagonAllocationContainerItem,
+      WagonAllocationBulkLoad,
+    ]),
+  ],
  providers: [
    TrainSchedulesRepository,
    TrainScheduleBookingsRepository,
    WagonBookingAllocationsRepository,
+    WagonAllocationContainerItemsRepository,
+    WagonAllocationBulkLoadsRepository,
  ],
  exports: [
    TrainSchedulesRepository,
    TrainScheduleBookingsRepository,
    WagonBookingAllocationsRepository,
+    WagonAllocationContainerItemsRepository,
+    WagonAllocationBulkLoadsRepository,
  ],
 })
 export class TrainSchedulesModule {}
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
@@ -1,9 +1,9 @@
 import { BaseRepository } from '@edr/api-common';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { EntityManager, Repository } from 'typeorm';

-import { TrainSchedule } from './entities/train-schedule.entity';
+import { TrainSchedule, TrainScheduleStatus } from './entities/train-schedule.entity';

@Injectable()
 export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
@@ -13,4 +13,48 @@ export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
  ) {
    super(repository);
  }
+
+  private repo(manager?: EntityManager) {
+    return manager ? manager.getRepository(TrainSchedule) : this.repository;
+  }
+
+  findByIdWithFullGraph(id: string, manager?: EntityManager): Promise<TrainSchedule | null> {
+    return this.repo(manager).findOne({
+      where: { id },
+      relations: {
+        route: true,
+        trainSet: {
+          locomotive: true,
+          wagons: {
+            wagonType: true,
+            physicalWagon: true,
+            allocations: {
+              booking: { company: true, bookingContainers: { containerType: true } },
+              containerItems: true,
+            },
+          },
+        },
+        originStation: true,
+        destinationStation: true,
+        scheduleBookings: {
+          booking: {
+            company: true,
+            originYard: true,
+            destinationYard: true,
+            bookingContainers: { containerType: true },
+            cargoType: true,
+          },
+        },
+      },
+    });
+  }
+
+  async updateStatus(
+    id: string,
+    status: TrainScheduleStatus,
+    extra?: Partial<TrainSchedule>,
+    manager?: EntityManager,
+  ): Promise<void> {
+    await this.repo(manager).update(id, { status, ...extra } as never);
+  }
 }
--- a/apps/edr-freight-api/src/modules/train-schedules/wagon-allocation-bulk-loads.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/wagon-allocation-bulk-loads.repository.ts
@@ -0,0 +1,36 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DeepPartial, EntityManager, In, Repository } from 'typeorm';
+
+import { WagonAllocationBulkLoad } from './entities/wagon-allocation-bulk-load.entity';
+
+@Injectable()
+export class WagonAllocationBulkLoadsRepository extends BaseRepository<WagonAllocationBulkLoad> {
+  constructor(
+    @InjectRepository(WagonAllocationBulkLoad)
+    repository: Repository<WagonAllocationBulkLoad>,
+  ) {
+    super(repository);
+  }
+
+  private repo(manager?: EntityManager) {
+    return manager
+      ? manager.getRepository(WagonAllocationBulkLoad)
+      : this.repository;
+  }
+
+  async createMany(
+    items: DeepPartial<WagonAllocationBulkLoad>[],
+    manager?: EntityManager,
+  ): Promise<WagonAllocationBulkLoad[]> {
+    if (!items.length) return [];
+    const repo = this.repo(manager);
+    return repo.save(repo.create(items));
+  }
+
+  async deleteByAllocationIds(allocationIds: string[], manager?: EntityManager): Promise<void> {
+    if (!allocationIds.length) return;
+    await this.repo(manager).delete({ wagonBookingAllocationId: In(allocationIds) });
+  }
+}
--- a/apps/edr-freight-api/src/modules/train-schedules/wagon-allocation-container-items.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/wagon-allocation-container-items.repository.ts
@@ -0,0 +1,36 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DeepPartial, EntityManager, In, Repository } from 'typeorm';
+
+import { WagonAllocationContainerItem } from './entities/wagon-allocation-container-item.entity';
+
+@Injectable()
+export class WagonAllocationContainerItemsRepository extends BaseRepository<WagonAllocationContainerItem> {
+  constructor(
+    @InjectRepository(WagonAllocationContainerItem)
+    repository: Repository<WagonAllocationContainerItem>,
+  ) {
+    super(repository);
+  }
+
+  private repo(manager?: EntityManager) {
+    return manager
+      ? manager.getRepository(WagonAllocationContainerItem)
+      : this.repository;
+  }
+
+  async createMany(
+    items: DeepPartial<WagonAllocationContainerItem>[],
+    manager?: EntityManager,
+  ): Promise<WagonAllocationContainerItem[]> {
+    if (!items.length) return [];
+    const repo = this.repo(manager);
+    return repo.save(repo.create(items));
+  }
+
+  async deleteByAllocationIds(allocationIds: string[], manager?: EntityManager): Promise<void> {
+    if (!allocationIds.length) return;
+    await this.repo(manager).delete({ wagonBookingAllocationId: In(allocationIds) });
+  }
+}
--- a/apps/edr-freight-api/src/modules/train-schedules/wagon-booking-allocations.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/wagon-booking-allocations.repository.ts
@@ -1,7 +1,7 @@
 import { BaseRepository } from '@edr/api-common';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { DeepPartial, EntityManager, Repository } from 'typeorm';

 import { WagonBookingAllocation } from './entities/wagon-booking-allocation.entity';

@@ -13,4 +13,43 @@ export class WagonBookingAllocationsRepository extends BaseRepository<WagonBooki
  ) {
    super(repository);
  }
+
+  private repo(manager?: EntityManager) {
+    return manager ? manager.getRepository(WagonBookingAllocation) : this.repository;
+  }
+
+  async createMany(
+    records: DeepPartial<WagonBookingAllocation>[],
+    manager?: EntityManager,
+  ): Promise<WagonBookingAllocation[]> {
+    if (!records.length) return [];
+    const repo = this.repo(manager);
+    return repo.save(repo.create(records));
+  }
+
+  findByScheduleId(trainScheduleId: string, manager?: EntityManager): Promise<WagonBookingAllocation[]> {
+    return this.repo(manager)
+      .createQueryBuilder('allocation')
+      .innerJoin('allocation.trainSetWagon', 'wagon')
+      .innerJoin('wagon.trainSet', 'trainSet')
+      .innerJoin('trainSet.trainSchedule', 'schedule')
+      .where('schedule.id = :trainScheduleId', { trainScheduleId })
+      .leftJoinAndSelect('allocation.booking', 'booking')
+      .getMany();
+  }
+
+  async deleteByTrainSetId(trainSetId: string, manager?: EntityManager): Promise<string[]> {
+    const allocations = await this.repo(manager)
+      .createQueryBuilder('allocation')
+      .innerJoin('allocation.trainSetWagon', 'wagon')
+      .where('wagon.train_set_id = :trainSetId', { trainSetId })
+      .select(['allocation.id'])
+      .getMany();
+
+    const ids = allocations.map((a) => a.id);
+    if (ids.length) {
+      await this.repo(manager).delete(ids);
+    }
+    return ids;
+  }
 }
--- a/apps/edr-freight-api/src/modules/train-scheduling/derive-schedule-direction.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/derive-schedule-direction.util.spec.ts
@@ -0,0 +1,21 @@
+import { deriveScheduleDirection } from './derive-schedule-direction.util';
+
+describe('deriveScheduleDirection', () => {
+  it('returns IMPORT when origin is Djibouti', () => {
+    expect(
+      deriveScheduleDirection({ country: 'Djibouti' }, { country: 'Ethiopia' }),
+    ).toBe('IMPORT');
+  });
+
+  it('returns EXPORT when destination is Djibouti and origin is not', () => {
+    expect(
+      deriveScheduleDirection({ country: 'Ethiopia' }, { country: 'Djibouti' }),
+    ).toBe('EXPORT');
+  });
+
+  it('returns DOMESTIC for intra-Ethiopia routes', () => {
+    expect(
+      deriveScheduleDirection({ country: 'Ethiopia' }, { country: 'Ethiopia' }),
+    ).toBe('DOMESTIC');
+  });
+});
--- a/apps/edr-freight-api/src/modules/train-scheduling/derive-schedule-direction.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/derive-schedule-direction.util.ts
@@ -0,0 +1,19 @@
+import type { ScheduleTradeDirection } from '@edr/types';
+
+type YardLike = { country?: string | null };
+
+export function deriveScheduleDirection(
+  originYard: YardLike,
+  destinationYard: YardLike,
+): ScheduleTradeDirection {
+  const originCountry = originYard.country?.trim();
+  const destinationCountry = destinationYard.country?.trim();
+
+  if (originCountry === 'Djibouti') {
+    return 'IMPORT';
+  }
+  if (destinationCountry === 'Djibouti' && originCountry !== 'Djibouti') {
+    return 'EXPORT';
+  }
+  return 'DOMESTIC';
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/assign-bookings.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/assign-bookings.dto.ts
@@ -0,0 +1,86 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsBoolean,
+  IsInt,
+  IsNumber,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+
+export class ContainerPlacementDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  bookingContainerId!: string;
+
+  @ApiProperty({ minimum: 0 })
+  @IsInt()
+  @Min(0)
+  unitIndex!: number;
+
+  @ApiProperty({ minimum: 1 })
+  @IsInt()
+  @Min(1)
+  sequenceNo!: number;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  containerId?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  containerNumber?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  sealNumber?: string;
+}
+
+export class AssignBookingsDto {
+  @ApiProperty({ type: [String] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('4', { each: true })
+  bookingIds!: string[];
+
+  @ApiPropertyOptional({ description: 'Bypass soft hold and overweight warnings' })
+  @IsOptional()
+  @IsBoolean()
+  forceAssign?: boolean;
+
+  @ApiPropertyOptional({ type: [ContainerPlacementDto] })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => ContainerPlacementDto)
+  containerPlacements?: ContainerPlacementDto[];
+
+  @ApiPropertyOptional({ description: 'Maximum total booking weight allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainWeightTons?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum total wagon length allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainLengthMeters?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum wagons allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  maxWagonsPerTrain?: number;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
@@ -1,5 +1,6 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsDateString, IsUUID } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsDateString, IsInt, IsNumber, IsOptional, IsUUID, Min } from 'class-validator';

 export class CreateContainerTrainScheduleDto {
  @ApiProperty({ format: 'uuid' })
@@ -13,4 +14,25 @@ export class CreateContainerTrainScheduleDto {
  @ApiProperty({ format: 'uuid' })
  @IsUUID()
  locomotiveId!: string;
+
+  @ApiPropertyOptional({ description: 'Maximum total booking weight allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainWeightTons?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum total wagon length allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainLengthMeters?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum wagons allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  maxWagonsPerTrain?: number;
 }
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/get-eligible-bookings.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/get-eligible-bookings.dto.ts
@@ -0,0 +1,23 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsIn, IsOptional, IsUUID } from 'class-validator';
+
+export class GetEligibleBookingsDto {
+  @ApiPropertyOptional({ enum: ['CONTAINER', 'BULK'] })
+  @IsOptional()
+  @IsIn(['CONTAINER', 'BULK'])
+  freightType?: 'CONTAINER' | 'BULK';
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  originStationId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  destinationStationId?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  schedulingStatus?: string;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/get-eligible-bulk-bookings.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/get-eligible-bulk-bookings.dto.ts
@@ -0,0 +1,18 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsUUID } from 'class-validator';
+
+export class GetEligibleBulkBookingsDto {
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  originStationId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  destinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'HOLDING' })
+  @IsOptional()
+  schedulingStatus?: string;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/get-eligible-container-bookings.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/get-eligible-container-bookings.dto.ts
@@ -1,5 +1,5 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsDateString, IsOptional, IsUUID } from 'class-validator';
+import { IsOptional, IsUUID } from 'class-validator';

 export class GetEligibleContainerBookingsDto {
  @ApiPropertyOptional({ format: 'uuid' })
@@ -12,8 +12,7 @@ export class GetEligibleContainerBookingsDto {
  @IsUUID()
  destinationStationId?: string;

-  @ApiPropertyOptional({ example: '2026-06-20T08:00:00.000Z' })
+  @ApiPropertyOptional({ example: 'HOLDING' })
  @IsOptional()
-  @IsDateString()
-  scheduleDate?: string;
+  schedulingStatus?: string;
 }
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/pin-wagons.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/pin-wagons.dto.ts
@@ -0,0 +1,22 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsUUID, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class PinWagonAssignmentDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  trainSetWagonId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  physicalWagonId!: string;
+}
+
+export class PinWagonsDto {
+  @ApiProperty({ type: [PinWagonAssignmentDto] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => PinWagonAssignmentDto)
+  assignments!: PinWagonAssignmentDto[];
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/preview-bulk-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/preview-bulk-train-schedule.dto.ts
@@ -0,0 +1,3 @@
+import { PreviewTrainScheduleDto } from './preview-train-schedule.dto';
+
+export class PreviewBulkTrainScheduleDto extends PreviewTrainScheduleDto {}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/preview-container-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/preview-container-train-schedule.dto.ts
@@ -1,22 +1,3 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { ArrayMinSize, IsArray, IsDateString, IsUUID } from 'class-validator';
+import { PreviewTrainScheduleDto } from './preview-train-schedule.dto';

-export class PreviewContainerTrainScheduleDto {
-  @ApiProperty({ type: [String] })
-  @IsArray()
-  @ArrayMinSize(1)
-  @IsUUID('4', { each: true })
-  bookingIds!: string[];
-
-  @ApiProperty({ example: '2026-06-20T08:00:00.000Z' })
-  @IsDateString()
-  scheduleDate!: string;
-
-  @ApiProperty({ format: 'uuid' })
-  @IsUUID()
-  originStationId!: string;
-
-  @ApiProperty({ format: 'uuid' })
-  @IsUUID()
-  destinationStationId!: string;
-}
+export class PreviewContainerTrainScheduleDto extends PreviewTrainScheduleDto {}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/preview-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/preview-train-schedule.dto.ts
@@ -0,0 +1,61 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsDateString,
+  IsInt,
+  IsNumber,
+  IsOptional,
+  IsUUID,
+  Min,
+} from 'class-validator';
+
+export class PreviewTrainScheduleDto {
+  @ApiProperty({ type: [String] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('4', { each: true })
+  bookingIds!: string[];
+
+  @ApiProperty({ example: '2026-06-20T08:00:00.000Z' })
+  @IsDateString()
+  scheduleDate!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  originStationId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  destinationStationId!: string;
+
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description: 'Allow bookings already assigned to this schedule (re-assign / reschedule)',
+  })
+  @IsOptional()
+  @IsUUID()
+  targetScheduleId?: string;
+
+  @ApiPropertyOptional({ description: 'Maximum total booking weight allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainWeightTons?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum total wagon length allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainLengthMeters?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum wagons allowed on this train' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  maxWagonsPerTrain?: number;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/update-train-scheduling-global-rules.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/update-train-scheduling-global-rules.dto.ts
@@ -0,0 +1,40 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsInt, IsNumber, IsOptional, Min } from 'class-validator';
+
+export class UpdateTrainSchedulingGlobalRulesDto {
+  @ApiPropertyOptional({ example: 760 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainLengthMeters?: number;
+
+  @ApiPropertyOptional({ example: 3500 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  maxTrainWeightTons?: number;
+
+  @ApiPropertyOptional({ example: 53 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  maxWagonsPerTrain?: number;
+
+  @ApiPropertyOptional({ example: 30 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(0.001)
+  max20ftContainerWeightTons?: number;
+
+  @ApiPropertyOptional({ example: 10 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(0)
+  max20ftPairWeightDiffTons?: number;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/entities/train-scheduling-global-rules.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/entities/train-scheduling-global-rules.entity.ts
@@ -0,0 +1,44 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ schema: 'freight', name: 'train_scheduling_global_rules' })
+export class TrainSchedulingGlobalRules extends BaseEntity {
+  @Column({
+    name: 'max_train_length_meters',
+    type: 'numeric',
+    precision: 10,
+    scale: 2,
+    default: 760,
+  })
+  maxTrainLengthMeters!: number;
+
+  @Column({
+    name: 'max_train_weight_tons',
+    type: 'numeric',
+    precision: 10,
+    scale: 3,
+    default: 3500,
+  })
+  maxTrainWeightTons!: number;
+
+  @Column({ name: 'max_wagons_per_train', type: 'int', default: 53 })
+  maxWagonsPerTrain!: number;
+
+  @Column({
+    name: 'max_20ft_container_weight_tons',
+    type: 'numeric',
+    precision: 8,
+    scale: 3,
+    default: 30,
+  })
+  max20ftContainerWeightTons!: number;
+
+  @Column({
+    name: 'max_20ft_pair_weight_diff_tons',
+    type: 'numeric',
+    precision: 8,
+    scale: 3,
+    default: 10,
+  })
+  max20ftPairWeightDiffTons!: number;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.spec.ts
@@ -0,0 +1,127 @@
+import { Booking } from '../bookings/entities/booking.entity';
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import {
+  computeFleetAvailability,
+  selectBookingsWithinFleetCap,
+  sortBookingsForScheduling,
+  summarizeFleetWarnings,
+  wagonsRequiredForBooking,
+} from './fleet-plan.util';
+import { buildContainerWagonPlan, type WagonPlanSlot } from './wagon-plan.util';
+
+const nw5: WagonType = {
+  id: 'wt-nw5',
+  code: 'NW5',
+  name: 'Flat Wagon',
+  capacityTons: 70,
+  lengthMeters: 14,
+  maxWagonsPerTrain: 53,
+  supportedLoadTypes: ['CONTAINER'],
+  isActive: true,
+  supportsContainer: true,
+} as WagonType;
+
+const makeBooking = (
+  id: string,
+  extra: Partial<Booking> = {},
+): Booking =>
+  ({
+    id,
+    reference: id,
+    freightType: 'CONTAINER',
+    isGovernment: false,
+    priorityScore: 0,
+    scheduledDate: new Date('2026-06-20T08:00:00.000Z'),
+    cargoTotalWeightVgm: 50,
+    bookingContainers: [{ id: `${id}-line`, quantity: 2, wagonsRequired: 1, vgmPerUnitTons: 25 }],
+    ...extra,
+  }) as Booking;
+
+describe('fleet-plan.util', () => {
+  it('sorts bookings government first, then priority, then date', () => {
+    const bookings = [
+      makeBooking('late', { scheduledDate: new Date('2026-06-22T08:00:00.000Z') }),
+      makeBooking('gov', { isGovernment: true, priorityScore: 0 }),
+      makeBooking('prio', { priorityScore: 10 }),
+    ];
+
+    const sorted = sortBookingsForScheduling(bookings);
+    expect(sorted.map((b) => b.id)).toEqual(['gov', 'prio', 'late']);
+  });
+
+  it('computes fleet availability with shortfall', () => {
+    const plan: WagonPlanSlot[] = buildContainerWagonPlan(
+      [
+        makeBooking('b1', {
+          bookingContainers: [
+            { id: 'b1-line', quantity: 4, wagonsRequired: 2, vgmPerUnitTons: 25 } as never,
+          ],
+        }),
+      ],
+      nw5,
+    );
+    const fleetByTypeId = new Map([[nw5.id, 1]]);
+
+    const rows = computeFleetAvailability(plan, fleetByTypeId, new Map([[nw5.id, 'NW5']]));
+    const nw5Row = rows.find((r) => r.wagonTypeCode === 'NW5');
+
+    expect(nw5Row?.needed).toBe(2);
+    expect(nw5Row?.available).toBe(1);
+    expect(nw5Row?.shortfall).toBe(1);
+  });
+
+  it('defers lower-priority bookings when fleet is insufficient', () => {
+    const high = makeBooking('high', {
+      priorityScore: 100,
+      bookingContainers: [
+        { id: 'high-line', quantity: 2, wagonsRequired: 2, vgmPerUnitTons: 25 } as never,
+      ],
+    });
+    const low = makeBooking('low', {
+      priorityScore: 1,
+      bookingContainers: [
+        { id: 'low-line', quantity: 2, wagonsRequired: 2, vgmPerUnitTons: 25 } as never,
+      ],
+    });
+    const fleet = new Map([[nw5.id, 2]]);
+
+    const { fitting, deferred } = selectBookingsWithinFleetCap(
+      [low, high],
+      fleet,
+      () => nw5.id,
+    );
+
+    expect(fitting.map((b) => b.id)).toEqual(['high']);
+    expect(deferred).toHaveLength(1);
+    expect(deferred[0]?.id).toBe('low');
+    expect(deferred[0]?.reason).toContain('2');
+  });
+
+  it('summarizes fleet shortage warnings', () => {
+    const warnings = summarizeFleetWarnings(
+      [
+        {
+          wagonTypeId: nw5.id,
+          wagonTypeCode: 'NW5',
+          needed: 5,
+          available: 2,
+          shortfall: 3,
+        },
+      ],
+      [{ id: 'b1', reference: 'BKG-1', reason: 'No wagons' }],
+    );
+
+    expect(warnings.some((w) => w.includes('Fleet shortage'))).toBe(true);
+    expect(warnings.some((w) => w.includes('deferred'))).toBe(true);
+  });
+
+  it('counts wagons required per booking from container lines', () => {
+    const booking = makeBooking('b1', {
+      bookingContainers: [
+        { id: 'b1-line-0', quantity: 2, wagonsRequired: 1, vgmPerUnitTons: 25 } as never,
+        { id: 'b1-line-1', quantity: 1, wagonsRequired: 1, vgmPerUnitTons: 25 } as never,
+      ],
+    });
+    expect(wagonsRequiredForBooking(booking)).toBe(2);
+  });
+});
--- a/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
@@ -0,0 +1,168 @@
+import type { Booking } from '../bookings/entities/booking.entity';
+import type { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import {
+  buildBulkWagonPlan,
+  buildContainerWagonPlan,
+  buildMixedWagonPlan,
+  roundTons,
+  type WagonPlanSlot,
+} from './wagon-plan.util';
+
+export type FleetAvailabilityRow = {
+  wagonTypeId: string;
+  wagonTypeCode: string;
+  needed: number;
+  available: number;
+  shortfall: number;
+};
+
+export type DeferredBookingRow = {
+  id: string;
+  reference: string;
+  reason: string;
+};
+
+export function sortBookingsForScheduling(bookings: Booking[]): Booking[] {
+  return [...bookings].sort((a, b) => {
+    const govDiff = Number(Boolean(b.isGovernment)) - Number(Boolean(a.isGovernment));
+    if (govDiff !== 0) return govDiff;
+
+    const priorityDiff = (b.priorityScore ?? 0) - (a.priorityScore ?? 0);
+    if (priorityDiff !== 0) return priorityDiff;
+
+    return new Date(a.scheduledDate).getTime() - new Date(b.scheduledDate).getTime();
+  });
+}
+
+export function wagonsRequiredForBooking(booking: Booking, bulkWagonCapacity?: number): number {
+  if (booking.freightType === 'BULK') {
+    const weight = Number(booking.cargoTotalWeightVgm ?? 0);
+    const capacity = bulkWagonCapacity && bulkWagonCapacity > 0 ? bulkWagonCapacity : 1;
+    return Math.max(1, Math.ceil(weight / capacity));
+  }
+
+  const lineSlots = (booking.bookingContainers ?? []).reduce(
+    (sum, line) => sum + Number(line.wagonsRequired ?? 0),
+    0,
+  );
+  return Math.max(1, lineSlots);
+}
+
+export function countSlotsByType(wagonPlan: WagonPlanSlot[]): Map<string, { code: string; count: number }> {
+  const map = new Map<string, { code: string; count: number }>();
+  for (const slot of wagonPlan) {
+    const existing = map.get(slot.wagonTypeId) ?? { code: slot.wagonTypeCode, count: 0 };
+    existing.count += 1;
+    map.set(slot.wagonTypeId, existing);
+  }
+  return map;
+}
+
+export function computeFleetAvailability(
+  demandPlan: WagonPlanSlot[],
+  fleetByTypeId: Map<string, number>,
+  fleetTypeCodes: Map<string, string>,
+): FleetAvailabilityRow[] {
+  const neededByType = countSlotsByType(demandPlan);
+  const typeIds = new Set([...neededByType.keys(), ...fleetByTypeId.keys()]);
+
+  return [...typeIds].map((wagonTypeId) => {
+    const needed = neededByType.get(wagonTypeId)?.count ?? 0;
+    const available = fleetByTypeId.get(wagonTypeId) ?? 0;
+    return {
+      wagonTypeId,
+      wagonTypeCode:
+        neededByType.get(wagonTypeId)?.code ??
+        fleetTypeCodes.get(wagonTypeId) ??
+        wagonTypeId,
+      needed,
+      available,
+      shortfall: Math.max(0, needed - available),
+    };
+  }).filter((row) => row.needed > 0 || row.available > 0);
+}
+
+export function selectBookingsWithinFleetCap(
+  bookings: Booking[],
+  fleetByTypeId: Map<string, number>,
+  resolveWagonTypeId: (booking: Booking) => string,
+  bulkWagonCapacity?: number,
+): { fitting: Booking[]; deferred: DeferredBookingRow[] } {
+  const remaining = new Map(fleetByTypeId);
+  const fitting: Booking[] = [];
+  const deferred: DeferredBookingRow[] = [];
+
+  for (const booking of sortBookingsForScheduling(bookings)) {
+    const typeId = resolveWagonTypeId(booking);
+    const needed = wagonsRequiredForBooking(booking, bulkWagonCapacity);
+    const available = remaining.get(typeId) ?? 0;
+
+    if (available >= needed) {
+      remaining.set(typeId, available - needed);
+      fitting.push(booking);
+      continue;
+    }
+
+    deferred.push({
+      id: booking.id,
+      reference: booking.reference,
+      reason:
+        available > 0
+          ? `Needs ${needed} wagons but only ${available} available for this type`
+          : `No available wagons for required type (${needed} needed)`,
+    });
+  }
+
+  return { fitting, deferred };
+}
+
+export function buildCappedWagonPlan(params: {
+  bookings: Booking[];
+  resolvedMode: 'CONTAINER' | 'BULK' | 'MIXED';
+  containerWagonType: WagonType;
+  bulkWagonType: WagonType;
+}): WagonPlanSlot[] {
+  const { bookings, resolvedMode, containerWagonType, bulkWagonType } = params;
+
+  if (resolvedMode === 'MIXED') {
+    const containerBookings = bookings.filter((b) => b.freightType === 'CONTAINER');
+    const bulkBookings = bookings.filter((b) => b.freightType === 'BULK');
+    return buildMixedWagonPlan(
+      containerBookings,
+      bulkBookings,
+      containerWagonType,
+      bulkWagonType,
+    );
+  }
+
+  if (resolvedMode === 'BULK') {
+    return buildBulkWagonPlan(bookings, bulkWagonType);
+  }
+
+  return buildContainerWagonPlan(bookings, containerWagonType);
+}
+
+export function summarizeFleetWarnings(
+  fleetAvailability: FleetAvailabilityRow[],
+  deferred: DeferredBookingRow[],
+): string[] {
+  const warnings: string[] = [];
+
+  for (const row of fleetAvailability.filter((r) => r.shortfall > 0)) {
+    warnings.push(
+      `Fleet shortage: need ${row.needed} ${row.wagonTypeCode}, only ${row.available} available (short ${row.shortfall})`,
+    );
+  }
+
+  if (deferred.length) {
+    warnings.push(
+      `${deferred.length} booking(s) deferred to next train due to insufficient fleet wagons`,
+    );
+  }
+
+  return warnings;
+}
+
+export function totalAssignedWeight(bookings: Booking[]): number {
+  return roundTons(bookings.reduce((sum, b) => sum + Number(b.cargoTotalWeightVgm ?? 0), 0));
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
@@ -1,17 +1,27 @@
 import {
  Body,
  Controller,
+  Delete,
  Get,
  Param,
  ParseUUIDPipe,
+  Patch,
  Post,
  Query,
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';

+import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking-guards';
+import { AssignBookingsDto } from './dto/assign-bookings.dto';
 import { CreateContainerTrainScheduleDto } from './dto/create-container-train-schedule.dto';
+import { GetEligibleBookingsDto } from './dto/get-eligible-bookings.dto';
+import { GetEligibleBulkBookingsDto } from './dto/get-eligible-bulk-bookings.dto';
 import { GetEligibleContainerBookingsDto } from './dto/get-eligible-container-bookings.dto';
+import { PinWagonsDto } from './dto/pin-wagons.dto';
+import { PreviewBulkTrainScheduleDto } from './dto/preview-bulk-train-schedule.dto';
 import { PreviewContainerTrainScheduleDto } from './dto/preview-container-train-schedule.dto';
+import { PreviewTrainScheduleDto } from './dto/preview-train-schedule.dto';
+import { UpdateTrainSchedulingGlobalRulesDto } from './dto/update-train-scheduling-global-rules.dto';
 import { TrainSchedulingService } from './train-scheduling.service';

@ApiTags('train-scheduling')
@@ -20,39 +30,176 @@ import { TrainSchedulingService } from './train-scheduling.service';
 export class TrainSchedulingController {
  constructor(private readonly trainSchedulingService: TrainSchedulingService) {}

+  @Get('global-rules')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'Get global train scheduling rules (singleton)' })
+  getGlobalRules() {
+    return this.trainSchedulingService.getTrainSchedulingGlobalRules();
+  }
+
+  @Patch('global-rules')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Update global train scheduling rules (singleton)' })
+  updateGlobalRules(@Body() dto: UpdateTrainSchedulingGlobalRulesDto) {
+    return this.trainSchedulingService.updateTrainSchedulingGlobalRules(dto);
+  }
+
+  @Get('eligible-bookings')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'List eligible bookings (container and/or bulk)' })
+  getEligibleBookings(@Query() query: GetEligibleBookingsDto) {
+    return this.trainSchedulingService.getEligibleBookings(query);
+  }
+
  @Get('container/eligible-bookings')
+  @TrainSchedulingView()
  @ApiOperation({ summary: 'List eligible container bookings' })
  getEligibleContainerBookings(@Query() query: GetEligibleContainerBookingsDto) {
    return this.trainSchedulingService.getEligibleContainerBookings(query);
  }

+  @Get('bulk/eligible-bookings')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'List eligible bulk bookings' })
+  getEligibleBulkBookings(@Query() query: GetEligibleBulkBookingsDto) {
+    return this.trainSchedulingService.getEligibleBulkBookings(query);
+  }
+
+  @Post('preview')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'Preview a mixed-capable train schedule' })
+  previewTrainSchedule(@Body() dto: PreviewTrainScheduleDto) {
+    return this.trainSchedulingService.previewTrainSchedule(dto);
+  }
+
  @Post('container/preview')
+  @TrainSchedulingView()
  @ApiOperation({ summary: 'Preview a container train schedule' })
  previewContainerTrainSchedule(@Body() dto: PreviewContainerTrainScheduleDto) {
    return this.trainSchedulingService.previewContainerTrainSchedule(dto);
  }

+  @Post('bulk/preview')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'Preview a bulk train schedule' })
+  previewBulkTrainSchedule(@Body() dto: PreviewBulkTrainScheduleDto) {
+    return this.trainSchedulingService.previewBulkTrainSchedule(dto);
+  }
+
  @Post('container/schedules')
+  @TrainSchedulingManage()
  @ApiOperation({ summary: 'Create a container train schedule' })
  createContainerTrainSchedule(@Body() dto: CreateContainerTrainScheduleDto) {
    return this.trainSchedulingService.createContainerTrainSchedule(dto);
  }

+  @Post('bulk/schedules')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Create a bulk train schedule' })
+  createBulkTrainSchedule(@Body() dto: CreateContainerTrainScheduleDto) {
+    return this.trainSchedulingService.createContainerTrainSchedule(dto);
+  }
+
+  @Post('schedules/:id/assign-bookings')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Assign bookings to a train schedule (mixed-capable)' })
+  assignBookings(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: AssignBookingsDto,
+  ) {
+    return this.trainSchedulingService.assignBookingsToSchedule(id, dto);
+  }
+
+  @Post('container/schedules/:id/assign-bookings')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Assign container bookings to a train schedule' })
+  assignContainerBookings(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: AssignBookingsDto,
+  ) {
+    return this.trainSchedulingService.assignBookingsToSchedule(id, dto, 'CONTAINER');
+  }
+
+  @Post('bulk/schedules/:id/assign-bookings')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Assign bulk bookings to a train schedule' })
+  assignBulkBookings(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: AssignBookingsDto,
+  ) {
+    return this.trainSchedulingService.assignBookingsToSchedule(id, dto, 'BULK');
+  }
+
+  @Delete('schedules/:id/bookings/:bookingId')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Unassign a booking from a train schedule' })
+  unassignBooking(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('bookingId', ParseUUIDPipe) bookingId: string,
+  ) {
+    return this.trainSchedulingService.unassignBooking(id, bookingId);
+  }
+
+  @Post('schedules/:id/pin-wagons')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Pin physical wagons to train set slots' })
+  pinWagons(@Param('id', ParseUUIDPipe) id: string, @Body() dto: PinWagonsDto) {
+    return this.trainSchedulingService.pinWagons(id, dto);
+  }
+
+  @Post('schedules/:id/finalize')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Finalize a draft train schedule' })
+  finalizeSchedule(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.finalizeSchedule(id);
+  }
+
+  @Post('schedules/:id/dispatch')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Dispatch a scheduled train' })
+  dispatchSchedule(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.dispatchSchedule(id);
+  }
+
  @Get('container/schedules')
+  @TrainSchedulingView()
  @ApiOperation({ summary: 'List container train schedules' })
  getContainerTrainSchedules() {
    return this.trainSchedulingService.getContainerTrainSchedules();
  }

+  @Get('bulk/schedules')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'List bulk train schedules' })
+  getBulkTrainSchedules() {
+    return this.trainSchedulingService.getContainerTrainSchedules();
+  }
+
  @Get('container/schedules/:id')
+  @TrainSchedulingView()
  @ApiOperation({ summary: 'Get container train schedule detail' })
  getContainerTrainScheduleById(@Param('id', ParseUUIDPipe) id: string) {
    return this.trainSchedulingService.getContainerTrainScheduleById(id);
  }

+  @Get('bulk/schedules/:id')
+  @TrainSchedulingView()
+  @ApiOperation({ summary: 'Get bulk train schedule detail' })
+  getBulkTrainScheduleById(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.getContainerTrainScheduleById(id);
+  }
+
  @Post('container/schedules/:id/cancel')
+  @TrainSchedulingManage()
  @ApiOperation({ summary: 'Cancel container train schedule' })
  cancelTrainSchedule(@Param('id', ParseUUIDPipe) id: string) {
    return this.trainSchedulingService.cancelTrainSchedule(id);
  }
+
+  @Post('bulk/schedules/:id/cancel')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Cancel bulk train schedule' })
+  cancelBulkTrainSchedule(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.cancelTrainSchedule(id);
+  }
 }
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
@@ -2,42 +2,40 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';

 import { BookingsModule } from '../bookings/bookings.module';
-import { Booking } from '../bookings/entities/booking.entity';
-import { BookingContainer } from '../bookings/entities/booking-container.entity';
+import { Container } from '../container-management/entities/container.entity';
 import { LocomotivesModule } from '../locomotives/locomotives.module';
+import { RuleEngineModule } from '../rule-engine/rule-engine.module';
 import { Locomotive } from '../locomotives/entities/locomotive.entity';
+import { Route } from '../routes/entities/route.entity';
+import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
+import { TrainSet } from '../train-sets/entities/train-set.entity';
+import { TrainSetsModule } from '../train-sets/train-sets.module';
+import { TrainSchedulesModule } from '../train-schedules/train-schedules.module';
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import { WagonTypesModule } from '../wagon-types/wagon-types.module';
-import { TrainSet } from '../train-sets/entities/train-set.entity';
-import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
-import { TrainSetsModule } from '../train-sets/train-sets.module';
-import { TrainScheduleBooking } from '../train-schedules/entities/train-schedule-booking.entity';
-import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
-import { WagonBookingAllocation } from '../train-schedules/entities/wagon-booking-allocation.entity';
-import { TrainSchedulesModule } from '../train-schedules/train-schedules.module';
-import { Yard } from '../rule-engine/entities/yard.entity';
+import { Wagon } from '../wagons/entities/wagon.entity';
+import { TrainSchedulingGlobalRules } from './entities/train-scheduling-global-rules.entity';
 import { TrainSchedulingController } from './train-scheduling.controller';
 import { TrainSchedulingService } from './train-scheduling.service';

@Module({
  imports: [
    TypeOrmModule.forFeature([
-      Booking,
-      BookingContainer,
      Locomotive,
      WagonType,
      TrainSet,
      TrainSetWagon,
-      TrainSchedule,
-      TrainScheduleBooking,
-      WagonBookingAllocation,
-      Yard,
+      Route,
+      Wagon,
+      Container,
+      TrainSchedulingGlobalRules,
    ]),
    BookingsModule,
    LocomotivesModule,
    WagonTypesModule,
    TrainSetsModule,
    TrainSchedulesModule,
+    RuleEngineModule,
  ],
  controllers: [TrainSchedulingController],
  providers: [TrainSchedulingService],
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
@@ -1,5 +1,10 @@
 import { ConflictException } from '@nestjs/common';
+import { WagonReadiness, WagonStatus } from '@edr/types';

+import { Wagon } from '../wagons/entities/wagon.entity';
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
+import { TrainSchedulingGlobalRules } from './entities/train-scheduling-global-rules.entity';
 import { TrainSchedulingService } from './train-scheduling.service';

 const nw5 = {
@@ -11,6 +16,7 @@ const nw5 = {
  maxWagonsPerTrain: 53,
  supportedLoadTypes: ['CONTAINER'],
  isActive: true,
+  supportsContainer: true,
 };

 const locomotive = {
@@ -21,15 +27,29 @@ const locomotive = {
  status: 'AVAILABLE',
 };

+const cw3 = {
+  id: 'wagon-type-bulk',
+  code: 'CW3',
+  name: 'Covered Wagon',
+  capacityTons: 60,
+  lengthMeters: 14,
+  maxWagonsPerTrain: 53,
+  supportedLoadTypes: ['BULK'],
+  isActive: true,
+  supportsContainer: false,
+};
+
 const makeBooking = (
  id: string,
  reference: string,
  weight: number,
  quantity: number,
  containerCode: string,
+  wagonsRequired: number,
  scheduledDate = '2026-06-20T08:00:00.000Z',
  originYardId = 'yard-origin',
  destinationYardId = 'yard-destination',
+  extra: Record<string, unknown> = {},
 ) => ({
  id,
  reference,
@@ -39,75 +59,177 @@ const makeBooking = (
  originYardId,
  destinationYardId,
  status: 'PAID',
-  customer: { companyName: 'Demo Customer' },
+  schedulingStatus: 'HOLDING',
+  holdExpiresAt: new Date(Date.now() + 60 * 60 * 1000),
+  company: { companyName: 'Demo Customer' },
  originYard: { label: 'Djibouti', code: 'DJIBOUTI' },
  destinationYard: { label: 'Addis Ababa', code: 'ADDIS_ABABA' },
  bookingContainers: [
    {
+      id: `${id}-line`,
+      containerTypeId: 'ct-1',
      quantity,
+      wagonsRequired,
+      vgmPerUnitTons: weight / quantity,
+      isOverweight: false,
      containerType: { code: containerCode, label: containerCode },
    },
  ],
+  ...extra,
 });

 describe('TrainSchedulingService', () => {
  let service: TrainSchedulingService;
-  let dataSource: {
-    getRepository: jest.Mock;
-    transaction: jest.Mock;
-  };
-  let locomotivesRepository: {
-    findById: jest.Mock;
-  };
-  let wagonTypesRepository: {
-    findAll: jest.Mock;
-  };
+  let dataSource: { getRepository: jest.Mock; transaction: jest.Mock };
+  let bookingsRepository: Record<string, jest.Mock>;
+  let locomotivesRepository: { findById: jest.Mock; findAll: jest.Mock };
+  let wagonTypesRepository: { findAll: jest.Mock };
+  let trainSchedulesRepository: Record<string, jest.Mock>;
+  let trainScheduleBookingsRepository: Record<string, jest.Mock>;
+  let wagonBookingAllocationsRepository: Record<string, jest.Mock>;
+  let wagonAllocationContainerItemsRepository: Record<string, jest.Mock>;
+  let wagonAllocationBulkLoadsRepository: Record<string, jest.Mock>;

  beforeEach(() => {
-    dataSource = {
-      getRepository: jest.fn(),
-      transaction: jest.fn(),
+    dataSource = { getRepository: jest.fn(), transaction: jest.fn() };
+    bookingsRepository = {
+      findEligibleForScheduling: jest.fn(),
+      findByIdsForScheduling: jest.fn(),
+      updateSchedulingFields: jest.fn(),
    };
-    locomotivesRepository = {
+    locomotivesRepository = { findById: jest.fn(), findAll: jest.fn() };
+    wagonTypesRepository = { findAll: jest.fn() };
+    trainSchedulesRepository = {
      findById: jest.fn(),
-    };
-    wagonTypesRepository = {
+      findByIdWithFullGraph: jest.fn(),
      findAll: jest.fn(),
+      updateStatus: jest.fn(),
+    };
+    trainScheduleBookingsRepository = {
+      findByBookingIds: jest.fn(),
+      createMany: jest.fn(),
+      deleteByScheduleAndBooking: jest.fn(),
+    };
+    wagonBookingAllocationsRepository = {
+      deleteByTrainSetId: jest.fn().mockResolvedValue([]),
+      createMany: jest.fn(),
+    };
+    wagonAllocationContainerItemsRepository = {
+      createMany: jest.fn(),
+      deleteByAllocationIds: jest.fn(),
+      findAll: jest.fn().mockResolvedValue([]),
+    };
+    wagonAllocationBulkLoadsRepository = {
+      createMany: jest.fn(),
+      deleteByAllocationIds: jest.fn(),
+      findAll: jest.fn().mockResolvedValue([]),
    };

    service = new TrainSchedulingService(
      dataSource as never,
+      bookingsRepository as never,
      locomotivesRepository as never,
      wagonTypesRepository as never,
+      trainSchedulesRepository as never,
+      trainScheduleBookingsRepository as never,
+      wagonBookingAllocationsRepository as never,
+      wagonAllocationContainerItemsRepository as never,
+      wagonAllocationBulkLoadsRepository as never,
    );
+
+    const defaultFleetWagons = [
+      ...Array.from({ length: 100 }, (_, index) => ({
+        id: `wagon-nw5-${index}`,
+        wagonTypeId: nw5.id,
+        status: WagonStatus.Available,
+        readiness: WagonReadiness.ImportReady,
+        currentTrainScheduleId: null,
+      })),
+      ...Array.from({ length: 50 }, (_, index) => ({
+        id: `wagon-cw3-${index}`,
+        wagonTypeId: cw3.id,
+        status: WagonStatus.Available,
+        readiness: WagonReadiness.ImportReady,
+        currentTrainScheduleId: null,
+      })),
+    ];
+
+    dataSource.getRepository.mockImplementation((entity: unknown) => {
+      if (entity === TrainSchedulingGlobalRules) {
+        return { find: jest.fn().mockResolvedValue([]) };
+      }
+      if (entity === Wagon) {
+        return { find: jest.fn().mockResolvedValue(defaultFleetWagons) };
+      }
+      if (entity === WagonType) {
+        return { find: jest.fn().mockResolvedValue([nw5, cw3]) };
+      }
+      return { find: jest.fn().mockResolvedValue([]), findOne: jest.fn().mockResolvedValue(null) };
+    });
  });

-  it('computes the expected valid preview for Group A', async () => {
+  it('returns fleet availability and defers bookings when fleet is insufficient', async () => {
    const bookings = [
-      makeBooking('b1', 'BKG-CONT-001', 500, 20, '40FT'),
-      makeBooking('b2', 'BKG-CONT-002', 300, 10, '20FT'),
-      makeBooking('b3', 'BKG-CONT-003', 450, 15, '40FT'),
+      makeBooking('b1', 'BKG-CONT-001', 500, 20, '40FT', 20),
+      makeBooking('b2', 'BKG-CONT-002', 300, 10, '20FT', 10),
    ];

    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
-    dataSource.getRepository.mockImplementation((entity: { name?: string }) => {
-      if (entity?.name === 'Booking') {
-        return { find: jest.fn().mockResolvedValue(bookings) };
-      }
-      if (entity?.name === 'TrainScheduleBooking') {
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const availableWagons = Array.from({ length: 15 }, (_, index) => ({
+      id: `wagon-${index}`,
+      wagonTypeId: nw5.id,
+      status: WagonStatus.Available,
+      readiness: WagonReadiness.ImportReady,
+      currentTrainScheduleId: null,
+    }));
+
+    dataSource.getRepository.mockImplementation((entity: unknown) => {
+      if (entity === TrainSchedulingGlobalRules) {
        return { find: jest.fn().mockResolvedValue([]) };
      }
-      if (entity?.name === 'Locomotive') {
-        return {
-          count: jest.fn().mockResolvedValue(2),
-          find: jest.fn().mockResolvedValue([locomotive]),
-        };
+      if (entity === Wagon) {
+        return { find: jest.fn().mockResolvedValue(availableWagons) };
      }
-      throw new Error(`Unexpected repository ${entity?.name}`);
+      if (entity === WagonType) {
+        return { find: jest.fn().mockResolvedValue([nw5]) };
+      }
+      return { find: jest.fn().mockResolvedValue([]), findOne: jest.fn().mockResolvedValue(null) };
    });

    const result = await service.previewContainerTrainSchedule({
-      bookingIds: bookings.map((booking) => booking.id),
+      bookingIds: bookings.map((b) => b.id),
+      scheduleDate: '2026-06-20T08:00:00.000Z',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+    });
+
+    expect(result.fleetAvailability?.length).toBeGreaterThan(0);
+    expect(result.fleetAvailability?.[0]?.shortfall).toBeGreaterThan(0);
+    expect(result.deferredBookings?.length).toBeGreaterThan(0);
+    expect(result.summary.wagonsNeeded).toBeLessThan(30);
+    expect(result.warnings.some((w) => w.includes('Fleet shortage') || w.includes('deferred'))).toBe(
+      true,
+    );
+  });
+
+  it('computes slot-based preview for Group A', async () => {
+    const bookings = [
+      makeBooking('b1', 'BKG-CONT-001', 500, 20, '40FT', 20),
+      makeBooking('b2', 'BKG-CONT-002', 300, 10, '20FT', 10),
+      makeBooking('b3', 'BKG-CONT-003', 450, 15, '40FT', 15),
+    ];
+
+    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const result = await service.previewContainerTrainSchedule({
+      bookingIds: bookings.map((b) => b.id),
      scheduleDate: '2026-06-20T08:00:00.000Z',
      originStationId: 'yard-origin',
      destinationStationId: 'yard-destination',
@@ -115,40 +237,50 @@ describe('TrainSchedulingService', () => {

    expect(result.valid).toBe(true);
    expect(result.violations).toEqual([]);
-    expect(result.summary).toEqual({
-      totalBookings: 3,
-      totalWeightTons: 1250,
-      wagonType: 'NW5',
-      wagonsNeeded: 18,
-      totalLengthMeters: 252,
-    });
-    expect(result.wagonPlan).toHaveLength(18);
-    expect(result.wagonPlan[0]?.allocations[0]).toEqual({
-      bookingId: 'b1',
-      bookingReference: 'BKG-CONT-001',
-      allocatedWeightTons: 70,
+    expect(result.summary.wagonsNeeded).toBe(45);
+    expect(result.wagonPlan).toHaveLength(45);
+  });
+
+  it('returns soft hold warnings without forceAssign', async () => {
+    const bookings = [makeBooking('b7', 'BKG-CONT-007', 120, 2, '40FT', 2)];
+
+    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const result = await service.previewContainerTrainSchedule({
+      bookingIds: ['b7'],
+      scheduleDate: '2026-06-20T08:00:00.000Z',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
    });
+
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings[0]).toContain('soft hold window');
  });

  it('flags the overweight booking as invalid', async () => {
-    const bookings = [makeBooking('b6', 'BKG-CONT-006', 3600, 80, '40FT')];
+    const bookings = [
+      makeBooking('b6', 'BKG-CONT-006', 3600, 80, '40FT', 80, undefined, undefined, undefined, {
+        bookingContainers: [
+          {
+            id: 'b6-line',
+            containerTypeId: 'ct-1',
+            quantity: 80,
+            wagonsRequired: 80,
+            vgmPerUnitTons: 45,
+            isOverweight: true,
+            containerType: { code: '40FT', label: '40FT' },
+          },
+        ],
+      }),
+    ];

    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
-    dataSource.getRepository.mockImplementation((entity: { name?: string }) => {
-      if (entity?.name === 'Booking') {
-        return { find: jest.fn().mockResolvedValue(bookings) };
-      }
-      if (entity?.name === 'TrainScheduleBooking') {
-        return { find: jest.fn().mockResolvedValue([]) };
-      }
-      if (entity?.name === 'Locomotive') {
-        return {
-          count: jest.fn().mockResolvedValue(1),
-          find: jest.fn().mockResolvedValue([locomotive]),
-        };
-      }
-      throw new Error(`Unexpected repository ${entity?.name}`);
-    });
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);

    const result = await service.previewContainerTrainSchedule({
      bookingIds: ['b6'],
@@ -158,36 +290,70 @@ describe('TrainSchedulingService', () => {
    });

    expect(result.valid).toBe(false);
-    expect(result.summary.totalWeightTons).toBe(3600);
-    expect(result.violations).toContain(
-      'Total booking weight 3600T exceeds max train weight 3500T',
+    expect(result.violations.some((v) => v.includes('overweight'))).toBe(true);
+  });
+
+  it('allows preview when bookings are already on the target schedule', async () => {
+    const bookings = [makeBooking('b1', 'BKG-CONT-001', 500, 20, '40FT', 20)];
+
+    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([
+      { bookingId: 'b1', trainScheduleId: 'sched-target' },
+    ]);
+    trainSchedulesRepository.findById.mockResolvedValue({
+      id: 'sched-target',
+      direction: 'IMPORT',
+    });
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const result = await service.previewContainerTrainSchedule({
+      bookingIds: ['b1'],
+      scheduleDate: '2026-06-20T08:00:00.000Z',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+      targetScheduleId: 'sched-target',
+    });
+
+    expect(result.violations).not.toContain(
+      'One or more selected bookings are already assigned to a train schedule',
    );
+    expect(result.valid).toBe(true);
+  });
+
+  it('allows preview when selected bookings are on different schedule dates', async () => {
+    const bookings = [
+      makeBooking('b1', 'BKG-CONT-001', 500, 20, '40FT', 20, '2026-06-20T08:00:00.000Z'),
+      makeBooking('b2', 'BKG-CONT-002', 300, 10, '20FT', 10, '2026-06-21T14:00:00.000Z'),
+    ];
+
+    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const result = await service.previewContainerTrainSchedule({
+      bookingIds: bookings.map((b) => b.id),
+      scheduleDate: '2026-06-20T08:00:00.000Z',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+    });
+
+    expect(result.violations).not.toContain(
+      'Selected bookings must share the same schedule date',
+    );
+    expect(result.valid).toBe(true);
  });

  it('rejects bookings that are not in schedulable status', async () => {
    const bookings = [
-      {
-        ...makeBooking('b7', 'BKG-CONT-007', 120, 2, '40FT'),
-        status: 'APPROVED',
-      },
+      { ...makeBooking('b7', 'BKG-CONT-007', 120, 2, '40FT', 2), status: 'APPROVED' },
    ];

    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
-    dataSource.getRepository.mockImplementation((entity: { name?: string }) => {
-      if (entity?.name === 'Booking') {
-        return { find: jest.fn().mockResolvedValue(bookings) };
-      }
-      if (entity?.name === 'TrainScheduleBooking') {
-        return { find: jest.fn().mockResolvedValue([]) };
-      }
-      if (entity?.name === 'Locomotive') {
-        return {
-          count: jest.fn().mockResolvedValue(1),
-          find: jest.fn().mockResolvedValue([locomotive]),
-        };
-      }
-      throw new Error(`Unexpected repository ${entity?.name}`);
-    });
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);

    const result = await service.previewContainerTrainSchedule({
      bookingIds: ['b7'],
@@ -239,13 +405,16 @@ describe('TrainSchedulingService', () => {
    };

    jest.spyOn(service, 'selectOrValidateLocomotive').mockResolvedValue(locomotive as never);
-    dataSource.getRepository.mockImplementation((entity: { name?: string }) => {
-      if (entity?.name === 'Route') {
+    dataSource.getRepository.mockImplementation((entity: unknown) => {
+      if ((entity as { name?: string })?.name === 'Route') {
        return { findOne: jest.fn().mockResolvedValue(route) };
      }
-      throw new Error(`Unexpected repository ${entity?.name}`);
+      if (entity === TrainSchedulingGlobalRules) {
+        return { find: jest.fn().mockResolvedValue([]) };
+      }
+      throw new Error(`Unexpected repository ${(entity as { name?: string })?.name}`);
    });
-    jest.spyOn(service, 'getContainerTrainScheduleById').mockResolvedValue({ id: 'schedule-1' } as never);
+    trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue({ id: 'schedule-1' });
    dataSource.transaction.mockImplementation(async (callback: (tx: typeof manager) => Promise<string>) =>
      callback(manager),
    );
@@ -259,7 +428,62 @@ describe('TrainSchedulingService', () => {
    expect(trainSetRepo.save).toHaveBeenCalled();
    expect(trainScheduleRepo.save).toHaveBeenCalled();
    expect(lockedLocomotiveRepo.update).toHaveBeenCalledWith('loc-1', { status: 'ASSIGNED' });
-    expect(result).toEqual({ id: 'schedule-1' });
+    expect(result.id).toBe('schedule-1');
+  });
+
+  it('previews mixed container and bulk bookings', async () => {
+    const containerBooking = makeBooking('c1', 'BKG-CONT', 100, 2, '40FT', 2);
+    const bulkBooking = {
+      id: 'b1',
+      reference: 'BKG-BULK',
+      freightType: 'BULK',
+      cargoTotalWeightVgm: 120,
+      scheduledDate: new Date('2026-06-20T08:00:00.000Z'),
+      originYardId: 'yard-origin',
+      destinationYardId: 'yard-destination',
+      status: 'PAID',
+      bookingContainers: [],
+      cargoType: { code: 'COFFEE' },
+    };
+
+    wagonTypesRepository.findAll.mockImplementation(async ({ where }: { where?: { code?: string } }) => {
+      if (where?.code === 'NW5') return [nw5];
+      return [nw5, cw3];
+    });
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue([containerBooking, bulkBooking]);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const result = await service.previewTrainSchedule({
+      bookingIds: ['c1', 'b1'],
+      scheduleDate: '2026-06-20T08:00:00.000Z',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+    });
+
+    expect(result.valid).toBe(true);
+    expect(result.summary.wagonType).toBe('MIXED');
+    expect(result.wagonPlan.length).toBeGreaterThan(2);
+    expect(result.containerUnits).toHaveLength(2);
+  });
+
+  it('previews container bookings without requiring placements', async () => {
+    const bookings = [makeBooking('c2', 'BKG-CONT-2', 50, 1, '40FT', 1)];
+
+    wagonTypesRepository.findAll.mockResolvedValue([nw5]);
+    bookingsRepository.findByIdsForScheduling.mockResolvedValue(bookings);
+    trainScheduleBookingsRepository.findByBookingIds.mockResolvedValue([]);
+    locomotivesRepository.findAll.mockResolvedValue([locomotive]);
+
+    const result = await service.previewTrainSchedule({
+      bookingIds: ['c2'],
+      scheduleDate: '2026-06-20T08:00:00.000Z',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-destination',
+    });
+
+    expect(result.valid).toBe(true);
+    expect(result.containerUnits).toHaveLength(1);
  });

  it('rejects create when the locked locomotive is no longer available', async () => {
@@ -296,4 +520,48 @@ describe('TrainSchedulingService', () => {
      }),
    ).rejects.toBeInstanceOf(ConflictException);
  });
+
+  it('rejects pin when wagon readiness does not match schedule direction', async () => {
+    const scheduleId = 'sched-1';
+    const slotId = 'slot-1';
+
+    trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue({
+      id: scheduleId,
+      status: 'DRAFT',
+      direction: 'IMPORT',
+      trainSet: {
+        wagons: [{ id: slotId, physicalWagonId: null }],
+      },
+    });
+
+    const manager = {
+      getRepository: jest.fn((entity: { name?: string }) => {
+        if (entity === Wagon) {
+          return {
+            findOne: jest.fn().mockResolvedValue({
+              id: 'wagon-1',
+              wagonNumber: 'WGN-001',
+              status: WagonStatus.Available,
+              readiness: WagonReadiness.ExportReady,
+              currentTrainScheduleId: null,
+            }),
+            update: jest.fn(),
+          };
+        }
+        if (entity === TrainSetWagon) {
+          return { update: jest.fn() };
+        }
+        throw new Error(`Unexpected repository ${entity?.name}`);
+      }),
+    };
+    dataSource.transaction.mockImplementation(async (callback: (tx: typeof manager) => Promise<void>) =>
+      callback(manager),
+    );
+
+    await expect(
+      service.pinWagons(scheduleId, {
+        assignments: [{ trainSetWagonId: slotId, physicalWagonId: 'wagon-1' }],
+      }),
+    ).rejects.toBeInstanceOf(ConflictException);
+  });
 });
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.spec.ts
@@ -0,0 +1,202 @@
+import { AllocationLoadType } from '@edr/types';
+
+import { Booking } from '../bookings/entities/booking.entity';
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import {
+  buildBulkWagonPlan,
+  buildContainerWagonPlan,
+  buildMixedWagonPlan,
+  expandBookingContainerUnits,
+  expandContainerItems,
+  roundTons,
+  sumWagonsRequired,
+  validate20ftContainerRules,
+  validateContainerPlacements,
+} from './wagon-plan.util';
+
+const nw5: WagonType = {
+  id: 'wt-nw5',
+  code: 'NW5',
+  name: 'Flat Wagon',
+  capacityTons: 70,
+  lengthMeters: 14,
+  maxWagonsPerTrain: 53,
+  supportedLoadTypes: ['CONTAINER'],
+  isActive: true,
+  supportsContainer: true,
+} as WagonType;
+
+const cw3: WagonType = {
+  id: 'wt-cw3',
+  code: 'CW3',
+  name: 'Covered Wagon',
+  capacityTons: 60,
+  lengthMeters: 14,
+  maxWagonsPerTrain: 53,
+  supportedLoadTypes: ['BULK'],
+  isActive: true,
+  supportsContainer: false,
+} as WagonType;
+
+const makeContainerBooking = (
+  id: string,
+  lines: Array<{ quantity: number; wagonsRequired: number; vgmPerUnitTons?: number }>,
+): Booking =>
+  ({
+    id,
+    reference: id,
+    freightType: 'CONTAINER',
+    cargoTotalWeightVgm: lines.reduce(
+      (sum, line) => sum + line.quantity * (line.vgmPerUnitTons ?? 25),
+      0,
+    ),
+    bookingContainers: lines.map((line, index) => ({
+      id: `${id}-line-${index}`,
+      containerTypeId: `ct-${index}`,
+      quantity: line.quantity,
+      wagonsRequired: line.wagonsRequired,
+      vgmPerUnitTons: line.vgmPerUnitTons ?? 25,
+    })),
+  }) as Booking;
+
+describe('wagon-plan.util', () => {
+  it('uses slot-based planning: 2×20ft = 1 wagon slot', () => {
+    const booking = makeContainerBooking('b1', [{ quantity: 2, wagonsRequired: 1 }]);
+    const plan = buildContainerWagonPlan([booking], nw5);
+    expect(plan).toHaveLength(1);
+    expect(plan[0]?.allocations[0]?.loadType).toBe(AllocationLoadType.Container);
+  });
+
+  it('uses slot-based planning: 1×40ft = 1 wagon slot', () => {
+    const booking = makeContainerBooking('b2', [{ quantity: 1, wagonsRequired: 1 }]);
+    const plan = buildContainerWagonPlan([booking], nw5);
+    expect(plan).toHaveLength(1);
+  });
+
+  it('sums wagons across multiple container lines', () => {
+    const booking = makeContainerBooking('b3', [
+      { quantity: 2, wagonsRequired: 1 },
+      { quantity: 1, wagonsRequired: 1 },
+    ]);
+    expect(sumWagonsRequired(booking)).toBe(2);
+    const plan = buildContainerWagonPlan([booking], nw5);
+    expect(plan).toHaveLength(2);
+  });
+
+  it('6×20ft containers = 3 wagon slots (2 per wagon)', () => {
+    // 20ft containers have wagonsPerUnit = 0.5, so 6 * 0.5 = 3 wagons
+    const booking = makeContainerBooking('b6x20', [{ quantity: 6, wagonsRequired: 3 }]);
+    expect(sumWagonsRequired(booking)).toBe(3);
+    const plan = buildContainerWagonPlan([booking], nw5);
+    expect(plan).toHaveLength(3);
+    // Verify sequence numbers are 1, 2, 3
+    expect(plan.map((s) => s.sequenceNo)).toEqual([1, 2, 3]);
+  });
+
+  it('expands container items per quantity', () => {
+    const booking = makeContainerBooking('b4', [{ quantity: 3, wagonsRequired: 3 }]);
+    const items = expandContainerItems(booking, 'alloc-1');
+    expect(items).toHaveLength(3);
+    expect(items[0]?.wagonBookingAllocationId).toBe('alloc-1');
+  });
+
+  it('rounds tons to three decimal places', () => {
+    expect(roundTons(1.23456)).toBe(1.235);
+    expect(roundTons('bad')).toBe(0);
+  });
+
+  it('builds mixed plan with container block before bulk', () => {
+    const containerBooking = makeContainerBooking('c1', [{ quantity: 2, wagonsRequired: 2 }]);
+    const bulkBooking = {
+      id: 'b1',
+      reference: 'BKG-BULK',
+      freightType: 'BULK',
+      cargoTotalWeightVgm: 120,
+      bookingContainers: [],
+    } as unknown as Booking;
+
+    const plan = buildMixedWagonPlan([containerBooking], [bulkBooking], nw5, cw3);
+    expect(plan).toHaveLength(4);
+    expect(plan[0]?.slotLoadType).toBe('CONTAINER');
+    expect(plan[2]?.slotLoadType).toBe('BULK');
+    expect(plan.map((s) => s.sequenceNo)).toEqual([1, 2, 3, 4]);
+  });
+
+  it('expands booking container units for UI rows', () => {
+    const booking = makeContainerBooking('c2', [{ quantity: 3, wagonsRequired: 3 }]);
+    const units = expandBookingContainerUnits([booking]);
+    expect(units).toHaveLength(3);
+    expect(units[1]?.unitIndex).toBe(1);
+    expect(units[1]?.bookingContainerId).toBe('c2-line-0');
+  });
+
+  it('validates required placements per container unit', () => {
+    const booking = makeContainerBooking('c3', [{ quantity: 2, wagonsRequired: 2 }]);
+    const plan = buildContainerWagonPlan([booking], nw5);
+    const violations = validateContainerPlacements([booking], plan, []);
+    expect(violations.some((v) => v.includes('required'))).toBe(true);
+
+    const units = expandBookingContainerUnits([booking]);
+    const placements = units.map((unit, index) => ({
+      bookingContainerId: unit.bookingContainerId,
+      unitIndex: unit.unitIndex,
+      sequenceNo: plan[index]?.sequenceNo ?? 1,
+      containerNumber: `CNTR-${index + 1}`,
+    }));
+    expect(validateContainerPlacements([booking], plan, placements)).toEqual([]);
+  });
+
+  it('rejects 20ft container over max individual weight', () => {
+    const booking = makeContainerBooking('c20', [{ quantity: 2, wagonsRequired: 1, vgmPerUnitTons: 35 }]);
+    const units = expandBookingContainerUnits([booking]);
+    const placements = units.map((unit, index) => ({
+      bookingContainerId: unit.bookingContainerId,
+      unitIndex: unit.unitIndex,
+      sequenceNo: 1,
+      containerNumber: `CNTR-${index + 1}`,
+    }));
+
+    const violations = validate20ftContainerRules(units, placements, {
+      max20ftContainerWeightTons: 30,
+      max20ftPairWeightDiffTons: 10,
+    });
+
+    expect(violations.some((v) => v.includes('exceeds max 30T'))).toBe(true);
+  });
+
+  it('rejects 20ft pair when weight difference exceeds limit', () => {
+    const booking = makeContainerBooking('c21', [
+      { quantity: 2, wagonsRequired: 1, vgmPerUnitTons: 25 },
+    ]);
+    booking.bookingContainers![0]!.vgmPerUnitTons = 25;
+    const units = expandBookingContainerUnits([booking]);
+    units[1]!.grossWeightTons = 10;
+    const placements = units.map((unit) => ({
+      bookingContainerId: unit.bookingContainerId,
+      unitIndex: unit.unitIndex,
+      sequenceNo: 1,
+      containerNumber: `CNTR-${unit.unitIndex}`,
+    }));
+
+    const violations = validate20ftContainerRules(units, placements, {
+      max20ftContainerWeightTons: 30,
+      max20ftPairWeightDiffTons: 10,
+    });
+
+    expect(violations.some((v) => v.includes('weight difference'))).toBe(true);
+  });
+
+  it('builds bulk-only plan as degenerate mixed case', () => {
+    const bulkBooking = {
+      id: 'b2',
+      reference: 'BKG-BULK-2',
+      freightType: 'BULK',
+      cargoTotalWeightVgm: 60,
+      bookingContainers: [],
+    } as unknown as Booking;
+    const plan = buildMixedWagonPlan([], [bulkBooking], nw5, cw3);
+    expect(plan).toHaveLength(1);
+    expect(plan[0]?.slotLoadType).toBe('BULK');
+    expect(buildBulkWagonPlan([bulkBooking], cw3)).toHaveLength(1);
+  });
+});
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
@@ -0,0 +1,551 @@
+import { AllocationLoadType } from '@edr/types';
+
+import { Booking } from '../bookings/entities/booking.entity';
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+
+export const MAX_TRAIN_WEIGHT_TONS = 3500;
+export const MAX_TRAIN_LENGTH_METERS = 760;
+export const MAX_TEU_SLOTS_PER_WAGON = 2;
+
+export type TrainLimitConfig = {
+  maxWeightTons?: number;
+  maxLengthMeters?: number;
+  maxWagonsPerTrain?: number;
+  max20ftContainerWeightTons?: number;
+  max20ftPairWeightDiffTons?: number;
+};
+
+export type ContainerPlacementRules = {
+  max20ftContainerWeightTons?: number;
+  max20ftPairWeightDiffTons?: number;
+};
+
+export type WagonAllocationRecord = {
+  bookingId: string;
+  bookingReference: string;
+  allocatedWeightTons: number;
+  loadType: AllocationLoadType;
+};
+
+export type SlotLoadType = 'CONTAINER' | 'BULK';
+
+export type WagonPlanSlot = {
+  sequenceNo: number;
+  wagonTypeId: string;
+  wagonTypeCode: string;
+  capacityTons: number;
+  lengthMeters: number;
+  assignedWeightTons: number;
+  allocations: WagonAllocationRecord[];
+  slotLoadType?: SlotLoadType;
+};
+
+export type ContainerUnitRow = {
+  bookingId: string;
+  bookingReference: string;
+  bookingContainerId: string;
+  unitIndex: number;
+  containerTypeId: string;
+  containerTypeCode: string;
+  label: string;
+  grossWeightTons: number;
+  sizeFt?: number;
+  wagonsPerUnit?: number;
+  containersPerWagon?: number;
+  teuSlots?: number;
+};
+
+export type ContainerPlacementInput = {
+  bookingContainerId: string;
+  unitIndex: number;
+  sequenceNo: number;
+  containerId?: string;
+  containerNumber?: string;
+  sealNumber?: string;
+};
+
+export function roundTons(value: number | string | null | undefined): number {
+  const numericValue = typeof value === 'number' ? value : Number(value ?? 0);
+  if (!Number.isFinite(numericValue)) return 0;
+  return Number(numericValue.toFixed(3));
+}
+
+/** TEU slots on a wagon: 40ft = 2, 20ft = 1 (max 2 TEU / wagon). */
+export function teuSlotsForSizeFt(sizeFt: number): number {
+  return sizeFt >= 40 ? 2 : 1;
+}
+
+export function containersPerWagonFromType(wagonsPerUnit: number): number {
+  const wpu = Number(wagonsPerUnit);
+  if (!wpu || wpu <= 0) return 1;
+  return Math.max(1, Math.round(1 / wpu));
+}
+
+function lineWagonsRequired(line: {
+  quantity?: number | null;
+  wagonsRequired?: number | null;
+  containerType?: { wagonsPerUnit?: number | null; sizeFt?: number | null } | null;
+}): number {
+  const qty = Number(line.quantity ?? 0);
+  if (qty <= 0) return 0;
+  const wpu = Number(line.containerType?.wagonsPerUnit);
+  if (Number.isFinite(wpu) && wpu > 0) {
+    return Math.ceil(qty * wpu);
+  }
+  return Math.max(1, Math.ceil(Number(line.wagonsRequired ?? 1)));
+}
+
+/**
+ * Build slot-based wagon plan for CONTAINER bookings using booking_container.wagons_required.
+ */
+export function buildContainerWagonPlan(
+  bookings: Booking[],
+  wagonType: WagonType,
+): WagonPlanSlot[] {
+  const totalSlots = bookings.reduce((sum, booking) => {
+    const lineSlots = (booking.bookingContainers ?? []).reduce(
+      (lineSum, line) => lineSum + lineWagonsRequired(line),
+      0,
+    );
+    return sum + Math.max(lineSlots, 1);
+  }, 0);
+
+  const slots = Math.max(1, Math.ceil(totalSlots));
+  const basePlan: WagonPlanSlot[] = Array.from({ length: slots }, (_, index) => ({
+    sequenceNo: index + 1,
+    wagonTypeId: wagonType.id,
+    wagonTypeCode: wagonType.code,
+    capacityTons: Number(wagonType.capacityTons),
+    lengthMeters: Number(wagonType.lengthMeters),
+    assignedWeightTons: 0,
+    allocations: [],
+  }));
+
+  return allocateBookingsToSlots(bookings, basePlan, AllocationLoadType.Container).map((slot) => ({
+    ...slot,
+    slotLoadType: 'CONTAINER' as SlotLoadType,
+  }));
+}
+
+/**
+ * Build weight-based wagon plan for BULK bookings.
+ */
+export function buildBulkWagonPlan(
+  bookings: Booking[],
+  wagonType: WagonType,
+): WagonPlanSlot[] {
+  const totalWeight = roundTons(
+    bookings.reduce((sum, b) => sum + Number(b.cargoTotalWeightVgm ?? 0), 0),
+  );
+  const capacity = Number(wagonType.capacityTons);
+  const slots = Math.max(1, Math.ceil(totalWeight / capacity));
+
+  const basePlan: WagonPlanSlot[] = Array.from({ length: slots }, (_, index) => ({
+    sequenceNo: index + 1,
+    wagonTypeId: wagonType.id,
+    wagonTypeCode: wagonType.code,
+    capacityTons: capacity,
+    lengthMeters: Number(wagonType.lengthMeters),
+    assignedWeightTons: 0,
+    allocations: [],
+  }));
+
+  return allocateBookingsToSlots(bookings, basePlan, AllocationLoadType.Bulk).map((slot) => ({
+    ...slot,
+    slotLoadType: 'BULK' as SlotLoadType,
+  }));
+}
+
+/**
+ * Build a mixed consist: container slots first, then bulk slots, with unified sequence numbers.
+ */
+export function buildMixedWagonPlan(
+  containerBookings: Booking[],
+  bulkBookings: Booking[],
+  containerWagonType: WagonType,
+  bulkWagonType: WagonType,
+): WagonPlanSlot[] {
+  const containerPlan = containerBookings.length
+    ? buildContainerWagonPlan(containerBookings, containerWagonType)
+    : [];
+  const bulkPlan = bulkBookings.length
+    ? buildBulkWagonPlan(bulkBookings, bulkWagonType)
+    : [];
+
+  const tagged: WagonPlanSlot[] = [
+    ...containerPlan.map((slot) => ({ ...slot, slotLoadType: 'CONTAINER' as SlotLoadType })),
+    ...bulkPlan.map((slot) => ({ ...slot, slotLoadType: 'BULK' as SlotLoadType })),
+  ];
+
+  if (!tagged.length) {
+    return [
+      {
+        sequenceNo: 1,
+        wagonTypeId: containerWagonType.id,
+        wagonTypeCode: containerWagonType.code,
+        capacityTons: Number(containerWagonType.capacityTons),
+        lengthMeters: Number(containerWagonType.lengthMeters),
+        assignedWeightTons: 0,
+        allocations: [],
+        slotLoadType: 'CONTAINER',
+      },
+    ];
+  }
+
+  return tagged.map((slot, index) => ({
+    ...slot,
+    sequenceNo: index + 1,
+  }));
+}
+
+export function expandBookingContainerUnits(bookings: Booking[]): ContainerUnitRow[] {
+  const rows: ContainerUnitRow[] = [];
+
+  for (const booking of bookings.filter((b) => b.freightType === 'CONTAINER')) {
+    for (const line of booking.bookingContainers ?? []) {
+      const qty = Number(line.quantity ?? 0);
+      const code = line.containerType?.code ?? line.containerType?.label ?? 'Container';
+      const sizeFt = Number(line.containerType?.sizeFt ?? (code.includes('40') ? 40 : 20));
+      const wagonsPerUnit = Number(line.containerType?.wagonsPerUnit ?? (sizeFt >= 40 ? 1 : 0.5));
+      const perWagon = containersPerWagonFromType(wagonsPerUnit);
+      const teuSlots = teuSlotsForSizeFt(sizeFt);
+      for (let i = 0; i < qty; i += 1) {
+        rows.push({
+          bookingId: booking.id,
+          bookingReference: booking.reference,
+          bookingContainerId: line.id,
+          unitIndex: i,
+          containerTypeId: line.containerTypeId ?? '',
+          containerTypeCode: code,
+          label: `${booking.reference} · ${i + 1}/${qty} · ${code}`,
+          grossWeightTons: Number(line.vgmPerUnitTons),
+          sizeFt,
+          wagonsPerUnit,
+          containersPerWagon: perWagon,
+          teuSlots,
+        });
+      }
+    }
+  }
+
+  return rows;
+}
+
+export function getContainerSlotSequenceNos(wagonPlan: WagonPlanSlot[]): number[] {
+  return wagonPlan
+    .filter((slot) => slot.slotLoadType === 'CONTAINER' || slot.allocations.some(
+      (a) => a.loadType === AllocationLoadType.Container,
+    ))
+    .map((slot) => slot.sequenceNo);
+}
+
+function allocateBookingsToSlots(
+  bookings: Booking[],
+  basePlan: WagonPlanSlot[],
+  loadType: AllocationLoadType,
+): WagonPlanSlot[] {
+  const remaining = bookings.map((booking) => ({
+    bookingId: booking.id,
+    bookingReference: booking.reference,
+    remainingWeightTons: roundTons(Number(booking.cargoTotalWeightVgm ?? 0)),
+  }));
+
+  let bookingIndex = 0;
+
+  return basePlan.map((slot) => {
+    let wagonRemaining = roundTons(slot.capacityTons);
+    const allocations: WagonAllocationRecord[] = [];
+    let assignedWeightTons = 0;
+
+    while (wagonRemaining > 0 && bookingIndex < remaining.length) {
+      const booking = remaining[bookingIndex];
+      const allocatedWeightTons = roundTons(
+        Math.min(wagonRemaining, booking.remainingWeightTons),
+      );
+
+      if (allocatedWeightTons <= 0) {
+        bookingIndex += 1;
+        continue;
+      }
+
+      allocations.push({
+        bookingId: booking.bookingId,
+        bookingReference: booking.bookingReference,
+        allocatedWeightTons,
+        loadType,
+      });
+
+      booking.remainingWeightTons = roundTons(
+        booking.remainingWeightTons - allocatedWeightTons,
+      );
+      wagonRemaining = roundTons(wagonRemaining - allocatedWeightTons);
+      assignedWeightTons = roundTons(assignedWeightTons + allocatedWeightTons);
+
+      if (booking.remainingWeightTons <= 0) {
+        bookingIndex += 1;
+      }
+    }
+
+    return { ...slot, assignedWeightTons, allocations };
+  });
+}
+
+export function expandContainerItems(
+  booking: Booking,
+  allocationId: string,
+): Array<{
+  wagonBookingAllocationId: string;
+  bookingContainerId: string;
+  containerTypeId: string;
+  grossWeightTons: number;
+  positionOnWagon: number | null;
+}> {
+  const items: Array<{
+    wagonBookingAllocationId: string;
+    bookingContainerId: string;
+    containerTypeId: string;
+    grossWeightTons: number;
+    positionOnWagon: number | null;
+  }> = [];
+
+  for (const line of booking.bookingContainers ?? []) {
+    const qty = Number(line.quantity ?? 0);
+    for (let i = 0; i < qty; i += 1) {
+      items.push({
+        wagonBookingAllocationId: allocationId,
+        bookingContainerId: line.id,
+        containerTypeId: line.containerTypeId ?? '',
+        grossWeightTons: Number(line.vgmPerUnitTons),
+        positionOnWagon: qty > 1 ? i + 1 : null,
+      });
+    }
+  }
+
+  return items;
+}
+
+export function sumWagonsRequired(booking: Booking): number {
+  if (booking.freightType === 'BULK') {
+    return 1;
+  }
+  return (booking.bookingContainers ?? []).reduce(
+    (sum, line) => sum + Number(line.wagonsRequired ?? 0),
+    0,
+  );
+}
+
+export function validateBulkWagonSlotWeights(wagonPlan: WagonPlanSlot[]): string[] {
+  const violations: string[] = [];
+  for (const slot of wagonPlan.filter((s) => s.slotLoadType === 'BULK')) {
+    if (slot.assignedWeightTons > slot.capacityTons) {
+      violations.push(
+        `Bulk wagon #${slot.sequenceNo} load ${slot.assignedWeightTons}T exceeds capacity ${slot.capacityTons}T`,
+      );
+    }
+  }
+  return violations;
+}
+
+export function validateTrainLimits(
+  wagonPlan: WagonPlanSlot[],
+  wagonType: WagonType,
+  limits?: TrainLimitConfig,
+): string[] {
+  const violations: string[] = [];
+  const maxWeightTons = limits?.maxWeightTons ?? MAX_TRAIN_WEIGHT_TONS;
+  const maxLengthMeters = limits?.maxLengthMeters ?? MAX_TRAIN_LENGTH_METERS;
+  const maxWagonsPerTrain =
+    limits?.maxWagonsPerTrain ?? Number(wagonType.maxWagonsPerTrain ?? 53);
+
+  const totalWeightTons = roundTons(
+    wagonPlan.reduce((sum, w) => sum + w.assignedWeightTons, 0),
+  );
+  const totalLengthMeters = roundTons(
+    wagonPlan.reduce((sum, w) => sum + w.lengthMeters, 0),
+  );
+
+  if (totalWeightTons > maxWeightTons) {
+    violations.push(
+      `Total booking weight ${totalWeightTons}T exceeds max train weight ${maxWeightTons}T`,
+    );
+  }
+  if (totalLengthMeters > maxLengthMeters) {
+    violations.push(
+      `Total wagon length ${totalLengthMeters}m exceeds max train length ${maxLengthMeters}m`,
+    );
+  }
+  if (wagonPlan.length > maxWagonsPerTrain) {
+    violations.push(
+      `Wagon count ${wagonPlan.length} exceeds max wagons per train (${maxWagonsPerTrain})`,
+    );
+  }
+
+  violations.push(...validateBulkWagonSlotWeights(wagonPlan));
+
+  return violations;
+}
+
+export function validateMixedTrainLimits(
+  wagonPlan: WagonPlanSlot[],
+  wagonTypes: WagonType[],
+  limits?: TrainLimitConfig,
+): string[] {
+  const maxWagonsPerTrain =
+    limits?.maxWagonsPerTrain ??
+    Math.max(...wagonTypes.map((wt) => Number(wt.maxWagonsPerTrain ?? 53)), 53);
+
+  return validateTrainLimits(
+    wagonPlan,
+    { maxWagonsPerTrain } as WagonType,
+    { ...limits, maxWagonsPerTrain },
+  );
+}
+
+export function validate20ftContainerRules(
+  units: ContainerUnitRow[],
+  placements: ContainerPlacementInput[],
+  rules?: ContainerPlacementRules,
+): string[] {
+  const violations: string[] = [];
+  const maxEach = rules?.max20ftContainerWeightTons;
+  const maxDiff = rules?.max20ftPairWeightDiffTons;
+  if (maxEach == null && maxDiff == null) return violations;
+
+  const placementByUnit = new Map(
+    placements.map((p) => [`${p.bookingContainerId}:${p.unitIndex}`, p]),
+  );
+
+  const weightsBySlot = new Map<number, number[]>();
+
+  for (const unit of units) {
+    const sizeFt = unit.sizeFt ?? (unit.containerTypeCode.includes('40') ? 40 : 20);
+    if (sizeFt >= 40) continue;
+
+    if (maxEach != null && unit.grossWeightTons > maxEach) {
+      violations.push(
+        `${unit.label} weight ${unit.grossWeightTons}T exceeds max ${maxEach}T for 20ft containers`,
+      );
+    }
+
+    const placement = placementByUnit.get(`${unit.bookingContainerId}:${unit.unitIndex}`);
+    if (!placement?.sequenceNo) continue;
+
+    const list = weightsBySlot.get(placement.sequenceNo) ?? [];
+    list.push(unit.grossWeightTons);
+    weightsBySlot.set(placement.sequenceNo, list);
+  }
+
+  if (maxDiff != null) {
+    for (const [sequenceNo, weights] of weightsBySlot.entries()) {
+      if (weights.length < 2) continue;
+      const diff = Math.abs(weights[0]! - weights[1]!);
+      if (diff > maxDiff) {
+        violations.push(
+          `Wagon #${sequenceNo} 20ft pair weight difference ${roundTons(diff)}T exceeds max ${maxDiff}T`,
+        );
+      }
+    }
+  }
+
+  return violations;
+}
+
+export function validateContainerPlacements(
+  containerBookings: Booking[],
+  wagonPlan: WagonPlanSlot[],
+  placements: ContainerPlacementInput[],
+  rules?: ContainerPlacementRules,
+): string[] {
+  const violations: string[] = [];
+  const units = expandBookingContainerUnits(containerBookings);
+  if (!units.length) return violations;
+
+  const containerSlots = new Set(getContainerSlotSequenceNos(wagonPlan));
+  const unitKeys = new Set(units.map((u) => `${u.bookingContainerId}:${u.unitIndex}`));
+  const placementKeys = new Set<string>();
+  const containerNumbers = new Set<string>();
+
+  if (!placements.length) {
+    violations.push('Container placements are required for container bookings');
+    return violations;
+  }
+
+  for (const placement of placements) {
+    const unitKey = `${placement.bookingContainerId}:${placement.unitIndex}`;
+    if (!unitKeys.has(unitKey)) {
+      violations.push(
+        `Unknown container unit ${placement.bookingContainerId}#${placement.unitIndex}`,
+      );
+      continue;
+    }
+    if (placementKeys.has(unitKey)) {
+      violations.push(`Duplicate placement for container unit ${unitKey}`);
+    }
+    placementKeys.add(unitKey);
+
+    if (!containerSlots.has(placement.sequenceNo)) {
+      violations.push(`Slot #${placement.sequenceNo} is not a container wagon slot`);
+    }
+
+    const hasInventory = Boolean(placement.containerId);
+    const hasManual = Boolean(placement.containerNumber?.trim());
+    if (!hasInventory && !hasManual) {
+      violations.push(
+        `Container unit ${unitKey} requires an existing container or a new container number`,
+      );
+    }
+
+    if (hasManual) {
+      const normalized = placement.containerNumber!.trim().toUpperCase();
+      if (containerNumbers.has(normalized)) {
+        violations.push(`Duplicate container number ${normalized}`);
+      }
+      containerNumbers.add(normalized);
+    }
+  }
+
+  for (const unit of units) {
+    const unitKey = `${unit.bookingContainerId}:${unit.unitIndex}`;
+    if (!placementKeys.has(unitKey)) {
+      violations.push(`Missing placement for ${unit.label}`);
+    }
+  }
+
+  const slotTeuUsed = new Map<number, number>();
+  const slotWeightUsed = new Map<number, number>();
+  const slotBySeq = new Map(wagonPlan.map((s) => [s.sequenceNo, s]));
+
+  for (const placement of placements) {
+    const unit = units.find(
+      (u) =>
+        u.bookingContainerId === placement.bookingContainerId &&
+        u.unitIndex === placement.unitIndex,
+    );
+    if (!unit) continue;
+
+    const teu = unit.teuSlots ?? teuSlotsForSizeFt(unit.sizeFt ?? 20);
+    const usedTeu = slotTeuUsed.get(placement.sequenceNo) ?? 0;
+    if (usedTeu + teu > MAX_TEU_SLOTS_PER_WAGON) {
+      violations.push(
+        `Wagon #${placement.sequenceNo} cannot fit another ${unit.containerTypeCode} (max 1×40ft or 2×20ft per wagon)`,
+      );
+    } else {
+      slotTeuUsed.set(placement.sequenceNo, usedTeu + teu);
+    }
+
+    const slot = slotBySeq.get(placement.sequenceNo);
+    if (slot) {
+      const weight = roundTons(slotWeightUsed.get(placement.sequenceNo) ?? 0) + unit.grossWeightTons;
+      slotWeightUsed.set(placement.sequenceNo, weight);
+      if (weight > slot.capacityTons) {
+        violations.push(
+          `Wagon #${placement.sequenceNo} total container weight ${weight}T exceeds capacity ${slot.capacityTons}T`,
+        );
+      }
+    }
+  }
+
+  violations.push(...validate20ftContainerRules(units, placements, rules));
+
+  return violations;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-readiness.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-readiness.util.spec.ts
@@ -0,0 +1,35 @@
+import { WagonReadiness } from '@edr/types';
+
+import {
+  requiredWagonReadiness,
+  wagonReadinessMatchesSchedule,
+} from './wagon-readiness.util';
+
+describe('wagonReadinessMatchesSchedule', () => {
+  it('requires IMPORT_READY for IMPORT schedules', () => {
+    expect(requiredWagonReadiness('IMPORT')).toBe(WagonReadiness.ImportReady);
+    expect(
+      wagonReadinessMatchesSchedule(WagonReadiness.ImportReady, 'IMPORT'),
+    ).toBe(true);
+    expect(
+      wagonReadinessMatchesSchedule(WagonReadiness.ExportReady, 'IMPORT'),
+    ).toBe(false);
+  });
+
+  it('requires EXPORT_READY for EXPORT schedules', () => {
+    expect(requiredWagonReadiness('EXPORT')).toBe(WagonReadiness.ExportReady);
+    expect(
+      wagonReadinessMatchesSchedule(WagonReadiness.ExportReady, 'EXPORT'),
+    ).toBe(true);
+    expect(
+      wagonReadinessMatchesSchedule(WagonReadiness.ImportReady, 'EXPORT'),
+    ).toBe(false);
+  });
+
+  it('allows any readiness for DOMESTIC schedules', () => {
+    expect(requiredWagonReadiness('DOMESTIC')).toBeNull();
+    expect(
+      wagonReadinessMatchesSchedule(WagonReadiness.ExportReady, 'DOMESTIC'),
+    ).toBe(true);
+  });
+});
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-readiness.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-readiness.util.ts
@@ -0,0 +1,18 @@
+import { WagonReadiness, type ScheduleTradeDirection } from '@edr/types';
+
+export function requiredWagonReadiness(
+  direction: ScheduleTradeDirection | string | null | undefined,
+): WagonReadiness | null {
+  if (direction === 'IMPORT') return WagonReadiness.ImportReady;
+  if (direction === 'EXPORT') return WagonReadiness.ExportReady;
+  return null;
+}
+
+export function wagonReadinessMatchesSchedule(
+  wagonReadiness: WagonReadiness | string,
+  direction: ScheduleTradeDirection | string | null | undefined,
+): boolean {
+  const required = requiredWagonReadiness(direction);
+  if (!required) return true;
+  return wagonReadiness === required;
+}
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-type-resolver.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-type-resolver.util.ts
@@ -0,0 +1,49 @@
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+
+const CARGO_CODE_TO_WAGON_TYPE: Record<string, string> = {
+  COFFEE: 'KW2',
+  GRAIN: 'KW2',
+  WHEAT: 'KW2',
+  SORGHUM: 'KW2',
+  CORN: 'KW2',
+  FERTILIZER: 'PW2',
+  SUGAR: 'PW2',
+  COAL: 'KW3',
+  STEEL: 'CW3',
+  ORE: 'CW3',
+};
+
+const DEFAULT_BULK_WAGON_TYPE = 'CW3';
+const DEFAULT_CONTAINER_WAGON_TYPE = 'NW5';
+
+/**
+ * Resolve wagon type code from cargo type code for bulk freight.
+ */
+export function resolveBulkWagonTypeCode(cargoTypeCode?: string | null): string {
+  if (!cargoTypeCode) return DEFAULT_BULK_WAGON_TYPE;
+  const normalized = cargoTypeCode.trim().toUpperCase();
+  return CARGO_CODE_TO_WAGON_TYPE[normalized] ?? DEFAULT_BULK_WAGON_TYPE;
+}
+
+/**
+ * Pick the best matching wagon type entity for bulk cargo.
+ */
+export function pickBulkWagonType(
+  wagonTypes: WagonType[],
+  cargoTypeCode?: string | null,
+): WagonType | undefined {
+  const preferredCode = resolveBulkWagonTypeCode(cargoTypeCode);
+  const direct = wagonTypes.find((wt) => wt.code === preferredCode && wt.isActive);
+  if (direct) return direct;
+
+  return wagonTypes.find(
+    (wt) =>
+      wt.isActive &&
+      !wt.supportsContainer &&
+      wt.code !== DEFAULT_CONTAINER_WAGON_TYPE,
+  );
+}
+
+export function getDefaultContainerWagonTypeCode(): string {
+  return DEFAULT_CONTAINER_WAGON_TYPE;
+}
--- a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
@@ -1,10 +1,21 @@
 import { BaseEntity } from '@edr/api-common';
+import { TrainSetWagonStatus } from '@edr/types';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';

 import { WagonBookingAllocation } from '../../train-schedules/entities/wagon-booking-allocation.entity';
+import { Wagon } from '../../wagons/entities/wagon.entity';
 import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 import { TrainSet } from './train-set.entity';

+export const TRAIN_SET_WAGON_STATUSES = [
+  TrainSetWagonStatus.Planned,
+  TrainSetWagonStatus.Reserved,
+  TrainSetWagonStatus.Loaded,
+  TrainSetWagonStatus.Departed,
+] as const;
+
+export type TrainSetWagonStatusType = (typeof TRAIN_SET_WAGON_STATUSES)[number];
+
@Entity({ schema: 'freight', name: 'train_set_wagons' })
@Index(['trainSetId', 'sequenceNo'], { unique: true })
 export class TrainSetWagon extends BaseEntity {
@@ -34,6 +45,16 @@ export class TrainSetWagon extends BaseEntity {
  @Column({ name: 'assigned_weight_tons', type: 'numeric', precision: 10, scale: 3, default: 0 })
  assignedWeightTons!: number;

+  @Column({ name: 'physical_wagon_id', type: 'uuid', nullable: true })
+  physicalWagonId?: string | null;
+
+  @ManyToOne(() => Wagon, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'physical_wagon_id' })
+  physicalWagon?: Wagon | null;
+
+  @Column({ name: 'status', type: 'varchar', length: 20, default: 'PLANNED' })
+  status!: string;
+
  @OneToMany(() => WagonBookingAllocation, (allocation) => allocation.trainSetWagon)
  allocations?: WagonBookingAllocation[];
 }
--- a/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
+++ b/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
@@ -4,6 +4,10 @@ import { Freight } from '@edr/types';
 import { Column, Entity, OneToMany } from 'typeorm';
 import { Wagon } from '../../wagons/entities/wagon.entity';

+/**
+ * Fleet master data — named wagon consist in inventory (POST /trains).
+ * Operational departures use train_schedules + locomotives; scheduling never creates trains rows.
+ */
@Entity({ schema: 'freight', name: 'trains' })
 export class Train extends BaseEntity {
  // --- existing fields (keep for backward compatibility) ---
--- a/apps/edr-freight-api/src/modules/wagon-types/entities/wagon-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/wagon-types/entities/wagon-type.entity.ts
@@ -28,6 +28,18 @@ export class WagonType extends BaseEntity {
  @Column({ name: 'is_active', type: 'boolean', default: true })
  isActive!: boolean;

+  @Column({ name: 'equated_length_m', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  equatedLengthM?: number | null;
+
+  @Column({ name: 'tare_weight_tons', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  tareWeightTons?: number | null;
+
+  @Column({ name: 'supports_container', type: 'boolean', default: false })
+  supportsContainer!: boolean;
+
+  @Column({ name: 'max_container_gross_t', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  maxContainerGrossT?: number | null;
+
  @OneToMany(() => TrainSetWagon, (wagon) => wagon.wagonType)
  trainSetWagons?: TrainSetWagon[];
 }
--- a/apps/edr-freight-api/src/modules/wagons/dto/create-wagon.dto.ts
+++ b/apps/edr-freight-api/src/modules/wagons/dto/create-wagon.dto.ts
@@ -1,4 +1,5 @@
-import { IsString, IsUUID, IsOptional, IsInt, Min, IsNumber, IsIn } from 'class-validator';
+import { WagonReadiness, WagonStatus } from '@edr/types';
+import { IsString, IsUUID, IsOptional, IsInt, Min, IsNumber, IsEnum } from 'class-validator';

 export class CreateWagonDto {
  @IsString()
@@ -25,10 +26,14 @@ export class CreateWagonDto {
  maxPayloadWeight!: number;

  @IsOptional()
-  @IsIn(['AVAILABLE', 'ASSIGNED', 'MAINTENANCE', 'RETIRED'])
-  status?: string;
+  @IsEnum(WagonStatus)
+  status?: WagonStatus;
+
+  @IsOptional()
+  @IsEnum(WagonReadiness)
+  readiness?: WagonReadiness;

  @IsOptional()
  @IsString()
  notes?: string;
-}
+}
--- a/apps/edr-freight-api/src/modules/wagons/entities/wagon.entity.ts
+++ b/apps/edr-freight-api/src/modules/wagons/entities/wagon.entity.ts
@@ -1,10 +1,29 @@
 // apps/edr-freight-api/src/modules/wagons/entities/wagon.entity.ts
-import { Entity, Column, ManyToOne, OneToMany, JoinColumn } from 'typeorm';
+import { WagonReadiness, WagonStatus } from '@edr/types';
+import { Entity, Column, ManyToOne, OneToMany, JoinColumn, Index } from 'typeorm';
 import { BaseEntity } from '@edr/api-common';
 import { Train } from '../../trains/entities/train.entity';
+import { TrainSchedule } from '../../train-schedules/entities/train-schedule.entity';
+import { TrainSetWagon } from '../../train-sets/entities/train-set-wagon.entity';
 import { Container } from '../../container-management/entities/container.entity';

+export const WAGON_STATUSES = [
+  WagonStatus.Available,
+  WagonStatus.Assigned,
+  WagonStatus.Maintenance,
+  WagonStatus.Retired,
+] as const;
+
+export const WAGON_READINESS_VALUES = [
+  WagonReadiness.ImportReady,
+  WagonReadiness.ExportReady,
+] as const;
+
+export type WagonStatusType = (typeof WAGON_STATUSES)[number];
+export type WagonReadinessType = (typeof WAGON_READINESS_VALUES)[number];
+
@Entity({ name: 'wagons', schema: 'freight' })
+@Index(['readiness'])
 export class Wagon extends BaseEntity {
  @Column({ unique: true, name: 'wagon_number' })
  wagonNumber!: string;
@@ -24,13 +43,30 @@ export class Wagon extends BaseEntity {
  @Column({ name: 'max_payload_weight', type: 'decimal', precision: 10, scale: 2 })
  maxPayloadWeight!: number;

-  @Column({ type: 'varchar', default: 'AVAILABLE' })
-  status!: string; // AVAILABLE, ASSIGNED, MAINTENANCE, RETIRED
+  @Column({ type: 'varchar', length: 20, default: WagonStatus.Available })
+  status!: WagonStatusType;
+
+  @Column({ type: 'varchar', length: 20, default: WagonReadiness.ImportReady })
+  readiness!: WagonReadinessType;

  @Column({ type: 'text', nullable: true })
  notes!: string | null;

-  // Relationship to Train
+  @Column({ name: 'train_set_wagon_id', type: 'uuid', nullable: true })
+  trainSetWagonId!: string | null;
+
+  @ManyToOne(() => TrainSetWagon, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'train_set_wagon_id' })
+  trainSetWagon?: TrainSetWagon | null;
+
+  @Column({ name: 'current_train_schedule_id', type: 'uuid', nullable: true })
+  currentTrainScheduleId!: string | null;
+
+  @ManyToOne(() => TrainSchedule, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'current_train_schedule_id' })
+  currentTrainSchedule?: TrainSchedule | null;
+
+  /** Fleet master consist grouping — separate from operational train_schedules. */
  @ManyToOne(() => Train, (train) => train.wagons, { onDelete: 'SET NULL' })
  @JoinColumn({ name: 'train_id' })
  train!: Train | null;
--- a/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
@@ -1,3 +1,4 @@
+import { WagonReadiness, WagonStatus } from '@edr/types';
 import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, DataSource, FindOptionsOrder, FindOptionsWhere, ILike } from 'typeorm';
@@ -19,7 +20,11 @@ export class WagonsService {
  ) {}

  async create(dto: CreateWagonDto): Promise<Wagon> {
-    const wagon = this.wagonRepo.create(dto);
+    const wagon = this.wagonRepo.create({
+      ...dto,
+      status: dto.status ?? WagonStatus.Available,
+      readiness: dto.readiness ?? WagonReadiness.ImportReady,
+    });
    // Convert undefined to null for nullable fields
    if (dto.trainId === undefined) wagon.trainId = null;
    if (dto.sequenceNumber === undefined) wagon.sequenceNumber = null;
@@ -30,23 +35,28 @@ export class WagonsService {
    const where: FindOptionsWhere<Wagon>[] | FindOptionsWhere<Wagon> = [];
    const search = query.search?.trim();
    const status = query.status?.trim();
+    const readiness = query.readiness?.trim();
    const trainId = query.trainId?.trim();
+    const filters = {
+      ...(status ? { status: status as Wagon['status'] } : {}),
+      ...(readiness ? { readiness: readiness as Wagon['readiness'] } : {}),
+      ...(trainId ? { trainId } : {}),
+    };

    if (search) {
      where.push({
        wagonNumber: ILike(`%${search}%`),
-        ...(status ? { status } : {}),
-        ...(trainId ? { trainId } : {}),
+        ...filters,
      });
    }

-    const sortBy = ['wagonNumber', 'tareWeight', 'maxPayloadWeight', 'status', 'sequenceNumber'].includes(query.sortBy ?? '')
+    const sortBy = ['wagonNumber', 'tareWeight', 'maxPayloadWeight', 'status', 'readiness', 'sequenceNumber'].includes(query.sortBy ?? '')
      ? (query.sortBy as keyof Wagon)
      : 'wagonNumber';
    const sortOrder = query.sortOrder?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';

    return this.wagonRepo.find({
-      where: search ? where : { ...(status ? { status } : {}), ...(trainId ? { trainId } : {}) },
+      where: search ? where : filters,
      order: { [sortBy]: sortOrder } as FindOptionsOrder<Wagon>,
      skip: query.page && query.limit ? (Number(query.page) - 1) * Number(query.limit) : undefined,
      take: query.limit ? Number(query.limit) : undefined,
@@ -72,7 +82,7 @@ export class WagonsService {

  async assignToTrain(wagonId: string, dto: AssignWagonToTrainDto): Promise<Wagon> {
    const wagon = await this.findById(wagonId);
-    if (wagon.status === 'ASSIGNED') {
+    if (wagon.status === WagonStatus.Assigned) {
      throw new ConflictException('Wagon already assigned to a train');
    }

@@ -91,7 +101,7 @@ export class WagonsService {

    wagon.trainId = train.id;
    wagon.sequenceNumber = sequence;
-    wagon.status = 'ASSIGNED';
+    wagon.status = WagonStatus.Assigned;
    return this.wagonRepo.save(wagon);
  }

@@ -99,7 +109,7 @@ export class WagonsService {
    const wagon = await this.findById(wagonId);
    wagon.trainId = null;
    wagon.sequenceNumber = null;
-    wagon.status = 'AVAILABLE';
+    wagon.status = WagonStatus.Available;
    return this.wagonRepo.save(wagon);
  }