Merge branch 'test/sales' of https://gitea.hexdive.com/New_REP_SYSTEM/ERP-core into test/sales

.gitignore

@@ -36,4 +36,12 @@ Testing/e2e/test-results/
 Testing/e2e/.auth/
 Testing/e2e/blob-report/
 
-
+# ── Migrations ─────────────────────────────────────────────────────────
+# Reverted 2026-07-31: excluding new EF Core migrations while
+# ErpDbContextModelSnapshot.cs stayed tracked meant every `dotnet ef
+# migrations add` after the initial 4 silently produced a migration git would
+# never see, while the (tracked) snapshot's changes committed normally —
+# so the snapshot kept claiming tables existed that no migration in git
+# history ever created them. Confirmed live: 25 HRM tables + 11 Manufacturing
+# tables were missing from the actual database for exactly this reason.
+# Migrations now stay tracked like any other source file — commit them.

Backend/ERPCore.Tests/ERPCore.Tests.csproj

@@ -1,26 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.9" />
-    <PackageReference Include="coverlet.collector" Version="6.0.4" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
-    <PackageReference Include="xunit" Version="2.9.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\ERPCore\ERPCore.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Using Include="Xunit" />
-  </ItemGroup>
-
-</Project>

Backend/ERPCore.Tests/NotificationConfigServiceTests.cs

@@ -1,152 +0,0 @@
-using ERPCore.Domain.Entities;
-using ERPCore.Domain.Notifications;
-using ERPCore.Repositories;
-using ERPCore.Services;
-using ERPCore.System.Errors;
-using ERPCore.Tests.TestSupport;
-using Microsoft.EntityFrameworkCore;
-
-namespace ERPCore.Tests;
-
-public class NotificationConfigServiceTests
-{
-    [Fact]
-    public async Task GetAsync_MergesSavedValuesWithDiscoveredModules()
-    {
-        var dbName = Guid.NewGuid().ToString("N");
-        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
-        await NotificationConfigTestSupport.SeedAsync(db, new[]
-        {
-            new NotificationConfigModule
-            {
-                ModuleKey = "sale.create",
-                EmailEnabled = true,
-                SmsEnabled = false,
-                InAppEnabled = true
-            }
-        });
-
-        var service = CreateService(db);
-
-        var result = await service.GetAsync();
-
-        Assert.Equal(7u, result.RowVersion);
-        Assert.Contains(result.Value.Modules, m => m.ModuleKey == "sale.create" && m.EmailEnabled && !m.SmsEnabled && m.InAppEnabled);
-        Assert.Contains(result.Value.Modules, m => m.ModuleKey == "grn.confirmed" && !m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
-    }
-
-    [Fact]
-    public async Task UpdateAsync_PersistsEmptyAndMultiChannelSelections()
-    {
-        var dbName = Guid.NewGuid().ToString("N");
-        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
-        await NotificationConfigTestSupport.SeedAsync(db);
-
-        var service = CreateService(db);
-        var catalog = new NotificationModuleCatalog();
-        var request = new ERPCore.Dtos.Notifications.UpdateNotificationConfigRequest
-        {
-            Modules = catalog.GetAll().Select((module, index) => new ERPCore.Dtos.Notifications.UpdateNotificationModuleRequest
-            {
-                ModuleKey = module.Key,
-                EmailEnabled = index == 0,
-                SmsEnabled = index == 1,
-                InAppEnabled = index == 1
-            }).ToList()
-        };
-
-        var updated = await service.UpdateAsync(request, 7);
-
-        Assert.Equal(7u, updated.RowVersion);
-        Assert.Contains(updated.Value.Modules, m => m.ModuleKey == catalog.GetAll()[0].Key && m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
-        Assert.Contains(updated.Value.Modules, m => m.ModuleKey == catalog.GetAll()[1].Key && !m.EmailEnabled && m.SmsEnabled && m.InAppEnabled);
-
-        await using var verifyDb = NotificationConfigTestSupport.CreateContext(dbName);
-        var persisted = await verifyDb.NotificationConfigModules.AsNoTracking().ToListAsync();
-        Assert.Contains(persisted, m => m.ModuleKey == catalog.GetAll()[0].Key && m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
-        Assert.Contains(persisted, m => m.ModuleKey == catalog.GetAll()[1].Key && !m.EmailEnabled && m.SmsEnabled && m.InAppEnabled);
-    }
-
-    [Fact]
-    public async Task ResolveEnabledChannelsAsync_ReturnsEmptyWhenNothingEnabled()
-    {
-        var dbName = Guid.NewGuid().ToString("N");
-        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
-        await NotificationConfigTestSupport.SeedAsync(db, new[]
-        {
-            new NotificationConfigModule
-            {
-                ModuleKey = "sale.create",
-                EmailEnabled = false,
-                SmsEnabled = false,
-                InAppEnabled = false
-            }
-        });
-
-        var service = CreateService(db);
-
-        var channels = await service.ResolveEnabledChannelsAsync("sale.create");
-
-        Assert.Empty(channels);
-    }
-
-    [Fact]
-    public async Task ResolveEnabledChannelsAsync_ReturnsMultipleChannels()
-    {
-        var dbName = Guid.NewGuid().ToString("N");
-        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
-        await NotificationConfigTestSupport.SeedAsync(db, new[]
-        {
-            new NotificationConfigModule
-            {
-                ModuleKey = "sale.create",
-                EmailEnabled = true,
-                SmsEnabled = true,
-                InAppEnabled = false
-            }
-        });
-
-        var service = CreateService(db);
-
-        var channels = await service.ResolveEnabledChannelsAsync("sale.create");
-
-        Assert.Equal(new[] { NotificationChannel.Email, NotificationChannel.Sms }, channels);
-    }
-
-    [Fact]
-    public async Task UpdateAsync_MapsConcurrencyFailuresToDomainException()
-    {
-        var dbName = Guid.NewGuid().ToString("N");
-        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
-        await NotificationConfigTestSupport.SeedAsync(db);
-
-        var service = CreateService(db, new ThrowingUnitOfWork());
-        var catalog = new NotificationModuleCatalog();
-        var request = new ERPCore.Dtos.Notifications.UpdateNotificationConfigRequest
-        {
-            Modules = catalog.GetAll().Select(module => new ERPCore.Dtos.Notifications.UpdateNotificationModuleRequest
-            {
-                ModuleKey = module.Key,
-                EmailEnabled = false,
-                SmsEnabled = false,
-                InAppEnabled = false
-            }).ToList()
-        };
-
-        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(request, 7));
-        Assert.Equal(ErrorCodes.ConcurrencyConflict, ex.Code);
-        Assert.Equal(412, ex.StatusCode);
-    }
-
-    private static NotificationConfigService CreateService(ERPCore.Infra.Persistence.ErpDbContext db, ERPCore.Infra.UoW.IUnitOfWork? uow = null)
-    {
-        var configRepo = new Repository<NotificationConfig>(db);
-        var moduleRepo = new Repository<NotificationConfigModule>(db);
-        return new NotificationConfigService(
-            configRepo,
-            moduleRepo,
-            new NotificationModuleCatalog(),
-            new TestCurrentUser(),
-            uow ?? new ERPCore.Infra.UoW.UnitOfWork(db));
-    }
-}

Backend/ERPCore.Tests/NotificationModuleCatalogTests.cs

@@ -1,17 +0,0 @@
-using ERPCore.Services;
-
-namespace ERPCore.Tests;
-
-public class NotificationModuleCatalogTests
-{
-    [Fact]
-    public void GetAll_ReturnsStableUniqueModuleKeys()
-    {
-        var catalog = new NotificationModuleCatalog();
-
-        Assert.NotEmpty(catalog.GetAll());
-        Assert.Contains(catalog.GetAll(), m => m.Key == "sale.create");
-        Assert.Contains(catalog.GetAll(), m => m.Key == "grn.confirmed");
-        Assert.Equal(catalog.GetAll().Count, catalog.GetAll().Select(m => m.Key).Distinct(StringComparer.OrdinalIgnoreCase).Count());
-    }
-}

Backend/ERPCore.Tests/TestSupport/NotificationConfigTestSupport.cs

@@ -1,70 +0,0 @@
-using ERPCore.Domain.Entities;
-using ERPCore.Infra.Auth;
-using ERPCore.Infra.Persistence;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Storage;
-
-namespace ERPCore.Tests.TestSupport;
-
-internal sealed class TestCurrentUser : ICurrentUser
-{
-    public string UserId => "system";
-    public int AuditUserId => User.SystemUserId;
-    public bool IsAuthenticated => false;
-}
-
-internal sealed class ThrowingUnitOfWork : ERPCore.Infra.UoW.IUnitOfWork
-{
-    public Task<int> SaveChangesAsync(CancellationToken ct = default)
-        => throw new DbUpdateConcurrencyException("Test concurrency conflict.");
-
-    public Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken ct = default)
-        => throw new NotSupportedException();
-
-    public Task<T> ExecuteInTransactionAsync<T>(Func<CancellationToken, Task<T>> action, CancellationToken ct = default)
-        => throw new NotSupportedException();
-}
-
-internal static class NotificationConfigTestSupport
-{
-    private static readonly InMemoryDatabaseRoot Root = new();
-
-    public static ErpDbContext CreateContext(string name)
-    {
-        var options = new DbContextOptionsBuilder<ErpDbContext>()
-            .UseInMemoryDatabase(name, Root)
-            .Options;
-
-        return new ErpDbContext(options, new TestCurrentUser());
-    }
-
-    public static async Task SeedAsync(ErpDbContext db, IEnumerable<NotificationConfigModule>? modules = null)
-    {
-        db.Users.Add(new User
-        {
-            UserId = User.SystemUserId,
-            Username = "system",
-            DisplayName = "System"
-        });
-
-        var config = new NotificationConfig
-        {
-            NotificationConfigId = NotificationConfig.SingletonId,
-            UpdatedBy = User.SystemUserId,
-            UpdatedAt = DateTime.UtcNow,
-            RowVersion = 7,
-        };
-
-        if (modules is not null)
-        {
-            foreach (var module in modules)
-            {
-                module.NotificationConfigId = NotificationConfig.SingletonId;
-                config.Modules.Add(module);
-            }
-        }
-
-        db.NotificationConfig.Add(config);
-        await db.SaveChangesAsync();
-    }
-}

Backend/ERPCore/Controllers/AuthController.cs

@@ -27,15 +27,13 @@ public sealed class AuthController : ControllerBase
     private readonly IAuthRecoveryService _recovery;
     private readonly IAuthAltService _alt;
     private readonly IRoleService _roles;
-    private readonly IAuditService _audit;
 
-    public AuthController(IAuthUserService users, IAuthRecoveryService recovery, IAuthAltService alt, IRoleService roles, IAuditService audit)
+    public AuthController(IAuthUserService users, IAuthRecoveryService recovery, IAuthAltService alt, IRoleService roles)
     {
         _users = users;
         _recovery = recovery;
         _alt = alt;
         _roles = roles;
-        _audit = audit;
     }
 
     /// <summary>
@@ -70,7 +68,6 @@ public sealed class AuthController : ControllerBase
     {
         var result = await _users.LoginAsync(request, ct);
         AuthCookieWriter.WriteSession(Response, result.AccessToken, result.RefreshToken, result.Body.ExpiresIn);
-        if (result.Body.User?.UserId is Guid authUserId) await _audit.RecordLoginAsync(authUserId, ClientIp(), ClientUserAgent(), ct);
         return Ok(result.Body);
     }
 
@@ -81,13 +78,9 @@ public sealed class AuthController : ControllerBase
     {
         var result = await _users.VerifyOtpForLoginAsync(request, ct);
         AuthCookieWriter.WriteSession(Response, result.AccessToken, result.RefreshToken, result.Body.ExpiresIn);
-        if (result.Body.User?.UserId is Guid authUserId) await _audit.RecordLoginAsync(authUserId, ClientIp(), ClientUserAgent(), ct);
         return Ok(result.Body);
     }
 
-    private string? ClientIp() => HttpContext.Connection.RemoteIpAddress?.ToString();
-    private string? ClientUserAgent() => Request.Headers.UserAgent.ToString() is { Length: > 0 } ua ? ua : null;
-
     [HttpPost("refresh-token")]
     [AllowAnonymous]
     [ProducesResponseType(typeof(AuthSessionResponse), StatusCodes.Status200OK)]

Backend/ERPCore/Controllers/BranchConfigController.cs

@@ -1,44 +0,0 @@
-using ERPCore.Dtos.Config;
-using ERPCore.Services.Interfaces;
-using Microsoft.AspNetCore.Mvc;
-
-namespace ERPCore.Controllers;
-
-/// <summary>
-/// Branch configuration endpoints — the singleton toggle for whether this deployment
-/// requires a branch on Employee/Warehouse records at all.
-/// <para>
-/// <b>Authorization:</b> writes are admitted by the inherited ERP door policy only, same
-/// Phase-1 posture as <see cref="ProductConfigController"/> — any ERP-admitted user can
-/// flip this flag until per-endpoint RBAC lands.
-/// </para>
-/// </summary>
-[Route("api/v1/branch-config")]
-public sealed class BranchConfigController : ApiControllerBase
-{
-    private readonly IBranchConfigService _config;
-
-    public BranchConfigController(IBranchConfigService config) => _config = config;
-
-    [HttpGet]
-    [ProducesResponseType(typeof(BranchConfigDto), StatusCodes.Status200OK)]
-    public async Task<ActionResult<BranchConfigDto>> Get(CancellationToken ct)
-    {
-        var result = await _config.GetAsync(ct);
-        SetETag(result.RowVersion);
-        return Ok(result.Value);
-    }
-
-    [HttpPut]
-    [ProducesResponseType(typeof(BranchConfigDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
-    public async Task<ActionResult<BranchConfigDto>> Update(
-        [FromBody] UpdateBranchConfigRequest request, CancellationToken ct)
-    {
-        var expected = RequireIfMatch();
-        var result = await _config.UpdateAsync(request, expected, ct);
-        SetETag(result.RowVersion);
-        return Ok(result.Value);
-    }
-}

Backend/ERPCore/Controllers/BundleSalesController.cs

@@ -29,14 +29,6 @@ public sealed class BundleSalesController : ApiControllerBase
         return result is null ? NotFound() : Ok(result);
     }
 
-    [HttpPost("templates")]
-    [ProducesResponseType(typeof(BundleSaleTemplateDto), StatusCodes.Status201Created)]
-    public async Task<ActionResult<BundleSaleTemplateDto>> CreateTemplate([FromBody] CreateBundleSaleTemplateRequest request, CancellationToken ct)
-    {
-        var result = await _bundles.CreateTemplateAsync(request, ct);
-        return Created($"/api/v1/bundle-sales/templates/{result.BundleSaleTemplateId}", result);
-    }
-
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<BundleSaleSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<BundleSaleSummaryDto>>> List(

Backend/ERPCore/Controllers/DashboardController.cs

@@ -15,6 +15,6 @@ public sealed class DashboardController : ApiControllerBase
     /// <summary>Aggregate counts for stock, GRN, and procurement.</summary>
     [HttpGet("stats")]
     [ProducesResponseType(typeof(DashboardStatsDto), StatusCodes.Status200OK)]
-    public async Task<ActionResult<DashboardStatsDto>> GetStats([FromQuery] int? branchId, CancellationToken ct)
-        => Ok(await _dashboard.GetStatsAsync(branchId, ct));
+    public async Task<ActionResult<DashboardStatsDto>> GetStats(CancellationToken ct)
+        => Ok(await _dashboard.GetStatsAsync(ct));
 }

Backend/ERPCore/Controllers/GrnsController.cs

@@ -12,18 +12,15 @@ public sealed class GrnsController : ApiControllerBase
 {
     private readonly IGrnService _grns;
 
-    public GrnsController(IGrnService grns)
-    {
-        _grns = grns;
-    }
+    public GrnsController(IGrnService grns) => _grns = grns;
 
     /// <summary>List GRNs, newest first.</summary>
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<GrnSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<GrnSummaryDto>>> List(
         [FromQuery] PageQuery query, [FromQuery] GrnStatus? status, [FromQuery] int? poId,
-        [FromQuery] int? vendorId, [FromQuery] int? warehouseId, [FromQuery] int? branchId, CancellationToken ct)
-        => Ok(await _grns.ListAsync(query, status, poId, vendorId, warehouseId, branchId, ct));
+        [FromQuery] int? vendorId, [FromQuery] int? warehouseId, CancellationToken ct)
+        => Ok(await _grns.ListAsync(query, status, poId, vendorId, warehouseId, ct));
 
     [HttpGet("{grnId:int}")]
     [ProducesResponseType(typeof(GrnDto), StatusCodes.Status200OK)]

Backend/ERPCore/Controllers/Hrm/BranchesController.cs

@@ -61,14 +61,4 @@ public sealed class BranchesController : ApiControllerBase
         await _branches.SetStatusAsync(branchId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{branchId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int branchId, CancellationToken ct)
-    {
-        await _branches.DeleteAsync(branchId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/DepartmentsController.cs

@@ -62,14 +62,4 @@ public sealed class DepartmentsController : ApiControllerBase
         await _departments.SetStatusAsync(departmentId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{departmentId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int departmentId, CancellationToken ct)
-    {
-        await _departments.DeleteAsync(departmentId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/DesignationsController.cs

@@ -61,14 +61,4 @@ public sealed class DesignationsController : ApiControllerBase
         await _designations.SetStatusAsync(designationId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{designationId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int designationId, CancellationToken ct)
-    {
-        await _designations.DeleteAsync(designationId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/EmployeesController.cs

@@ -83,6 +83,7 @@ public sealed class EmployeesController : ApiControllerBase
         return Ok(result.Value);
     }
 
+    /// <summary>Never a hard delete — Employee is retained forever (docs/12-BACKEND-HRM.md C.2).</summary>
     [HttpPatch("{employeeId:int}/status")]
     [ProducesResponseType(StatusCodes.Status204NoContent)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
@@ -92,17 +93,6 @@ public sealed class EmployeesController : ApiControllerBase
         return NoContent();
     }
 
-    /// <summary>Permanently deletes the employee and all dependent HR records. Blocked (409) if payroll history exists.</summary>
-    [HttpDelete("{employeeId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int employeeId, CancellationToken ct)
-    {
-        await _employees.DeleteAsync(employeeId, ct);
-        return NoContent();
-    }
-
     [HttpPost("{employeeId:int}/link-user")]
     [ProducesResponseType(StatusCodes.Status204NoContent)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]

Backend/ERPCore/Controllers/Hrm/EmploymentTypesController.cs

@@ -61,14 +61,4 @@ public sealed class EmploymentTypesController : ApiControllerBase
         await _employmentTypes.SetStatusAsync(employmentTypeId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{employmentTypeId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int employmentTypeId, CancellationToken ct)
-    {
-        await _employmentTypes.DeleteAsync(employmentTypeId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/HrDocumentTypesController.cs

@@ -61,14 +61,4 @@ public sealed class HrDocumentTypesController : ApiControllerBase
         await _types.SetStatusAsync(hrDocumentTypeId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{hrDocumentTypeId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int hrDocumentTypeId, CancellationToken ct)
-    {
-        await _types.DeleteAsync(hrDocumentTypeId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/LeaveTypesController.cs

@@ -61,14 +61,4 @@ public sealed class LeaveTypesController : ApiControllerBase
         await _leaveTypes.SetStatusAsync(leaveTypeId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{leaveTypeId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int leaveTypeId, CancellationToken ct)
-    {
-        await _leaveTypes.DeleteAsync(leaveTypeId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/SalaryComponentsController.cs

@@ -61,14 +61,4 @@ public sealed class SalaryComponentsController : ApiControllerBase
         await _components.SetStatusAsync(salaryComponentId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{salaryComponentId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int salaryComponentId, CancellationToken ct)
-    {
-        await _components.DeleteAsync(salaryComponentId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/Hrm/WorkShiftsController.cs

@@ -61,14 +61,4 @@ public sealed class WorkShiftsController : ApiControllerBase
         await _shifts.SetStatusAsync(workShiftId, request.Status, ct);
         return NoContent();
     }
-
-    [HttpDelete("{workShiftId:int}")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<IActionResult> Delete(int workShiftId, CancellationToken ct)
-    {
-        await _shifts.DeleteAsync(workShiftId, ct);
-        return NoContent();
-    }
 }

Backend/ERPCore/Controllers/ItemsController.cs

@@ -81,4 +81,11 @@ public sealed class ItemsController : ApiControllerBase
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     public async Task<ActionResult<ItemReorderSettingsDto>> UpdateReorder(int itemId, [FromBody] UpdateReorderRequest request, CancellationToken ct)
         => Ok(await _items.UpdateReorderAsync(itemId, request, ct));
+
+    /// <summary>Replace the item's UOM conversions (FR-MD-02).</summary>
+    [HttpPut("{itemId:int}/uom-conversions")]
+    [ProducesResponseType(typeof(ItemUomConversionsDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ItemUomConversionsDto>> UpdateUomConversions(int itemId, [FromBody] UpdateUomConversionsRequest request, CancellationToken ct)
+        => Ok(await _items.UpdateUomConversionsAsync(itemId, request, ct));
 }

Backend/ERPCore/Controllers/NotificationConfigController.cs

@@ -1,34 +0,0 @@
-using ERPCore.Dtos.Notifications;
-using ERPCore.Services.Interfaces;
-using Microsoft.AspNetCore.Mvc;
-
-namespace ERPCore.Controllers;
-
-[Route("api/v1/notification-config")]
-public sealed class NotificationConfigController : ApiControllerBase
-{
-    private readonly INotificationConfigService _config;
-
-    public NotificationConfigController(INotificationConfigService config) => _config = config;
-
-    [HttpGet]
-    [ProducesResponseType(typeof(NotificationConfigDto), StatusCodes.Status200OK)]
-    public async Task<ActionResult<NotificationConfigDto>> Get(CancellationToken ct)
-    {
-        var result = await _config.GetAsync(ct);
-        SetETag(result.RowVersion);
-        return Ok(result.Value);
-    }
-
-    [HttpPut]
-    [ProducesResponseType(typeof(NotificationConfigDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
-    public async Task<ActionResult<NotificationConfigDto>> Update([FromBody] UpdateNotificationConfigRequest request, CancellationToken ct)
-    {
-        var expected = RequireIfMatch();
-        var result = await _config.UpdateAsync(request, expected, ct);
-        SetETag(result.RowVersion);
-        return Ok(result.Value);
-    }
-}

Backend/ERPCore/Controllers/ProductionRunsController.cs

@@ -24,19 +24,6 @@ public sealed class ProductionRunsController : ApiControllerBase
         CancellationToken ct)
         => Ok(await _runs.ListAsync(query, status, templateId, warehouseId, ct));
 
-    /// <summary>Produced-items report (FR-MFG-13): one row per run that has produced
-    /// something, plus a summary total over every filtered row.</summary>
-    [HttpGet("produced")]
-    [ProducesResponseType(typeof(ProducedListResponseDto), StatusCodes.Status200OK)]
-    public async Task<ActionResult<ProducedListResponseDto>> ListProduced(
-        [FromQuery] DateOnly? from,
-        [FromQuery] DateOnly? to,
-        [FromQuery] int? templateId,
-        [FromQuery] int? warehouseId,
-        [FromQuery] ProductionRunStatus? status,
-        CancellationToken ct)
-        => Ok(await _runs.ListProducedAsync(from, to, templateId, warehouseId, status, ct));
-
     [HttpGet("{runId:int}")]
     [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]

Backend/ERPCore/Controllers/PurchaseInvoicesController.cs

@@ -1,102 +0,0 @@
-using ERPCore.Domain.Enums;
-using ERPCore.Dtos.Common;
-using ERPCore.Dtos.Grn;
-using ERPCore.Dtos.Procurement;
-using ERPCore.Services.Interfaces;
-using Microsoft.AspNetCore.Mvc;
-
-namespace ERPCore.Controllers;
-
-/// <summary>Purchase invoice endpoints — vendor invoices consolidating Confirmed GRNs.</summary>
-[Route("api/v1/purchase-invoices")]
-public sealed class PurchaseInvoicesController : ApiControllerBase
-{
-    private readonly IPurchaseInvoiceService _invoices;
-    private readonly IPurchaseInvoicePaymentService _payments;
-
-    public PurchaseInvoicesController(IPurchaseInvoiceService invoices, IPurchaseInvoicePaymentService payments)
-    {
-        _invoices = invoices;
-        _payments = payments;
-    }
-
-    [HttpGet]
-    [ProducesResponseType(typeof(PagedResponse<PurchaseInvoiceSummaryDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<PurchaseInvoiceSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] PurchaseInvoiceStatus? status, [FromQuery] int? vendorId, CancellationToken ct)
-        => Ok(await _invoices.ListAsync(query, status, vendorId, ct));
-
-    /// <summary>Confirmed, not-yet-invoiced GRNs for a vendor — candidates for a new/edited invoice.</summary>
-    [HttpGet("eligible-grns")]
-    [ProducesResponseType(typeof(IReadOnlyList<GrnEligibleForInvoiceDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<IReadOnlyList<GrnEligibleForInvoiceDto>>> EligibleGrns([FromQuery] int vendorId, CancellationToken ct)
-        => Ok(await _invoices.ListEligibleGrnsAsync(vendorId, ct));
-
-    [HttpGet("{purchaseInvoiceId:int}")]
-    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<PurchaseInvoiceDto>> GetById(int purchaseInvoiceId, CancellationToken ct)
-    {
-        var result = await _invoices.GetAsync(purchaseInvoiceId, ct);
-        if (result is null) return NotFound();
-        SetETag(result.RowVersion);
-        return Ok(result.Value);
-    }
-
-    [HttpPost]
-    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status201Created)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
-    public async Task<ActionResult<PurchaseInvoiceDto>> Create([FromBody] CreatePurchaseInvoiceRequest request, CancellationToken ct)
-    {
-        var result = await _invoices.CreateAsync(request, ct);
-        SetETag(result.RowVersion);
-        return Created($"/api/v1/purchase-invoices/{result.Value.PurchaseInvoiceId}", result.Value);
-    }
-
-    [HttpPut("{purchaseInvoiceId:int}")]
-    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
-    public async Task<ActionResult<PurchaseInvoiceDto>> Update(int purchaseInvoiceId, [FromBody] UpdatePurchaseInvoiceRequest request, CancellationToken ct)
-    {
-        var expected = RequireIfMatch();
-        var result = await _invoices.UpdateAsync(purchaseInvoiceId, request, expected, ct);
-        SetETag(result.RowVersion);
-        return Ok(result.Value);
-    }
-
-    [HttpPost("{purchaseInvoiceId:int}/post")]
-    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<ActionResult<PurchaseInvoiceDto>> Post(int purchaseInvoiceId, CancellationToken ct)
-        => Ok(await _invoices.PostAsync(purchaseInvoiceId, ct));
-
-    [HttpPost("{purchaseInvoiceId:int}/cancel")]
-    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<ActionResult<PurchaseInvoiceDto>> Cancel(int purchaseInvoiceId, CancellationToken ct)
-        => Ok(await _invoices.CancelAsync(purchaseInvoiceId, ct));
-
-    /// <summary>Pay the vendor against this invoice's balance, in full or in installments; posts a real GL journal entry.</summary>
-    [HttpPost("{purchaseInvoiceId:int}/payments")]
-    [ProducesResponseType(typeof(PurchaseInvoicePaymentDto), StatusCodes.Status201Created)]
-    [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<ActionResult<PurchaseInvoicePaymentDto>> Pay(int purchaseInvoiceId, [FromBody] CreatePurchaseInvoicePaymentRequest request, CancellationToken ct)
-    {
-        var dto = await _payments.PayAsync(purchaseInvoiceId, request, ct);
-        return Created($"/api/v1/purchase-invoices/{purchaseInvoiceId}/payments/{dto.PurchaseInvoicePaymentId}", dto);
-    }
-
-    /// <summary>Payment history for this invoice, newest first.</summary>
-    [HttpGet("{purchaseInvoiceId:int}/payments")]
-    [ProducesResponseType(typeof(IReadOnlyList<PurchaseInvoicePaymentDto>), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<IReadOnlyList<PurchaseInvoicePaymentDto>>> ListPayments(int purchaseInvoiceId, CancellationToken ct)
-        => Ok(await _payments.ListAsync(purchaseInvoiceId, ct));
-}

Backend/ERPCore/Controllers/SalesDayEndController.cs

@@ -1,50 +0,0 @@
-using ERPCore.Dtos.Common;
-using ERPCore.Dtos.Sales;
-using ERPCore.Services.Interfaces;
-using Microsoft.AspNetCore.Mvc;
-
-namespace ERPCore.Controllers;
-
-/// <summary>Cashier day-end close-out — locks a cashier's Posted sales slips for a business
-/// date and posts one consolidated GL journal entry for the day (docs/14 Sales API).</summary>
-[Route("api/v1/sales-day-end")]
-public sealed class SalesDayEndController : ApiControllerBase
-{
-    private readonly ISalesDayEndService _dayEnds;
-
-    public SalesDayEndController(ISalesDayEndService dayEnds) => _dayEnds = dayEnds;
-
-    /// <summary>List day-end closes, newest first.</summary>
-    [HttpGet]
-    [ProducesResponseType(typeof(PagedResponse<SalesDayEndSummaryDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<SalesDayEndSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] int? cashierUserId, CancellationToken ct)
-        => Ok(await _dayEnds.ListAsync(query, cashierUserId, ct));
-
-    /// <summary>What closing this cashier/date right now would include (or the existing close's totals, if already closed).</summary>
-    [HttpGet("preview")]
-    [ProducesResponseType(typeof(SalesDayEndPreviewDto), StatusCodes.Status200OK)]
-    public async Task<ActionResult<SalesDayEndPreviewDto>> Preview(
-        [FromQuery] int cashierUserId, [FromQuery] DateOnly? businessDate, CancellationToken ct)
-        => Ok(await _dayEnds.PreviewAsync(cashierUserId, businessDate ?? DateOnly.FromDateTime(DateTime.UtcNow), ct));
-
-    [HttpGet("{salesDayEndId:int}")]
-    [ProducesResponseType(typeof(SalesDayEndDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<SalesDayEndDto>> GetById(int salesDayEndId, CancellationToken ct)
-    {
-        var dto = await _dayEnds.GetAsync(salesDayEndId, ct);
-        return dto is null ? NotFound() : Ok(dto);
-    }
-
-    /// <summary>Close the day: lock every Posted slip for (CashierUserId, BusinessDate) and post the
-    /// consolidated GL journal entry. Idempotent — closing an already-closed date replays it.</summary>
-    [HttpPost]
-    [ProducesResponseType(typeof(SalesDayEndDto), StatusCodes.Status201Created)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<ActionResult<SalesDayEndDto>> Close([FromBody] CreateSalesDayEndRequest request, CancellationToken ct)
-    {
-        var dto = await _dayEnds.CloseAsync(request, ct);
-        return Created($"/api/v1/sales-day-end/{dto.SalesDayEndId}", dto);
-    }
-}

Backend/ERPCore/Controllers/SalesInvoicesController.cs

@@ -10,13 +10,8 @@ namespace ERPCore.Controllers;
 public sealed class SalesInvoicesController : ApiControllerBase
 {
     private readonly ISalesInvoiceService _invoices;
-    private readonly ISalesInvoicePaymentService _payments;
 
-    public SalesInvoicesController(ISalesInvoiceService invoices, ISalesInvoicePaymentService payments)
-    {
-        _invoices = invoices;
-        _payments = payments;
-    }
+    public SalesInvoicesController(ISalesInvoiceService invoices) => _invoices = invoices;
 
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<SalesInvoiceSummaryDto>), StatusCodes.Status200OK)]
@@ -25,9 +20,8 @@ public sealed class SalesInvoicesController : ApiControllerBase
         [FromQuery] SalesInvoiceStatus? status,
         [FromQuery] int? customerId,
         [FromQuery] int? warehouseId,
-        [FromQuery] int? branchId,
         CancellationToken ct)
-        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, branchId, ct));
+        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, ct));
 
     [HttpGet("{salesInvoiceId:int}")]
     [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
@@ -76,23 +70,4 @@ public sealed class SalesInvoicesController : ApiControllerBase
     [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
     public async Task<ActionResult<SalesInvoiceDto>> Cancel(int salesInvoiceId, CancellationToken ct)
         => Ok(await _invoices.CancelAsync(salesInvoiceId, ct));
-
-    /// <summary>Pay the customer's balance against this invoice, in full or in installments; posts a real GL journal entry.</summary>
-    [HttpPost("{salesInvoiceId:int}/payments")]
-    [ProducesResponseType(typeof(SalesInvoicePaymentDto), StatusCodes.Status201Created)]
-    [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    public async Task<ActionResult<SalesInvoicePaymentDto>> Pay(int salesInvoiceId, [FromBody] CreateSalesInvoicePaymentRequest request, CancellationToken ct)
-    {
-        var dto = await _payments.PayAsync(salesInvoiceId, request, ct);
-        return Created($"/api/v1/sales-invoices/{salesInvoiceId}/payments/{dto.SalesInvoicePaymentId}", dto);
-    }
-
-    /// <summary>Payment history for this invoice, newest first.</summary>
-    [HttpGet("{salesInvoiceId:int}/payments")]
-    [ProducesResponseType(typeof(IReadOnlyList<SalesInvoicePaymentDto>), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<IReadOnlyList<SalesInvoicePaymentDto>>> ListPayments(int salesInvoiceId, CancellationToken ct)
-        => Ok(await _payments.ListAsync(salesInvoiceId, ct));
 }

Backend/ERPCore/Controllers/SalesReturnsController.cs

@@ -1,49 +0,0 @@
-using ERPCore.Dtos.Common;
-using ERPCore.Dtos.Sales;
-using ERPCore.Services.Interfaces;
-using Microsoft.AspNetCore.Mvc;
-
-namespace ERPCore.Controllers;
-
-/// <summary>Sales-return endpoints — customer returns of previously sold goods.</summary>
-[Route("api/v1/sales-returns")]
-public sealed class SalesReturnsController : ApiControllerBase
-{
-    private readonly ISalesReturnService _returns;
-
-    public SalesReturnsController(ISalesReturnService returns) => _returns = returns;
-
-    /// <summary>List posted returns, newest first.</summary>
-    [HttpGet]
-    [ProducesResponseType(typeof(PagedResponse<SalesReturnSummaryDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<SalesReturnSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] int? customerId, [FromQuery] int? warehouseId, CancellationToken ct)
-        => Ok(await _returns.ListAsync(query, customerId, warehouseId, ct));
-
-    /// <summary>Remaining returnable qty per line of one sales invoice (invoiced qty minus already-returned).</summary>
-    [HttpGet("remaining")]
-    [ProducesResponseType(typeof(IReadOnlyList<SalesInvoiceLineRemainingDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<IReadOnlyList<SalesInvoiceLineRemainingDto>>> GetRemaining([FromQuery] int salesInvoiceId, CancellationToken ct)
-        => Ok(await _returns.GetRemainingByInvoiceAsync(salesInvoiceId, ct));
-
-    /// <summary>Get one return with its lines and the ledger entries it posted.</summary>
-    [HttpGet("{returnId:int}")]
-    [ProducesResponseType(typeof(SalesReturnDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<SalesReturnDto>> GetById(int returnId, CancellationToken ct)
-    {
-        var dto = await _returns.GetAsync(returnId, ct);
-        return dto is null ? NotFound() : Ok(dto);
-    }
-
-    /// <summary>Create + auto-post a return (inbound movement).</summary>
-    [HttpPost]
-    [ProducesResponseType(typeof(SalesReturnDto), StatusCodes.Status201Created)]
-    [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
-    public async Task<ActionResult<SalesReturnDto>> Create([FromBody] CreateSalesReturnRequest request, CancellationToken ct)
-    {
-        var dto = await _returns.CreateAsync(request, ct);
-        return Created($"/api/v1/sales-returns/{dto.ReturnId}", dto);
-    }
-}

Backend/ERPCore/Controllers/StockAdjustmentsController.cs

@@ -17,8 +17,8 @@ public sealed class StockAdjustmentsController : ApiControllerBase
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<AdjustmentSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<AdjustmentSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] int? reasonCodeId, CancellationToken ct)
-        => Ok(await _adjustments.ListAsync(query, warehouseId, branchId, reasonCodeId, ct));
+        [FromQuery] PageQuery query, [FromQuery] int? warehouseId, [FromQuery] int? reasonCodeId, CancellationToken ct)
+        => Ok(await _adjustments.ListAsync(query, warehouseId, reasonCodeId, ct));
 
     /// <summary>Get one adjustment with its lines and the ledger entries it posted.</summary>
     [HttpGet("{adjustmentId:int}")]

Backend/ERPCore/Controllers/StockController.cs

@@ -28,8 +28,8 @@ public sealed class StockController : ApiControllerBase
     [HttpGet("on-hand/list")]
     [ProducesResponseType(typeof(PagedResponse<StockOnHandDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<StockOnHandDto>>> OnHandList(
-        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _stock.GetOnHandListAsync(itemId, warehouseId, branchId, query, ct));
+        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _stock.GetOnHandListAsync(itemId, warehouseId, query, ct));
 
     /// <summary>
     /// Immutable movement history. <c>sourceDocType</c>/<c>sourceDocId</c> answer "what did
@@ -39,11 +39,11 @@ public sealed class StockController : ApiControllerBase
     [HttpGet("ledger")]
     [ProducesResponseType(typeof(PagedResponse<StockLedgerRowDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<StockLedgerRowDto>>> Ledger(
-        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] int? branchId,
+        [FromQuery] int? itemId, [FromQuery] int? warehouseId,
         [FromQuery] DateOnly? from, [FromQuery] DateOnly? to,
         [FromQuery] string? sourceDocType, [FromQuery] int? sourceDocId,
         [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _stock.GetLedgerAsync(itemId, warehouseId, branchId, from, to, sourceDocType, sourceDocId, query, ct));
+        => Ok(await _stock.GetLedgerAsync(itemId, warehouseId, from, to, sourceDocType, sourceDocId, query, ct));
 
     [HttpGet("valuation")]
     [ProducesResponseType(typeof(StockValuationDto), StatusCodes.Status200OK)]
@@ -54,8 +54,8 @@ public sealed class StockController : ApiControllerBase
     [HttpGet("reorder-alerts")]
     [ProducesResponseType(typeof(PagedResponse<ReorderAlertDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<ReorderAlertDto>>> ReorderAlerts(
-        [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _reorder.GetAlertsAsync(warehouseId, branchId, query, ct));
+        [FromQuery] int? warehouseId, [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _reorder.GetAlertsAsync(warehouseId, query, ct));
 
     /// <summary>Create a draft requisition for an item's suggested reorder quantity.</summary>
     [HttpPost("reorder-alerts/{itemId:int}/requisition")]

Backend/ERPCore/Controllers/StockCountsController.cs

@@ -18,8 +18,8 @@ public sealed class StockCountsController : ApiControllerBase
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<CountSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<CountSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] CountStatus? status, [FromQuery] int? warehouseId, [FromQuery] int? branchId, CancellationToken ct)
-        => Ok(await _counts.ListAsync(query, status, warehouseId, branchId, ct));
+        [FromQuery] PageQuery query, [FromQuery] CountStatus? status, [FromQuery] int? warehouseId, CancellationToken ct)
+        => Ok(await _counts.ListAsync(query, status, warehouseId, ct));
 
     [HttpGet("{countId:int}")]
     [ProducesResponseType(typeof(CountDto), StatusCodes.Status200OK)]

Backend/ERPCore/Controllers/StockTransfersController.cs

@@ -19,8 +19,8 @@ public sealed class StockTransfersController : ApiControllerBase
     [ProducesResponseType(typeof(PagedResponse<TransferSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<TransferSummaryDto>>> List(
         [FromQuery] PageQuery query, [FromQuery] TransferStatus? status,
-        [FromQuery] int? srcWarehouseId, [FromQuery] int? destWarehouseId, [FromQuery] int? branchId, CancellationToken ct)
-        => Ok(await _transfers.ListAsync(query, status, srcWarehouseId, destWarehouseId, branchId, ct));
+        [FromQuery] int? srcWarehouseId, [FromQuery] int? destWarehouseId, CancellationToken ct)
+        => Ok(await _transfers.ListAsync(query, status, srcWarehouseId, destWarehouseId, ct));
 
     [HttpGet("{transferId:int}")]
     [ProducesResponseType(typeof(TransferDto), StatusCodes.Status200OK)]

Backend/ERPCore/Controllers/UsersController.cs

@@ -1,9 +1,6 @@
-using ERPCore.Domain.Enums;
-using ERPCore.Dtos.Audit;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Hrm;
 using ERPCore.Dtos.Users;
-using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
@@ -18,15 +15,11 @@ public sealed class UsersController : ApiControllerBase
 {
     private readonly IUserManagementService _users;
     private readonly IEmployeeUserLinkService _links;
-    private readonly IAuditService _audit;
-    private readonly ICurrentUser _currentUser;
 
-    public UsersController(IUserManagementService users, IEmployeeUserLinkService links, IAuditService audit, ICurrentUser currentUser)
+    public UsersController(IUserManagementService users, IEmployeeUserLinkService links)
     {
         _users = users;
         _links = links;
-        _audit = audit;
-        _currentUser = currentUser;
     }
 
     /// <summary>Advisory forward-direction lookup: does a Staff record already exist with this email? (docs/12-BACKEND-HRM.md A.5)</summary>
@@ -37,8 +30,8 @@ public sealed class UsersController : ApiControllerBase
 
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<ManagedUserDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<ManagedUserDto>>> List([FromQuery] PageQuery query, [FromQuery] EntityStatus? status, [FromQuery] string? roleCode, CancellationToken ct)
-        => Ok(await _users.ListAsync(query, status, roleCode, ct));
+    public async Task<ActionResult<PagedResponse<ManagedUserDto>>> List([FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _users.ListAsync(query, ct));
 
     /// <summary>AuthHex UserType options for the create-user form's select.</summary>
     [HttpGet("user-types")]
@@ -60,7 +53,7 @@ public sealed class UsersController : ApiControllerBase
     [ProducesResponseType(StatusCodes.Status409Conflict)]
     public async Task<ActionResult<ManagedUserDto>> Create([FromBody] CreateUserRequest request, CancellationToken ct)
     {
-        var result = await _users.CreateAsync(request, _currentUser.AuditUserId, ct);
+        var result = await _users.CreateAsync(request, ct);
         return Created($"/api/v1/users/{result.UserId}", result);
     }
 
@@ -69,18 +62,4 @@ public sealed class UsersController : ApiControllerBase
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     public async Task<ActionResult<ManagedUserDto>> UpdateRole(int userId, [FromBody] UpdateUserRoleRequest request, CancellationToken ct)
         => Ok(await _users.UpdateRoleAsync(userId, request, ct));
-
-    /// <summary>Revokes/restores standing inside ERPCore only — see <see cref="IUserManagementService.SetStatusAsync"/>.</summary>
-    [HttpPatch("{userId:int}/status")]
-    [ProducesResponseType(typeof(ManagedUserDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<ManagedUserDto>> UpdateStatus(int userId, [FromBody] UpdateUserStatusRequest request, CancellationToken ct)
-        => Ok(await _users.SetStatusAsync(userId, request.Status, ct));
-
-    /// <summary>Device/login history ERPCore captures itself — not AuthHex's "currently active sessions"
-    /// (which only ever reports the caller's own). See <see cref="IAuditService.ListLoginDevicesAsync"/>.</summary>
-    [HttpGet("{userId:int}/login-devices")]
-    [ProducesResponseType(typeof(PagedResponse<LoginActivityDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<LoginActivityDto>>> ListLoginDevices(int userId, [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _audit.ListLoginDevicesAsync(userId, query, ct));
 }

Backend/ERPCore/Controllers/WarehousesController.cs

@@ -15,9 +15,8 @@ public sealed class WarehousesController : ApiControllerBase
 
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<WarehouseDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<WarehouseDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] int? branchId, CancellationToken ct)
-        => Ok(await _warehouses.ListAsync(query, branchId, ct));
+    public async Task<ActionResult<PagedResponse<WarehouseDto>>> List([FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _warehouses.ListAsync(query, ct));
 
     [HttpGet("{warehouseId:int}")]
     [ProducesResponseType(typeof(WarehouseDto), StatusCodes.Status200OK)]

Backend/ERPCore/Domain/DocumentTypes.cs

@@ -10,7 +10,6 @@ public static class DocumentTypes
     public const string Rfq = "RFQ";
     public const string PurchaseOrder = "PO";
     public const string Grn = "GRN";
-    public const string PurchaseInvoice = "PINV";
     public const string Transfer = "TRF";
     public const string Adjustment = "ADJ";
     public const string Count = "CNT";
@@ -21,9 +20,4 @@ public static class DocumentTypes
     public const string SalesInvoice = "SI";
     public const string SalesSlip = "SSL";
     public const string BundleSale = "BND";
-    public const string BundleSaleTemplate = "TPL";
-    public const string SalesReturn = "SRET";
-
-    /// <summary>Cashier day-end close-out (Sales) — <c>DEND-2026-00001</c>.</summary>
-    public const string SalesDayEnd = "DEND";
 }

Backend/ERPCore/Domain/Entities/Branch.cs

@@ -3,19 +3,16 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Branch/location master (FR-HR-MD-01) — multi-branch readiness. Required by
-/// <see cref="Employee.BranchId"/>, optionally referenced by <see cref="PayrollRun.BranchId"/>.
+/// Branch/location master (FR-HR-MD-01) — multi-branch readiness. Referenced
+/// optionally by <see cref="Employee.BranchId"/> and <see cref="PayrollRun.BranchId"/>.
 /// Deactivated, not deleted, when referenced. Model: docs/12-BACKEND-HRM.md Part C.1.
 /// </summary>
 public class Branch
 {
     public int BranchId { get; set; }
-
-    /// <summary>Server-generated on create ("BR-001", "BR-002", ...) — never accepted from the client.</summary>
     public string Code { get; set; } = string.Empty;
     public string Name { get; set; } = string.Empty;
     public string? Address { get; set; }
-    public string? PhoneNumber { get; set; }
     public EntityStatus Status { get; set; } = EntityStatus.Active;
 
     public DateTime CreatedAt { get; set; }

Backend/ERPCore/Domain/Entities/BranchConfig.cs

@@ -1,27 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// Branch configuration — a singleton row (single-tenant, docs/00-CORE §1) gating whether
-/// this deployment uses branches at all. When <see cref="BranchingEnabled"/> is off, the
-/// Employee/Warehouse create forms stop asking for a branch and every new record is
-/// silently assigned to the deployment's one default branch instead — schema-wise
-/// <c>Employee.BranchId</c>/<c>Warehouse.BranchId</c> stay <c>NOT NULL</c> either way, only
-/// the UI/UX requirement toggles. See <see cref="Services.BranchConfigService.ResolveBranchIdAsync"/>.
-/// </summary>
-public class BranchConfig
-{
-    /// <summary>Always 1 - the singleton row's id.</summary>
-    public const int SingletonId = 1;
-
-    public int ConfigId { get; set; }
-
-    public bool BranchingEnabled { get; set; } = true;
-
-    public DateTime? UpdatedAt { get; set; }
-
-    public int? UpdatedBy { get; set; }
-    public User? UpdatedByUser { get; set; }
-
-    /// <summary>PostgreSQL xmin-backed optimistic concurrency token (ETag source).</summary>
-    public uint RowVersion { get; set; }
-}

Backend/ERPCore/Domain/Entities/BundleSale.cs

@@ -29,11 +29,5 @@ public class BundleSale
     public DateTime? UpdatedAt { get; set; }
     public int ConcurrencyStamp { get; set; }
 
-    /// <summary>Set once this bundle's business date is closed by <see cref="SalesDayEnd"/> — a
-    /// closed bundle sale is frozen (no further edits). Same role as <see cref="SalesSlip.DayEndId"/>;
-    /// a bundle sale is a cashier document exactly like a sales slip, just priced as a set.</summary>
-    public int? DayEndId { get; set; }
-    public SalesDayEnd? DayEnd { get; set; }
-
     public ICollection<BundleSaleLine> Lines { get; set; } = new List<BundleSaleLine>();
 }

Backend/ERPCore/Domain/Entities/BundleSaleLine.cs

@@ -12,6 +12,8 @@ public class BundleSaleLine
     public Item? Item { get; set; }
     public string Description { get; set; } = string.Empty;
     public decimal Qty { get; set; }
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
     public decimal UnitPrice { get; set; }

Backend/ERPCore/Domain/Entities/BundleSaleTemplateLine.cs

@@ -8,6 +8,8 @@ public class BundleSaleTemplateLine
 
     public int ItemId { get; set; }
     public Item? Item { get; set; }
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 

Backend/ERPCore/Domain/Entities/Employee.cs

@@ -6,10 +6,8 @@ namespace ERPCore.Domain.Entities;
 /// Staff record (FR-HR-MD-02) — distinct from <see cref="User"/> (the system login
 /// account): not every employee has a login, and not every login belongs to an
 /// employee. <see cref="UserId"/> is the optional, explicit, human-confirmed link
-/// between the two (docs/12-BACKEND-HRM.md A.5/C.2, Part B.3.2). Normal separation is
-/// recorded via <see cref="Status"/> + <see cref="LastWorkingDate"/> rather than deletion;
-/// an explicit hard delete is also available (<see cref="Services.Interfaces.IEmployeeService.DeleteAsync"/>)
-/// and cascades to every dependent HR record, blocked only if payroll history exists.
+/// between the two (docs/12-BACKEND-HRM.md A.5/C.2, Part B.3.2). Never hard-deleted —
+/// separation is recorded via <see cref="Status"/> + <see cref="LastWorkingDate"/>.
 /// <see cref="EmployeeCode"/> is user-entered (not <see cref="NumberSequence"/>-issued):
 /// HR departments keep their own legacy numbering scheme, and NumberSequence's
 /// year-scoping is the wrong shape for an identifier that must never look "reset".
@@ -52,7 +50,7 @@ public class Employee
     public Designation? Designation { get; set; }
     public int EmploymentTypeId { get; set; }
     public EmploymentType? EmploymentType { get; set; }
-    public int BranchId { get; set; }
+    public int? BranchId { get; set; }
     public Branch? Branch { get; set; }
     public int WorkShiftId { get; set; }
     public WorkShift? WorkShift { get; set; }

Backend/ERPCore/Domain/Entities/Grn.cs

@@ -22,11 +22,6 @@ public class Grn
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 
-    /// <summary>Owning branch, set explicitly at creation — warehouses are shared across
-    /// branches, so branch scope can no longer be derived from <see cref="Warehouse"/>.</summary>
-    public int BranchId { get; set; }
-    public Branch? Branch { get; set; }
-
     public GrnStatus Status { get; set; } = GrnStatus.Draft;
 
     public int CreatedBy { get; set; }
@@ -35,16 +30,6 @@ public class Grn
     public DateTime CreatedAt { get; set; }
     public DateTime? PostedAt { get; set; }
 
-    /// <summary>Journal number of the real GL journal entry posted for this GRN's receipt (set on confirm).</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
-    /// <summary>The Purchase Invoice this GRN has been consolidated into, if any (null until
-    /// invoiced). Vendor settlement is tracked on the invoice, not per-GRN — see
-    /// <see cref="PurchaseInvoice"/>.</summary>
-    public int? PurchaseInvoiceId { get; set; }
-    public PurchaseInvoice? PurchaseInvoice { get; set; }
-
     /// <summary>PostgreSQL xmin-backed optimistic concurrency token.</summary>
     public uint RowVersion { get; set; }
 

Backend/ERPCore/Domain/Entities/GrnLine.cs

@@ -25,6 +25,9 @@ public class GrnLine
     public int ItemId { get; set; }
     public Item? Item { get; set; }
 
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+
     public int? BinId { get; set; }
     public Bin? Bin { get; set; }
 
@@ -58,11 +61,4 @@ public class GrnLine
     public decimal LineTotal { get; set; }
 
     public HoldStatus HoldStatus { get; set; } = HoldStatus.Available;
-
-    /// <summary>
-    /// One row per received unit when <see cref="Item.Warranty"/> is
-    /// <see cref="Enums.Warranty.Warranty"/> — count must equal <see cref="Qty"/>.
-    /// Empty for a non-warranty item.
-    /// </summary>
-    public ICollection<GrnLineWarrantyNumber> WarrantyNumbers { get; set; } = new List<GrnLineWarrantyNumber>();
 }

Backend/ERPCore/Domain/Entities/GrnLineWarrantyNumber.cs

@@ -1,20 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// One warranty number captured against a single received unit of a warranty-tracked
-/// item (<see cref="Item.Warranty"/> = <see cref="Enums.Warranty.Warranty"/>). A GRN line
-/// for such an item must carry exactly <see cref="GrnLine.Qty"/> of these — one per unit —
-/// mirroring how a Serial-tracked item requires one serial per unit (docs/10 Part C.3).
-/// </summary>
-public class GrnLineWarrantyNumber
-{
-    public int GrnLineWarrantyNumberId { get; set; }
-
-    public int GrnLineId { get; set; }
-    public GrnLine? GrnLine { get; set; }
-
-    public string WarrantyNo { get; set; } = string.Empty;
-
-    /// <summary>Warranty coverage length in months, selected at receipt (e.g. 3/6/12/18).</summary>
-    public int WarrantyPeriodMonths { get; set; }
-}

Backend/ERPCore/Domain/Entities/Item.cs

@@ -24,12 +24,6 @@ public class Item
     public int? BrandId { get; set; }
     public Brand? Brand { get; set; }
 
-    /// <summary>
-    /// The stocking unit — the pack the item is counted in (BOTTLE, PACKET, BOX, PCS).
-    /// <b>Every</b> quantity in the system is a count of these: stock layers, the ledger,
-    /// and every document line. Nothing converts, so this is the sole meaning of a
-    /// quantity and cannot be changed once the item has stock history.
-    /// </summary>
     public int BaseUomId { get; set; }
     public Uom? BaseUom { get; set; }
 
@@ -38,46 +32,14 @@ public class Item
 
     public StockNature StockNature { get; set; }
     public TrackingMode TrackingMode { get; set; }
-    public Warranty Warranty { get; set; } = Warranty.NonWarranty;
-    /// <summary>Coverage length in months (see <see cref="Enums.WarrantyPeriods.AllowedMonths"/>) when <see cref="Warranty"/> is Warranty; null otherwise.</summary>
-    public int? WarrantyPeriodMonths { get; set; }
     public string? TaxClass { get; set; }
 
     /// <summary>
-    /// Optional selling price range and flat price used by Sales only.
-    /// <c>null</c> values mean the field is not set. These values never enter costing/GRN/FIFO.
+    /// Optional fixed selling price used by Sales only. <c>null</c> means "use stock value"
+    /// (the item is sold at its FIFO stock cost at sale time); a value is the fixed sale price.
+    /// Never enters costing/GRN/FIFO (docs/10 Part C.1, C.9).
     /// </summary>
-    public decimal? SellingMinPrice { get; set; }
-    public decimal? SellingMaxPrice { get; set; }
-    public decimal? SellingFlatPrice { get; set; }
-
-    /// <summary>
-    /// How much one pack holds, as the user entered it — <c>500</c> with
-    /// <see cref="ContentUnit"/> <c>Ml</c> for a 500 ml bottle, <c>1.5</c> with <c>L</c>
-    /// for a 1.5 L one. Null (together with the other three) when the item has no
-    /// measurable content: a screw, a label, a service.
-    /// <para>
-    /// Content never affects stock — that is always a pack count. It exists so production
-    /// can express a formula in millilitres or grams and resolve it to packs
-    /// (see <c>IItemMeasure</c>).
-    /// </para>
-    /// <para>
-    /// A loose bulk item bought by weight is modelled the same way:
-    /// <c>BaseUom = KG, ContentQty = 1, ContentUnit = Kg</c> ⇒ 1000 g per stocked unit.
-    /// </para>
-    /// </summary>
-    public decimal? ContentQty { get; set; }
-    public MeasureUnit? ContentUnit { get; set; }
-
-    /// <summary>
-    /// <see cref="ContentQty"/>/<see cref="ContentUnit"/> normalised to a base unit
-    /// (L→Ml, Kg→G, both ×1000) at write time by <c>ItemContent.Normalize</c>. Server-derived
-    /// and never accepted from a client. <see cref="ContentBaseUnit"/> is therefore only ever
-    /// <see cref="MeasureUnit.Ml"/> or <see cref="MeasureUnit.G"/>.
-    /// <para>Stored rather than recomputed so every consumer reads one settled number.</para>
-    /// </summary>
-    public decimal? ContentBaseQty { get; set; }
-    public MeasureUnit? ContentBaseUnit { get; set; }
+    public decimal? SalePrice { get; set; }
 
     public EntityStatus Status { get; set; } = EntityStatus.Active;
 
@@ -88,4 +50,5 @@ public class Item
     public uint RowVersion { get; set; }
 
     public ICollection<ItemReorder> ReorderSettings { get; set; } = new List<ItemReorder>();
+    public ICollection<UomConversion> UomConversions { get; set; } = new List<UomConversion>();
 }

Backend/ERPCore/Domain/Entities/ItemType.cs

@@ -7,15 +7,12 @@ namespace ERPCore.Domain.Entities;
 /// Material.
 /// <para>
 /// <b>Deliberately unlinked.</b> Nothing references this entity and it references
-/// nothing: there is no value table and no join to <see cref="Item"/>. The chosen
+/// nothing: there is no value table and no join to <see cref="Item"/>. Its only job is
+/// to feed the frontend's item-builder dropdown via <c>GET /item-types</c>. The chosen
 /// values (Red, S, M) are encoded by the client into the generated SKU
 /// (e.g. <c>BL-100-0003</c>) and are never stored or parsed server-side — the item list
 /// is the record of what was built. See the accepted trade-off in docs/10 Part C.9.
 /// </para>
-/// <para>
-/// It does, however, carry one piece of meaning the client acts on:
-/// <see cref="IsMeasurable"/>. So this is no longer purely a dropdown source.
-/// </para>
 /// Not to be confused with <see cref="Enums.StockNature"/> (Stocked/NonStocked/Service),
 /// which is what the old <c>ItemType</c> enum became.
 /// Model: docs/10-BACKEND-PHASE1.md Part C.1.
@@ -24,24 +21,6 @@ public class ItemType
 {
     public int ItemTypeId { get; set; }
     public string Name { get; set; } = string.Empty;
-
-    /// <summary>
-    /// When true, this dimension's values are content <b>measurements</b> (500 ml, 1 L) rather
-    /// than plain labels (Red, S). The item builder then captures a number + unit per value and
-    /// stamps that pair onto each generated item's <see cref="Item.ContentQty"/> /
-    /// <see cref="Item.ContentUnit"/>, instead of copying one form-level pair into every variant
-    /// — which is what makes "Coca-Cola in 500 ml / 1 L / 250 ml" three correctly sized items.
-    /// <para>
-    /// This is what lets an apparel <c>Size</c> (S/M/L) stay plain text while a
-    /// <c>Pack Size</c>/<c>Volume</c> dimension carries ml/g/L/kg.
-    /// </para>
-    /// <para>
-    /// A client hint only: the server never reads it when writing an item. Each item's pair is
-    /// still validated and normalised on its own by <c>ItemContent</c>.
-    /// </para>
-    /// </summary>
-    public bool IsMeasurable { get; set; }
-
     public EntityStatus Status { get; set; } = EntityStatus.Active;
 
     public DateTime CreatedAt { get; set; }

Backend/ERPCore/Domain/Entities/LoginActivity.cs

@@ -1,22 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// One row per successful sign-in, captured directly by ERPCore (not AuthHex) so an
-/// admin can see a user's device/login history — AuthHex's own session listing only
-/// ever reports the currently-authenticated caller's own sessions, with no admin-scoped
-/// call to inspect anyone else's. This is a history of past logins, not a live "currently
-/// active sessions" view (that would need AuthHex to expose one).
-/// </summary>
-public class LoginActivity
-{
-    public int LoginActivityId { get; set; }
-    public int UserId { get; set; }
-    public User? User { get; set; }
-
-    public string? IpAddress { get; set; }
-    public string? UserAgent { get; set; }
-    /// <summary>Best-effort "Browser on OS" label parsed from <see cref="UserAgent"/> for display.</summary>
-    public string? DeviceLabel { get; set; }
-
-    public DateTime LoginAt { get; set; }
-}

Backend/ERPCore/Domain/Entities/NotificationConfig.cs

@@ -1,19 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// Notification configuration (new settings module) - singleton root row.
-/// </summary>
-public class NotificationConfig
-{
-    public const int SingletonId = 1;
-
-    public int NotificationConfigId { get; set; }
-
-    public DateTime? UpdatedAt { get; set; }
-    public int? UpdatedBy { get; set; }
-    public User? UpdatedByUser { get; set; }
-
-    public uint RowVersion { get; set; }
-
-    public ICollection<NotificationConfigModule> Modules { get; set; } = new List<NotificationConfigModule>();
-}

Backend/ERPCore/Domain/Entities/NotificationConfigModule.cs

@@ -1,14 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-public class NotificationConfigModule
-{
-    public int NotificationConfigModuleId { get; set; }
-
-    public int NotificationConfigId { get; set; }
-    public NotificationConfig? NotificationConfig { get; set; }
-
-    public string ModuleKey { get; set; } = string.Empty;
-    public bool EmailEnabled { get; set; }
-    public bool SmsEnabled { get; set; }
-    public bool InAppEnabled { get; set; }
-}

Backend/ERPCore/Domain/Entities/PoLine.cs

@@ -15,6 +15,9 @@ public class PoLine
     public int ItemId { get; set; }
     public Item? Item { get; set; }
 
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 

Backend/ERPCore/Domain/Entities/ProductConfig.cs

@@ -1,24 +1,22 @@
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Product configuration (FR-MD-11) - a singleton row (single-tenant, docs/00-CORE §1)
+/// Product configuration (FR-MD-11) — a <b>singleton row</b> (single-tenant, docs/00-CORE §1)
 /// gating optional product master-data features.
 /// <para>
 /// <see cref="SubcategoriesEnabled"/> and <see cref="BrandsEnabled"/> are enforced
 /// server-side: an Item write carrying a subcategory/brand while the flag is off is
-/// rejected with <c>CONFIG_DISABLED</c>. <see cref="ItemTypesEnabled"/> is advisory only
-/// - items carry no item-type reference (see <see cref="ItemType"/>), so there is nothing
-/// on a write to reject; the frontend honours it by hiding the variant builder.
-/// <see cref="SellingPricesEnabled"/>, <see cref="SerialNumbersEnabled"/>,
-/// <see cref="BatchListsEnabled"/> and <see cref="WarrantyPeriodsEnabled"/> are enforced
-/// on item writes and drive the create/edit screens. Reads are never gated, so existing
-/// data stays visible after a flag is switched off.
+/// rejected with <c>CONFIG_DISABLED</c>. <see cref="ItemTypesEnabled"/> is
+/// <b>advisory only</b> — items carry no item-type reference (see <see cref="ItemType"/>),
+/// so there is nothing on a write to reject; the frontend honours it by hiding the
+/// builder's type section. Reads are never gated, so existing data stays visible after a
+/// flag is switched off.
 /// </para>
 /// Model: docs/10-BACKEND-PHASE1.md Part C.1.
 /// </summary>
 public class ProductConfig
 {
-    /// <summary>Always 1 - the singleton row's id.</summary>
+    /// <summary>Always 1 — the singleton row's id.</summary>
     public const int SingletonId = 1;
 
     public int ConfigId { get; set; }
@@ -26,10 +24,6 @@ public class ProductConfig
     public bool SubcategoriesEnabled { get; set; } = true;
     public bool BrandsEnabled { get; set; } = true;
     public bool ItemTypesEnabled { get; set; } = true;
-    public bool SellingPricesEnabled { get; set; } = true;
-    public bool SerialNumbersEnabled { get; set; } = true;
-    public bool BatchListsEnabled { get; set; } = true;
-    public bool WarrantyPeriodsEnabled { get; set; } = true;
 
     public DateTime? UpdatedAt { get; set; }
 

Backend/ERPCore/Domain/Entities/PurchaseInvoice.cs

@@ -1,50 +0,0 @@
-using ERPCore.Domain.Enums;
-
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// Vendor invoice consolidating one or more Confirmed GRNs for the same vendor
-/// (each linked GRN becomes one <see cref="PurchaseInvoiceLine"/>, not re-itemized).
-/// Draft is editable (GRNs can be re-selected); Posted reclassifies the GRN clearing
-/// balance to Accounts Payable (see PurchaseInvoiceService.PostAsync); vendor payments
-/// are then recorded against this aggregate rather than against the individual GRNs.
-/// </summary>
-public class PurchaseInvoice
-{
-    public int PurchaseInvoiceId { get; set; }
-    public string DocNo { get; set; } = string.Empty;
-
-    public string VendorInvoiceNo { get; set; } = string.Empty;
-    public DateTime VendorInvoiceDate { get; set; }
-
-    public int VendorId { get; set; }
-    public Vendor? Vendor { get; set; }
-
-    public string VendorSnapshotName { get; set; } = string.Empty;
-    public string? VendorSnapshotTaxNo { get; set; }
-
-    public PurchaseInvoiceStatus Status { get; set; } = PurchaseInvoiceStatus.Draft;
-
-    public decimal Subtotal { get; set; }
-    public decimal VatTotal { get; set; }
-    public decimal GrandTotal { get; set; }
-    public decimal PaidAmount { get; set; }
-    public decimal BalanceAmount { get; set; }
-
-    /// <summary>Journal number of the AP-recognition GL journal entry posted when this
-    /// invoice is Posted (Debit GRN Clearing / Credit Accounts Payable) — see
-    /// PurchaseInvoiceService.PostAsync.</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
-    public int CreatedBy { get; set; }
-    public User? Creator { get; set; }
-
-    public DateTime CreatedAt { get; set; }
-    public DateTime? UpdatedAt { get; set; }
-
-    public uint RowVersion { get; set; }
-
-    public ICollection<PurchaseInvoiceLine> Lines { get; set; } = new List<PurchaseInvoiceLine>();
-    public ICollection<PurchaseInvoicePayment> Payments { get; set; } = new List<PurchaseInvoicePayment>();
-}

Backend/ERPCore/Domain/Entities/PurchaseInvoiceLine.cs

@@ -1,21 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// One row per consolidated GRN on a <see cref="PurchaseInvoice"/> — a straight
-/// consolidation of that GRN's line totals, not a re-itemization (docs: Purchase
-/// Invoice consolidates GRNs, it does not re-enter item lines).
-/// </summary>
-public class PurchaseInvoiceLine
-{
-    public int PurchaseInvoiceLineId { get; set; }
-
-    public int PurchaseInvoiceId { get; set; }
-    public PurchaseInvoice? PurchaseInvoice { get; set; }
-
-    public int GrnId { get; set; }
-    public Grn? Grn { get; set; }
-
-    public decimal Subtotal { get; set; }
-    public decimal VatTotal { get; set; }
-    public decimal LineTotal { get; set; }
-}

Backend/ERPCore/Domain/Entities/PurchaseInvoicePayment.cs

@@ -1,32 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// A vendor payment made against a Posted purchase invoice's balance (installments
-/// allowed — see PurchaseInvoicePaymentService.PayAsync). Posts its own real GL
-/// journal entry (Debit Accounts Payable / Credit the selected bank-or-cash account)
-/// before being recorded here.
-/// </summary>
-public class PurchaseInvoicePayment
-{
-    public int PurchaseInvoicePaymentId { get; set; }
-
-    public int PurchaseInvoiceId { get; set; }
-    public PurchaseInvoice? PurchaseInvoice { get; set; }
-
-    public decimal Amount { get; set; }
-    public DateTime PaymentDate { get; set; }
-
-    /// <summary>GL's numeric id for the bank/cash account the payment was made from.</summary>
-    public long GlBankAccountId { get; set; }
-    /// <summary>Snapshot of the account's display name at payment time (GL account lists have no local FK).</summary>
-    public string BankAccountName { get; set; } = string.Empty;
-
-    public string? Reference { get; set; }
-
-    /// <summary>Journal number of the real GL journal entry this payment posted.</summary>
-    public string? GlJournalNo { get; set; }
-
-    public int CreatedBy { get; set; }
-    public User? Creator { get; set; }
-    public DateTime CreatedAt { get; set; }
-}

Backend/ERPCore/Domain/Entities/PurchaseReturn.cs

@@ -28,12 +28,5 @@ public class PurchaseReturn
 
     public DateTime CreatedAt { get; set; }
 
-    /// <summary>Journal number of the real GL journal entry posted for this return (set on create — it auto-posts).
-    /// Reverses the Inventory/Clearing lines a Grn posts — <see cref="PurchaseReturnLine"/> carries no unit
-    /// price/VAT of its own, so it can't reverse a VAT-recoverable line the way a real credit note would.</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
     public ICollection<PurchaseReturnLine> Lines { get; set; } = new List<PurchaseReturnLine>();
 }
-

Backend/ERPCore/Domain/Entities/RunStageInput.cs

@@ -31,14 +31,10 @@ public class RunStageInput
     public int? FromRunOutputId { get; set; }
     public RunStageOutput? FromRunOutput { get; set; }
 
-    /// <summary>Copied from the template input: what <see cref="PlannedQty"/> is expressed in.</summary>
-    public StageQtyUnit QtyUnit { get; set; } = StageQtyUnit.Pack;
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
 
-    /// <summary>
-    /// Scaled at creation; per-run editable until the stage starts (FR-MFG-08,
-    /// <c>409 STAGE_NOT_EDITABLE</c>). Expressed in <see cref="QtyUnit"/> — so unlike the
-    /// consumption figures below it is <b>not</b> necessarily a pack count.
-    /// </summary>
+    /// <summary>Scaled at creation; per-run editable until the stage starts (FR-MFG-08, <c>409 STAGE_NOT_EDITABLE</c>).</summary>
     public decimal PlannedQty { get; set; }
 
     /// <summary>

Backend/ERPCore/Domain/Entities/RunStageOutput.cs

@@ -23,17 +23,10 @@ public class RunStageOutput
 
     public string Name { get; set; } = string.Empty;
 
-    /// <summary>
-    /// Display label for intermediate WIP; null on the terminal output, whose unit is the
-    /// finished item's base UOM. Never converted — see <see cref="StageOutput.UomId"/>.
-    /// </summary>
-    public int? UomId { get; set; }
+    public int UomId { get; set; }
     public Uom? Uom { get; set; }
 
-    /// <summary>
-    /// Scaled at creation; per-run editable until the stage starts. Every quantity on an
-    /// output is a pack count, so scrap is recorded in whole broken bottles rather than ml.
-    /// </summary>
+    /// <summary>Scaled at creation; per-run editable until the stage starts.</summary>
     public decimal PlannedQty { get; set; }
 
     /// <summary>Recorded at complete. A re-complete after a rework <b>overwrites</b> this, never adds to it.</summary>

Backend/ERPCore/Domain/Entities/SalesDayEnd.cs

@@ -1,46 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// A cashier's end-of-day close-out. Aggregates every <see cref="SalesSlip"/> the
-/// cashier posted on <see cref="BusinessDate"/>, freezes them against this record
-/// (<see cref="SalesSlip.DayEndId"/>) so a slip can only ever belong to one day-end,
-/// and posts one consolidated GL journal entry for the day's revenue/tax/COGS —
-/// the sales-side equivalent of how <see cref="Grn"/> posts per receipt. Unique per
-/// (CashierUserId, BusinessDate): closing twice replays the existing record instead
-/// of creating a second one (same idempotent-replay pattern as Grn.ConfirmAsync).
-/// </summary>
-public class SalesDayEnd
-{
-    public int SalesDayEndId { get; set; }
-    public string DocNo { get; set; } = string.Empty;
-
-    public int CashierUserId { get; set; }
-    public User? CashierUser { get; set; }
-
-    /// <summary>The calendar date being closed (matched against each slip's <see cref="SalesSlip.SlipDate"/>, UTC).</summary>
-    public DateOnly BusinessDate { get; set; }
-
-    public int SlipCount { get; set; }
-    public int BundleCount { get; set; }
-    public decimal Subtotal { get; set; }
-    public decimal DiscountTotal { get; set; }
-    public decimal TaxTotal { get; set; }
-    public decimal GrandTotal { get; set; }
-
-    /// <summary>Sum of the FIFO cost consumed for these slips (from <see cref="StockLedger"/>), for the COGS GL lines.</summary>
-    public decimal CostOfGoodsSold { get; set; }
-
-    /// <summary>Journal number of the real GL journal entry posted for this close (null when there was nothing to post).</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
-    public int ClosedBy { get; set; }
-    public User? ClosedByUser { get; set; }
-    public DateTime ClosedAt { get; set; }
-
-    /// <summary>PostgreSQL xmin-backed optimistic concurrency token.</summary>
-    public uint RowVersion { get; set; }
-
-    public ICollection<SalesSlip> Slips { get; set; } = new List<SalesSlip>();
-    public ICollection<BundleSale> BundleSales { get; set; } = new List<BundleSale>();
-}

Backend/ERPCore/Domain/Entities/SalesInvoice.cs

@@ -17,11 +17,6 @@ public class SalesInvoice
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 
-    /// <summary>Owning branch, set explicitly at creation — warehouses are shared across
-    /// branches, so branch scope can no longer be derived from <see cref="Warehouse"/>.</summary>
-    public int BranchId { get; set; }
-    public Branch? Branch { get; set; }
-
     public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
     public SalesInvoiceStatus Status { get; set; } = SalesInvoiceStatus.Draft;
 
@@ -34,14 +29,6 @@ public class SalesInvoice
     public decimal PaidAmount { get; set; }
     public decimal BalanceAmount { get; set; }
 
-    /// <summary>Journal number of the revenue-recognition GL journal entry posted when this
-    /// invoice is Posted (Debit Accounts Receivable / Credit Sales Revenue + Tax, plus COGS —
-    /// see SalesPostingService.PostInvoiceAsync). Unlike a SalesSlip, an invoice posts its own
-    /// GL entry immediately rather than waiting for Sales Day End, since invoices aren't a
-    /// cashier document and don't go through that close-out.</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
     public int CreatedBy { get; set; }
     public User? Creator { get; set; }
 
@@ -51,5 +38,4 @@ public class SalesInvoice
     public uint RowVersion { get; set; }
 
     public ICollection<SalesInvoiceLine> Lines { get; set; } = new List<SalesInvoiceLine>();
-    public ICollection<SalesInvoicePayment> Payments { get; set; } = new List<SalesInvoicePayment>();
 }

Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs

@@ -16,6 +16,8 @@ public class SalesInvoiceLine
 
     public decimal Qty { get; set; }
     public decimal FreeQty { get; set; }
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 

Backend/ERPCore/Domain/Entities/SalesInvoicePayment.cs

@@ -1,32 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// A customer payment made against a Posted sales invoice's balance (installments
-/// allowed — see SalesInvoicePaymentService.PayAsync). Posts its own real GL journal
-/// entry (Debit the selected bank-or-cash account / Credit Accounts Receivable) before
-/// being recorded here — the mirror image of <see cref="PurchaseInvoicePayment"/>.
-/// </summary>
-public class SalesInvoicePayment
-{
-    public int SalesInvoicePaymentId { get; set; }
-
-    public int SalesInvoiceId { get; set; }
-    public SalesInvoice? SalesInvoice { get; set; }
-
-    public decimal Amount { get; set; }
-    public DateTime PaymentDate { get; set; }
-
-    /// <summary>GL's numeric id for the bank/cash account the payment was received into.</summary>
-    public long GlBankAccountId { get; set; }
-    /// <summary>Snapshot of the account's display name at payment time (GL account lists have no local FK).</summary>
-    public string BankAccountName { get; set; } = string.Empty;
-
-    public string? Reference { get; set; }
-
-    /// <summary>Journal number of the real GL journal entry this payment posted.</summary>
-    public string? GlJournalNo { get; set; }
-
-    public int CreatedBy { get; set; }
-    public User? Creator { get; set; }
-    public DateTime CreatedAt { get; set; }
-}

Backend/ERPCore/Domain/Entities/SalesReturn.cs

@@ -1,38 +0,0 @@
-using ERPCore.Domain.Enums;
-
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// Sales return header — a customer returns previously sold goods, generating an
-/// inbound stock movement. Auto-posts with a mandatory reason code, mirroring
-/// <see cref="PurchaseReturn"/> with the direction reversed.
-/// </summary>
-public class SalesReturn
-{
-    public int ReturnId { get; set; }
-    public string DocNo { get; set; } = string.Empty;
-
-    public int CustomerId { get; set; }
-    public Customer? Customer { get; set; }
-
-    public int WarehouseId { get; set; }
-    public Warehouse? Warehouse { get; set; }
-
-    public int ReasonCodeId { get; set; }
-    public ReasonCode? ReasonCode { get; set; }
-
-    public ReturnStatus Status { get; set; } = ReturnStatus.Posted;
-
-    public int CreatedBy { get; set; }
-    public User? Creator { get; set; }
-
-    public DateTime CreatedAt { get; set; }
-
-    /// <summary>Journal number of the real GL journal entry posted for this return (set on create — it auto-posts).
-    /// Reverses Inventory/COGS only — <see cref="SalesReturnLine"/> carries no unit price, so revenue/tax aren't
-    /// reversed here (they'd need a per-line price this document doesn't capture).</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
-    public ICollection<SalesReturnLine> Lines { get; set; } = new List<SalesReturnLine>();
-}

Backend/ERPCore/Domain/Entities/SalesReturnLine.cs

@@ -1,21 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// Sales-return line referencing the original sales invoice line for traceability.
-/// <see cref="Qty"/> is in base UOM.
-/// </summary>
-public class SalesReturnLine
-{
-    public int ReturnLineId { get; set; }
-
-    public int ReturnId { get; set; }
-    public SalesReturn? Return { get; set; }
-
-    public int? SalesInvoiceLineId { get; set; }
-    public SalesInvoiceLine? SalesInvoiceLine { get; set; }
-
-    public int ItemId { get; set; }
-    public Item? Item { get; set; }
-
-    public decimal Qty { get; set; }
-}

Backend/ERPCore/Domain/Entities/SalesSlip.cs

@@ -27,10 +27,6 @@ public class SalesSlip
     public decimal PaidAmount { get; set; }
     public decimal BalanceAmount { get; set; }
 
-    /// <summary>Set once this slip's business date is closed by <see cref="SalesDayEnd"/> — a closed slip is frozen (no further edits).</summary>
-    public int? DayEndId { get; set; }
-    public SalesDayEnd? DayEnd { get; set; }
-
     public DateTime CreatedAt { get; set; }
     public DateTime? UpdatedAt { get; set; }
 

Backend/ERPCore/Domain/Entities/SalesSlipLine.cs

@@ -16,6 +16,8 @@ public class SalesSlipLine
 
     public decimal Qty { get; set; }
     public decimal FreeQty { get; set; }
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 

Backend/ERPCore/Domain/Entities/StageInput.cs

@@ -32,13 +32,8 @@ public class StageInput
     public int? FromOutputId { get; set; }
     public StageOutput? FromOutput { get; set; }
 
-    /// <summary>
-    /// What <see cref="QtyPerBatch"/> is expressed in. Stock inputs may use
-    /// <see cref="StageQtyUnit.Content"/> (ml/g) when the item has a content size; Upstream
-    /// inputs are always <see cref="StageQtyUnit.Pack"/> — WIP is counted in the unit its
-    /// source output declares.
-    /// </summary>
-    public StageQtyUnit QtyUnit { get; set; } = StageQtyUnit.Pack;
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
 
     public decimal QtyPerBatch { get; set; }
 }

Backend/ERPCore/Domain/Entities/StageOutput.cs

@@ -20,14 +20,8 @@ public class StageOutput
 
     public string Name { get; set; } = string.Empty;
 
-    /// <summary>
-    /// Display label for intermediate work-in-progress. Required when <see cref="ItemId"/>
-    /// is null and must be null when it is set — a real item's unit is its own base UOM.
-    /// WIP never touches stock or the ledger, so this is never converted, only shown.
-    /// </summary>
-    public int? UomId { get; set; }
+    public int UomId { get; set; }
     public Uom? Uom { get; set; }
 
-    /// <summary>Always a pack count: of the WIP unit above, or of the item's base UOM.</summary>
     public decimal QtyPerBatch { get; set; }
 }

Backend/ERPCore/Domain/Entities/StockAdjustment.cs

@@ -19,11 +19,6 @@ public class StockAdjustment
     public int ReasonCodeId { get; set; }
     public ReasonCode? ReasonCode { get; set; }
 
-    /// <summary>Owning branch, set explicitly at creation — warehouses are shared across
-    /// branches, so branch scope can no longer be derived from <see cref="Warehouse"/>.</summary>
-    public int BranchId { get; set; }
-    public Branch? Branch { get; set; }
-
     public AdjustmentStatus Status { get; set; } = AdjustmentStatus.Posted;
 
     public int CreatedBy { get; set; }
@@ -32,10 +27,5 @@ public class StockAdjustment
     public DateTime CreatedAt { get; set; }
     public uint RowVersion { get; set; }
 
-    /// <summary>Journal number of the real GL journal entry posted for this adjustment (set on create — it
-    /// auto-posts). Increases and decreases post separately (never netted) so gains/losses stay visible.</summary>
-    public string? GlJournalNo { get; set; }
-    public DateTime? GlPostedAt { get; set; }
-
     public ICollection<StockAdjustmentLine> Lines { get; set; } = new List<StockAdjustmentLine>();
 }

Backend/ERPCore/Domain/Entities/StockCount.cs

@@ -16,11 +16,6 @@ public class StockCount
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 
-    /// <summary>Owning branch, set explicitly at creation — warehouses are shared across
-    /// branches, so branch scope can no longer be derived from <see cref="Warehouse"/>.</summary>
-    public int BranchId { get; set; }
-    public Branch? Branch { get; set; }
-
     public CountType CountType { get; set; }
     public CountStatus Status { get; set; } = CountStatus.Draft;
 

Backend/ERPCore/Domain/Entities/StockTransfer.cs

@@ -19,11 +19,6 @@ public class StockTransfer
     public int DestWarehouseId { get; set; }
     public Warehouse? DestWarehouse { get; set; }
 
-    /// <summary>Owning branch, set explicitly at creation — warehouses are shared across
-    /// branches, so branch scope can no longer be derived from src/dest warehouse.</summary>
-    public int BranchId { get; set; }
-    public Branch? Branch { get; set; }
-
     public TransferStatus Status { get; set; } = TransferStatus.Draft;
 
     public int CreatedBy { get; set; }

Backend/ERPCore/Domain/Entities/Uom.cs

@@ -1,10 +1,8 @@
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Unit of Measure (FR-MD-02). A flat lookup, used as an item's base UOM — the pack every
-/// quantity in the system counts — and as the display label on an intermediate production
-/// output. There are no conversions between UOMs: an item is stocked in exactly one, and a
-/// differently sized pack is a different item. Model: docs/10-BACKEND-PHASE1.md Part C.1.
+/// Unit of Measure (FR-MD-02). Referenced as an item's base UOM and as the
+/// endpoints of a <see cref="UomConversion"/>. Model: docs/10-BACKEND-PHASE1.md Part C.1.
 /// </summary>
 public class Uom
 {

Backend/ERPCore/Domain/Entities/UomConversion.cs

@@ -0,0 +1,22 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Per-item conversion factor between two UOMs (FR-MD-02/03): quantity in
+/// <see cref="FromUomId"/> × <see cref="Factor"/> = quantity in <see cref="ToUomId"/>.
+/// Model: docs/10-BACKEND-PHASE1.md Part C.1.
+/// </summary>
+public class UomConversion
+{
+    public int ConversionId { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public int FromUomId { get; set; }
+    public Uom? FromUom { get; set; }
+
+    public int ToUomId { get; set; }
+    public Uom? ToUom { get; set; }
+
+    public decimal Factor { get; set; }
+}

Backend/ERPCore/Domain/Entities/Warehouse.cs

@@ -9,8 +9,6 @@ public class Warehouse
     public int WarehouseId { get; set; }
     public string Code { get; set; } = string.Empty;
     public string Name { get; set; } = string.Empty;
-    public int BranchId { get; set; }
-    public Branch? Branch { get; set; }
 
     public ICollection<Bin> Bins { get; set; } = new List<Bin>();
 }

Backend/ERPCore/Domain/Enums/AuditAction.cs

@@ -5,8 +5,5 @@ public enum AuditAction
 {
     Create,
     Update,
-    Delete,
-    /// <summary>A successful sign-in — written explicitly (not via ErpDbContext's automatic
-    /// entity-change capture, since a login mutates nothing) by AuthController.</summary>
-    Login
+    Delete
 }

Backend/ERPCore/Domain/Enums/MeasureUnit.cs

@@ -1,23 +0,0 @@
-namespace ERPCore.Domain.Enums;
-
-/// <summary>
-/// Unit of an item's <b>content size</b> — how much a single stocked pack holds
-/// (a 500 ml bottle, a 50 kg sack). Stored as a string in the database.
-/// <para>
-/// This is <b>not</b> a stocking unit. Stock is always counted in packs
-/// (<c>Item.BaseUomId</c>); content is a separate, optional attribute used by
-/// production to turn "2000 ml of syrup" into a pack count.
-/// </para>
-/// <para>
-/// Only <see cref="Ml"/> and <see cref="G"/> are ever stored as a <i>base</i> content
-/// unit. <see cref="L"/> and <see cref="Kg"/> are entry conveniences normalised ×1000
-/// on write by <c>ItemContent.Normalize</c>, so nothing downstream has to convert.
-/// </para>
-/// </summary>
-public enum MeasureUnit
-{
-    Ml,
-    L,
-    G,
-    Kg
-}

Backend/ERPCore/Domain/Enums/PurchaseInvoiceStatus.cs

@@ -1,8 +0,0 @@
-namespace ERPCore.Domain.Enums;
-
-public enum PurchaseInvoiceStatus
-{
-    Draft,
-    Posted,
-    Cancelled
-}

Backend/ERPCore/Domain/Enums/StageQtyUnit.cs

@@ -1,22 +0,0 @@
-namespace ERPCore.Domain.Enums;
-
-/// <summary>
-/// What a stage input's quantity is expressed in (FR-MFG-04). Stored as a string.
-/// <para>
-/// Deliberately explicit rather than inferred from whether the item happens to have a
-/// content size: templates outlive item edits, so an inferred unit would let adding a
-/// content size to an existing item silently reinterpret every saved formula — "300"
-/// meaning 300 packs would become 300 ml.
-/// </para>
-/// </summary>
-public enum StageQtyUnit
-{
-    /// <summary>A count of the item's base UOM — bottles, packets, pieces.</summary>
-    Pack,
-
-    /// <summary>
-    /// An amount of the item's content in its base content unit (ml or g), resolved to
-    /// packs by <c>IItemMeasure</c> at stage start. Requires the item to have a content size.
-    /// </summary>
-    Content
-}

Backend/ERPCore/Domain/Enums/Warranty.cs

@@ -1,17 +0,0 @@
-namespace ERPCore.Domain.Enums;
-
-/// <summary>
-/// Whether an item is sold under warranty (FR-MD-01). Stored as a string, same
-/// convention as <see cref="StockNature"/> and <see cref="TrackingMode"/>.
-/// </summary>
-public enum Warranty
-{
-    NonWarranty,
-    Warranty
-}
-
-/// <summary>Allowed warranty coverage lengths, in months — set once on the item (FR-MD-01).</summary>
-public static class WarrantyPeriods
-{
-    public static readonly int[] AllowedMonths = { 3, 6, 12, 18 };
-}

Backend/ERPCore/Domain/Notifications/Modules/NotificationModules.cs

@@ -1,34 +0,0 @@
-namespace ERPCore.Domain.Notifications.Modules;
-
-[NotificationModule("sale.create", "Sale Created", "Raised when a sales document is created.", 10)]
-public sealed class SaleCreateNotificationModule;
-
-[NotificationModule("sale.posted", "Sale Posted", "Raised when a sales document is posted.", 20)]
-public sealed class SalePostedNotificationModule;
-
-[NotificationModule("grn.created", "GRN Created", "Raised when a goods receipt note is created.", 30)]
-public sealed class GrnCreatedNotificationModule;
-
-[NotificationModule("grn.confirmed", "GRN Confirmed", "Raised when a goods receipt note is confirmed.", 40)]
-public sealed class GrnConfirmedNotificationModule;
-
-[NotificationModule("purchase.order.created", "Purchase Order Created", "Raised when a purchase order is created.", 50)]
-public sealed class PurchaseOrderCreatedNotificationModule;
-
-[NotificationModule("purchase.order.approved", "Purchase Order Approved", "Raised when a purchase order is approved.", 60)]
-public sealed class PurchaseOrderApprovedNotificationModule;
-
-[NotificationModule("purchase.return.created", "Purchase Return Created", "Raised when a purchase return is created.", 70)]
-public sealed class PurchaseReturnCreatedNotificationModule;
-
-[NotificationModule("stock.adjustment.created", "Stock Adjustment Created", "Raised when a stock adjustment is created.", 80)]
-public sealed class StockAdjustmentCreatedNotificationModule;
-
-[NotificationModule("stock.transfer.created", "Stock Transfer Created", "Raised when a stock transfer is created.", 90)]
-public sealed class StockTransferCreatedNotificationModule;
-
-[NotificationModule("item.created", "Item Created", "Raised when an item master record is created.", 100)]
-public sealed class ItemCreatedNotificationModule;
-
-[NotificationModule("item.updated", "Item Updated", "Raised when an item master record is updated.", 110)]
-public sealed class ItemUpdatedNotificationModule;

Backend/ERPCore/Domain/Notifications/NotificationChannel.cs

@@ -1,8 +0,0 @@
-namespace ERPCore.Domain.Notifications;
-
-public enum NotificationChannel
-{
-    Email,
-    Sms,
-    InApp
-}

Backend/ERPCore/Domain/Notifications/NotificationModuleAttribute.cs

@@ -1,18 +0,0 @@
-namespace ERPCore.Domain.Notifications;
-
-[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-public sealed class NotificationModuleAttribute : Attribute
-{
-    public string Key { get; }
-    public string Label { get; }
-    public string Description { get; }
-    public int SortOrder { get; }
-
-    public NotificationModuleAttribute(string key, string label, string description, int sortOrder)
-    {
-        Key = key;
-        Label = label;
-        Description = description;
-        SortOrder = sortOrder;
-    }
-}

Backend/ERPCore/Domain/Notifications/NotificationModuleDefinition.cs

@@ -1,7 +0,0 @@
-namespace ERPCore.Domain.Notifications;
-
-public sealed record NotificationModuleDefinition(
-    string Key,
-    string Label,
-    string Description,
-    int SortOrder);

Backend/ERPCore/Dtos/Audit/AuditDtos.cs

@@ -10,7 +10,3 @@ public sealed record AuditLogDto(
 /// <summary>A GL-ready journal stub emitted per stock movement (FR-STK-13).</summary>
 public sealed record JournalEntryStubDto(
     int JournalId, string SourceDocType, int SourceDocId, string DebitAccount, string CreditAccount, decimal Amount);
-
-/// <summary>A captured past sign-in — device history, not a live "currently active sessions" view.</summary>
-public sealed record LoginActivityDto(
-    int LoginActivityId, string? IpAddress, string? DeviceLabel, DateTime LoginAt);

Backend/ERPCore/Dtos/Config/BranchConfigDtos.cs

@@ -1,20 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace ERPCore.Dtos.Config;
-
-/// <summary>Branch configuration resource — the singleton toggle for whether this deployment
-/// requires a branch on Employee/Warehouse records at all.</summary>
-public sealed record BranchConfigDto(bool BranchingEnabled, DateTime? UpdatedAt, int? UpdatedBy);
-
-/// <summary>
-/// Full replacement of the flag. <c>UpdatedBy</c> is derived from the token, never posted.
-/// <para>
-/// <see cref="BranchingEnabled"/> is <see cref="bool"/>? deliberately: <c>[Required]</c> on a
-/// non-nullable bool is a no-op, so an omitted flag would otherwise silently bind to
-/// <c>false</c>. Nullable makes the requirement actually bind — an omitted flag is a 400.
-/// </para>
-/// </summary>
-public sealed class UpdateBranchConfigRequest
-{
-    [Required] public bool? BranchingEnabled { get; set; }
-}

Backend/ERPCore/Dtos/Config/ProductConfigDtos.cs

@@ -4,14 +4,10 @@ namespace ERPCore.Dtos.Config;
 
 /// <summary>
 /// Product configuration resource (docs/11-BACKEND-PHASE1.md §2.8). Singleton.
-/// <see cref="ItemTypesEnabled"/> is advisory (frontend-honoured) - see the entity docs.
-/// <see cref="SellingPricesEnabled"/>, <see cref="SerialNumbersEnabled"/>,
-/// <see cref="BatchListsEnabled"/> and <see cref="WarrantyPeriodsEnabled"/> are enforced
-/// when items are written.
+/// <see cref="ItemTypesEnabled"/> is advisory (frontend-honoured) — see the entity docs.
 /// </summary>
 public sealed record ProductConfigDto(
     bool SubcategoriesEnabled, bool BrandsEnabled, bool ItemTypesEnabled,
-    bool SellingPricesEnabled, bool SerialNumbersEnabled, bool BatchListsEnabled, bool WarrantyPeriodsEnabled,
     DateTime? UpdatedAt, int? UpdatedBy);
 
 /// <summary>
@@ -19,8 +15,8 @@ public sealed record ProductConfigDto(
 /// <para>
 /// The flags are <see cref="bool"/>? deliberately: <c>[Required]</c> on a non-nullable bool
 /// is a no-op (it always has a value), so a body of <c>{}</c> would bind every flag to
-/// <c>false</c> and silently switch everything off. Nullable makes the requirement actually
-/// bind - an omitted flag is a 400, not an accidental disable.
+/// <c>false</c> and silently switch all three features off. Nullable makes the requirement
+/// actually bind — an omitted flag is a 400, not an accidental disable.
 /// </para>
 /// </summary>
 public sealed class UpdateProductConfigRequest
@@ -28,8 +24,4 @@ public sealed class UpdateProductConfigRequest
     [Required] public bool? SubcategoriesEnabled { get; set; }
     [Required] public bool? BrandsEnabled { get; set; }
     [Required] public bool? ItemTypesEnabled { get; set; }
-    [Required] public bool? SellingPricesEnabled { get; set; }
-    [Required] public bool? SerialNumbersEnabled { get; set; }
-    [Required] public bool? BatchListsEnabled { get; set; }
-    [Required] public bool? WarrantyPeriodsEnabled { get; set; }
 }

Backend/ERPCore/Dtos/Grn/GrnDtos.cs

@@ -5,41 +5,32 @@ namespace ERPCore.Dtos.Grn;
 
 // Responses (docs/11 §4) --------------------------------------------------------
 
-public sealed record GrnLineWarrantyNumberDto(string WarrantyNo, int WarrantyPeriodMonths);
-
 public sealed record GrnLineDto(
-    int GrnLineId, int? PoLineId, int ItemId, int? BinId,
+    int GrnLineId, int? PoLineId, int ItemId, int UomId, int? BinId,
     decimal Qty, decimal UnitCost, decimal? PoUnitPrice,
     decimal DiscountPct, decimal NetUnitCost, decimal VatPct, decimal VatAmount,
     decimal ReceivedValue, decimal LineTotal, decimal PriceVariance,
-    HoldStatus HoldStatus, int? BatchId, IReadOnlyList<GrnLineWarrantyNumberDto> WarrantyNumbers);
+    HoldStatus HoldStatus, int? BatchId);
 
 public sealed record GrnDto(
-    int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, int BranchId, GrnStatus Status,
-    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, string? GlJournalNo,
-    int? PurchaseInvoiceId, string? PurchaseInvoiceNo, IReadOnlyList<GrnLineDto> Lines);
+    int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, GrnStatus Status,
+    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, IReadOnlyList<GrnLineDto> Lines);
 
 /// <summary>Row shape for <c>GET /grns</c> — line count instead of the lines themselves.</summary>
 public sealed record GrnSummaryDto(
-    int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, int BranchId, GrnStatus Status,
-    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, int LineCount,
-    int? PurchaseInvoiceId, string? PurchaseInvoiceNo);
+    int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, GrnStatus Status,
+    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, int LineCount);
 
 public sealed record CreatedLayerDto(
     int LayerId, int ItemId, int WarehouseId, int? BatchId,
     decimal QtyReceived, decimal QtyRemaining, decimal UnitCost, DateTime ReceiptDate);
 
 public sealed record GrnConfirmResultDto(
-    int GrnId, GrnStatus Status, DateTime PostedAt, string GlJournalNo,
+    int GrnId, GrnStatus Status, DateTime PostedAt,
     IReadOnlyList<CreatedLayerDto> CreatedLayers, IReadOnlyList<int> LedgerRefs, PurchaseOrderStatus? PoStatus);
 
 public sealed record ReleaseLineResultDto(int GrnLineId, HoldStatus HoldStatus);
 
-/// <summary>A Confirmed, not-yet-invoiced GRN eligible to be consolidated onto a Purchase Invoice.</summary>
-public sealed record GrnEligibleForInvoiceDto(
-    int GrnId, string DocNo, DateTime PostedAt, int WarehouseId,
-    int LineCount, decimal Subtotal, decimal VatTotal, decimal GrandTotal);
-
 // Requests ----------------------------------------------------------------------
 
 public sealed class BatchInput
@@ -53,6 +44,7 @@ public sealed class CreateGrnLineInput
     /// <summary>Set for a PO-based receipt; cost is then derived from the PO line (02-SECURITY C.3).</summary>
     public int? PoLineId { get; set; }
     [Required] public int ItemId { get; set; }
+    [Required] public int UomId { get; set; }
     public int? BinId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
     /// <summary>
@@ -67,11 +59,6 @@ public sealed class CreateGrnLineInput
     [Range(0, 100)] public decimal VatPct { get; set; }
     [EnumDataType(typeof(HoldStatus))] public HoldStatus HoldStatus { get; set; } = HoldStatus.Available;
     public BatchInput? Batch { get; set; }
-    /// <summary>
-    /// Required, one per unit (count must equal <see cref="Qty"/>), when the item is
-    /// warranty-tracked (<c>Item.Warranty == Warranty.Warranty</c>). Ignored otherwise.
-    /// </summary>
-    public List<string>? WarrantyNumbers { get; set; }
 }
 
 public sealed class CreateGrnRequest
@@ -81,9 +68,6 @@ public sealed class CreateGrnRequest
     /// <summary>Required for a direct receipt (no PO); ignored otherwise (vendor derives from the PO).</summary>
     public int? VendorId { get; set; }
     [Required] public int WarehouseId { get; set; }
-    /// <summary>Owning branch for this GRN — warehouses are shared, so this is what actually
-    /// scopes the document (resolved via IBranchConfigService; required when branching is enabled).</summary>
-    [Required] public int BranchId { get; set; }
     [Required, MinLength(1)] public List<CreateGrnLineInput> Lines { get; set; } = new();
 }
 

Backend/ERPCore/Dtos/Hrm/EmployeeDtos.cs

@@ -6,7 +6,7 @@ namespace ERPCore.Dtos.Hrm;
 public sealed record EmployeeListItemDto(
     int EmployeeId, string EmployeeCode, string FullName, string? Email,
     int DepartmentId, string? DepartmentName, int DesignationId, string? DesignationName,
-    int EmploymentTypeId, string? EmploymentTypeName, int BranchId, string? BranchName,
+    int EmploymentTypeId, string? EmploymentTypeName, int? BranchId, string? BranchName,
     EmployeeStatus Status, bool HasUserLink, DateTime HireDate);
 
 public sealed record EmployeeDetailDto(
@@ -16,7 +16,7 @@ public sealed record EmployeeDetailDto(
     string? City, string? PostalCode, string? Country,
     string? EmergencyContactName, string? EmergencyContactRelationship, string? EmergencyContactPhone,
     DateTime HireDate, DateTime? ConfirmationDate, DateTime? LastWorkingDate,
-    int DepartmentId, int DesignationId, int EmploymentTypeId, int BranchId, int WorkShiftId,
+    int DepartmentId, int DesignationId, int EmploymentTypeId, int? BranchId, int WorkShiftId,
     int? ReportingManagerId, string? EpfNumber, string? EtfNumber, string? TaxIdentificationNumber,
     int? UserId, EmployeeStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
 
@@ -45,7 +45,7 @@ public sealed class CreateEmployeeRequest
     [Required] public int DepartmentId { get; set; }
     [Required] public int DesignationId { get; set; }
     [Required] public int EmploymentTypeId { get; set; }
-    [Required] public int BranchId { get; set; }
+    public int? BranchId { get; set; }
     [Required] public int WorkShiftId { get; set; }
     public int? ReportingManagerId { get; set; }
 
@@ -82,7 +82,7 @@ public sealed class UpdateEmployeeRequest
     [Required] public int DepartmentId { get; set; }
     [Required] public int DesignationId { get; set; }
     [Required] public int EmploymentTypeId { get; set; }
-    [Required] public int BranchId { get; set; }
+    public int? BranchId { get; set; }
     [Required] public int WorkShiftId { get; set; }
     public int? ReportingManagerId { get; set; }
 

Backend/ERPCore/Dtos/Hrm/OrgMasterDtos.cs

@@ -7,22 +7,20 @@ namespace ERPCore.Dtos.Hrm;
 // ids, timestamps) excluded from create/update requests (02-SECURITY B.6/C.1).
 
 public sealed record BranchDto(
-    int BranchId, string Code, string Name, string? Address, string? PhoneNumber, EntityStatus Status,
+    int BranchId, string Code, string Name, string? Address, EntityStatus Status,
     DateTime CreatedAt, DateTime? UpdatedAt);
 
-// Code is server-generated (BranchService.GenerateCodeAsync) — never accepted from the client.
 public sealed class CreateBranchRequest
 {
+    [Required, StringLength(20)] public string Code { get; set; } = string.Empty;
     [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
     [StringLength(500)] public string? Address { get; set; }
-    [StringLength(30)] public string? PhoneNumber { get; set; }
 }
 
 public sealed class UpdateBranchRequest
 {
     [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
     [StringLength(500)] public string? Address { get; set; }
-    [StringLength(30)] public string? PhoneNumber { get; set; }
 }
 
 public sealed record DepartmentDto(

Backend/ERPCore/Dtos/ItemTypes/ItemTypeDtos.cs

@@ -5,16 +5,12 @@ namespace ERPCore.Dtos.ItemTypes;
 
 /// <summary>
 /// Item type resource (docs/11-BACKEND-PHASE1.md §2.7) — a dimension name such as Color
-/// or Size. Carries no values and no item linkage: the chosen values are encoded into the
+/// or Size. Carries no values and no item linkage: <c>GET /item-types</c> exists to
+/// populate the frontend builder's dropdown, and the chosen values are encoded into the
 /// client-generated SKU rather than stored (docs/10 Part C.9).
-/// <para>
-/// <c>IsMeasurable</c> marks a dimension whose values are content measurements (500 ml, 1 L)
-/// rather than plain labels; the builder captures a number + unit per value and writes it to
-/// each generated item's content size.
-/// </para>
 /// </summary>
 public sealed record ItemTypeDto(
-    int ItemTypeId, string Name, bool IsMeasurable, EntityStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
+    int ItemTypeId, string Name, EntityStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
 
 // Request DTOs — narrow: server-controlled fields (status, ids, timestamps)
 // are intentionally excluded to prevent over-posting (02-SECURITY B.6 / C.1). ----
@@ -22,21 +18,11 @@ public sealed record ItemTypeDto(
 public sealed class CreateItemTypeRequest
 {
     [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
-
-    /// <summary>Omitted ⇒ false, i.e. plain-text values. See <see cref="ItemTypeDto"/>.</summary>
-    public bool IsMeasurable { get; set; }
 }
 
 public sealed class UpdateItemTypeRequest
 {
     [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Nullable on purpose: a plain <c>bool</c> binds an absent property as <c>false</c>, so any
-    /// client that PUT only a name — as the item-types screen used to — would silently clear the
-    /// flag on every rename. Omitting this field <b>preserves</b> the stored value.
-    /// </summary>
-    public bool? IsMeasurable { get; set; }
 }
 
 public sealed class UpdateItemTypeStatusRequest

Backend/ERPCore/Dtos/Items/ItemDtos.cs

@@ -9,11 +9,7 @@ namespace ERPCore.Dtos.Items;
 public sealed record ItemListItemDto(
     int ItemId, string Sku, string Name, int CategoryId, int? SubCategoryId, int? BrandId,
     int BaseUomId, int? DefaultVendorId, StockNature StockNature, TrackingMode TrackingMode,
-    Warranty Warranty, int? WarrantyPeriodMonths,
-    string? TaxClass, decimal? SellingMinPrice, decimal? SellingMaxPrice, decimal? SellingFlatPrice,
-    decimal? ContentQty, MeasureUnit? ContentUnit,
-    decimal? ContentBaseQty, MeasureUnit? ContentBaseUnit,
-    EntityStatus Status);
+    string? TaxClass, decimal? SalePrice, EntityStatus Status);
 
 /// <summary>A single per-warehouse reorder policy row.</summary>
 public sealed record ItemReorderDto(int WarehouseId, decimal ReorderPoint, decimal ReorderQty);
@@ -21,22 +17,26 @@ public sealed record ItemReorderDto(int WarehouseId, decimal ReorderPoint, decim
 /// <summary>
 /// Full item resource for <c>GET /items/{id}</c> and create/update responses.
 /// <para>
-/// <c>ContentBaseQty</c>/<c>ContentBaseUnit</c> are echoed back so a detail screen can show
-/// what the entered size normalised to (1.5 L ⇒ 1500 ml) — they are server-derived and are
-/// not accepted on write.
+/// <see cref="Conversions"/> is embedded because they are otherwise unreadable: they can
+/// only be written via <c>PUT /items/{id}/uom-conversions</c>, which returns them, but no
+/// endpoint reads them back — so a detail screen could never show current state before
+/// editing. Mirrors how <see cref="Reorder"/> is already inlined.
 /// </para>
 /// </summary>
 public sealed record ItemDetailDto(
     int ItemId, string Sku, string Name, string? Description, int CategoryId,
     int? SubCategoryId, int? BrandId, int BaseUomId, int? DefaultVendorId,
     StockNature StockNature, TrackingMode TrackingMode,
-    Warranty Warranty, int? WarrantyPeriodMonths,
-    string? TaxClass, decimal? SellingMinPrice, decimal? SellingMaxPrice, decimal? SellingFlatPrice,
-    decimal? ContentQty, MeasureUnit? ContentUnit,
-    decimal? ContentBaseQty, MeasureUnit? ContentBaseUnit,
-    EntityStatus Status, IReadOnlyList<ItemReorderDto> Reorder,
+    string? TaxClass, decimal? SalePrice, EntityStatus Status, IReadOnlyList<ItemReorderDto> Reorder,
+    IReadOnlyList<UomConversionDto> Conversions,
     DateTime CreatedAt, DateTime? UpdatedAt);
 
+/// <summary>UOM conversion row (docs/11 §2.2).</summary>
+public sealed record UomConversionDto(int ConversionId, int FromUom, int ToUom, decimal Factor);
+
+/// <summary>Response body for <c>PUT /items/{id}/uom-conversions</c>.</summary>
+public sealed record ItemUomConversionsDto(int ItemId, int BaseUomId, IReadOnlyList<UomConversionDto> Conversions);
+
 /// <summary>Response body for <c>PUT /items/{id}/reorder</c>.</summary>
 public sealed record ItemReorderSettingsDto(IReadOnlyList<ItemReorderDto> Settings);
 
@@ -61,22 +61,9 @@ public sealed class CreateItemRequest
     public int? DefaultVendorId { get; set; }
     [Required, EnumDataType(typeof(StockNature))] public StockNature StockNature { get; set; }
     [EnumDataType(typeof(TrackingMode))] public TrackingMode TrackingMode { get; set; } = TrackingMode.None;
-    [EnumDataType(typeof(Warranty))] public Warranty Warranty { get; set; } = Warranty.NonWarranty;
-    /// <summary>Required (one of <see cref="Enums.WarrantyPeriods.AllowedMonths"/>) when <see cref="Warranty"/> is Warranty; ignored otherwise.</summary>
-    public int? WarrantyPeriodMonths { get; set; }
     [StringLength(20)] public string? TaxClass { get; set; }
     /// <summary>Optional fixed sale price (Sales only). Null ⇒ sell at stock/FIFO value.</summary>
-    [Range(0, double.MaxValue)] public decimal? SellingMinPrice { get; set; }
-    [Range(0, double.MaxValue)] public decimal? SellingMaxPrice { get; set; }
-    [Range(0, double.MaxValue)] public decimal? SellingFlatPrice { get; set; }
-
-    /// <summary>
-    /// How much one pack holds. Supply with <see cref="ContentUnit"/> or leave both null
-    /// for items with no measurable content. The normalised base pair is derived by the
-    /// server and is deliberately not accepted here.
-    /// </summary>
-    [Range(0.0001, double.MaxValue)] public decimal? ContentQty { get; set; }
-    [EnumDataType(typeof(MeasureUnit))] public MeasureUnit? ContentUnit { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SalePrice { get; set; }
 }
 
 public sealed class UpdateItemRequest
@@ -93,22 +80,9 @@ public sealed class UpdateItemRequest
     public int? DefaultVendorId { get; set; }
     [Required, EnumDataType(typeof(StockNature))] public StockNature StockNature { get; set; }
     [EnumDataType(typeof(TrackingMode))] public TrackingMode TrackingMode { get; set; } = TrackingMode.None;
-    [EnumDataType(typeof(Warranty))] public Warranty Warranty { get; set; } = Warranty.NonWarranty;
-    /// <summary>Required (one of <see cref="Enums.WarrantyPeriods.AllowedMonths"/>) when <see cref="Warranty"/> is Warranty; ignored otherwise.</summary>
-    public int? WarrantyPeriodMonths { get; set; }
     [StringLength(20)] public string? TaxClass { get; set; }
     /// <summary>Optional fixed sale price (Sales only). Null ⇒ sell at stock/FIFO value.</summary>
-    [Range(0, double.MaxValue)] public decimal? SellingMinPrice { get; set; }
-    [Range(0, double.MaxValue)] public decimal? SellingMaxPrice { get; set; }
-    [Range(0, double.MaxValue)] public decimal? SellingFlatPrice { get; set; }
-
-    /// <summary>
-    /// How much one pack holds. Supply with <see cref="ContentUnit"/> or leave both null
-    /// for items with no measurable content. The normalised base pair is derived by the
-    /// server and is deliberately not accepted here.
-    /// </summary>
-    [Range(0.0001, double.MaxValue)] public decimal? ContentQty { get; set; }
-    [EnumDataType(typeof(MeasureUnit))] public MeasureUnit? ContentUnit { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SalePrice { get; set; }
 }
 
 public sealed class UpdateItemStatusRequest
@@ -127,3 +101,15 @@ public sealed class UpdateReorderRequest
 {
     [Required, MinLength(1)] public List<ReorderSettingInput> Settings { get; set; } = new();
 }
+
+public sealed class UomConversionInput
+{
+    [Required] public int FromUom { get; set; }
+    [Required] public int ToUom { get; set; }
+    [Range(0.000001, double.MaxValue)] public decimal Factor { get; set; }
+}
+
+public sealed class UpdateUomConversionsRequest
+{
+    [Required, MinLength(1)] public List<UomConversionInput> Conversions { get; set; } = new();
+}

Backend/ERPCore/Dtos/Notifications/NotificationConfigDtos.cs

@@ -1,29 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace ERPCore.Dtos.Notifications;
-
-public sealed record NotificationModuleConfigDto(
-    string ModuleKey,
-    string Label,
-    string Description,
-    bool EmailEnabled,
-    bool SmsEnabled,
-    bool InAppEnabled);
-
-public sealed record NotificationConfigDto(
-    IReadOnlyList<NotificationModuleConfigDto> Modules,
-    DateTime? UpdatedAt,
-    int? UpdatedBy);
-
-public sealed class UpdateNotificationModuleRequest
-{
-    [Required, StringLength(100)] public string ModuleKey { get; set; } = string.Empty;
-    [Required] public bool? EmailEnabled { get; set; }
-    [Required] public bool? SmsEnabled { get; set; }
-    [Required] public bool? InAppEnabled { get; set; }
-}
-
-public sealed class UpdateNotificationConfigRequest
-{
-    [Required, MinLength(0)] public List<UpdateNotificationModuleRequest> Modules { get; set; } = new();
-}

Backend/ERPCore/Dtos/Procurement/PurchaseInvoiceDtos.cs

@@ -1,50 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using ERPCore.Domain.Enums;
-
-namespace ERPCore.Dtos.Procurement;
-
-public sealed record PurchaseInvoiceLineDto(
-    int PurchaseInvoiceLineId, int GrnId, string GrnDocNo, DateTime GrnPostedAt,
-    decimal Subtotal, decimal VatTotal, decimal LineTotal);
-
-public sealed record PurchaseInvoiceTotalsDto(
-    decimal Subtotal, decimal VatTotal, decimal GrandTotal, decimal PaidAmount, decimal BalanceAmount);
-
-public sealed record PurchaseInvoiceDto(
-    int PurchaseInvoiceId, string DocNo, string VendorInvoiceNo, DateTime VendorInvoiceDate,
-    int VendorId, string VendorSnapshotName, string? VendorSnapshotTaxNo,
-    PurchaseInvoiceStatus Status, int GrnCount, int CreatedBy, DateTime CreatedAt, DateTime? UpdatedAt,
-    string? GlJournalNo, DateTime? GlPostedAt,
-    PurchaseInvoiceTotalsDto Totals, IReadOnlyList<PurchaseInvoiceLineDto> Lines);
-
-public sealed record PurchaseInvoiceSummaryDto(
-    int PurchaseInvoiceId, string DocNo, string VendorInvoiceNo, DateTime VendorInvoiceDate,
-    int VendorId, string VendorSnapshotName, PurchaseInvoiceStatus Status, int GrnCount,
-    PurchaseInvoiceTotalsDto Totals, DateTime CreatedAt, string? GlJournalNo);
-
-public sealed record PurchaseInvoicePaymentDto(
-    int PurchaseInvoicePaymentId, int PurchaseInvoiceId, decimal Amount, DateTime PaymentDate,
-    long GlBankAccountId, string BankAccountName, string? Reference, string? GlJournalNo, DateTime CreatedAt);
-
-public sealed class CreatePurchaseInvoicePaymentRequest
-{
-    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
-    [Required] public long GlBankAccountId { get; set; }
-    [StringLength(100)] public string? Reference { get; set; }
-}
-
-public sealed class CreatePurchaseInvoiceRequest
-{
-    [Required] public int VendorId { get; set; }
-    [Required, StringLength(50)] public string VendorInvoiceNo { get; set; } = string.Empty;
-    [Required] public DateTime VendorInvoiceDate { get; set; }
-    [Required, MinLength(1)] public List<int> GrnIds { get; set; } = new();
-}
-
-public sealed class UpdatePurchaseInvoiceRequest
-{
-    [Required] public int VendorId { get; set; }
-    [Required, StringLength(50)] public string VendorInvoiceNo { get; set; } = string.Empty;
-    [Required] public DateTime VendorInvoiceDate { get; set; }
-    [Required, MinLength(1)] public List<int> GrnIds { get; set; } = new();
-}

Backend/ERPCore/Dtos/Procurement/PurchaseOrderDtos.cs

@@ -6,7 +6,7 @@ namespace ERPCore.Dtos.Procurement;
 // Responses (docs/11 §3.3) ------------------------------------------------------
 
 public sealed record PoLineDto(
-    int PoLineId, int ItemId, int WarehouseId,
+    int PoLineId, int ItemId, int UomId, int WarehouseId,
     decimal Qty, decimal UnitPrice, decimal Tax, decimal QtyReceived);
 
 public sealed record PoTotalsDto(decimal SubTotal, decimal Tax, decimal GrandTotal, string Currency);
@@ -25,6 +25,7 @@ public sealed record PurchaseOrderSummaryDto(
 public sealed class CreatePoLineInput
 {
     [Required] public int ItemId { get; set; }
+    [Required] public int UomId { get; set; }
     [Required] public int WarehouseId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
     [Range(0, double.MaxValue)] public decimal UnitPrice { get; set; }

Backend/ERPCore/Dtos/Procurement/PurchaseReturnDtos.cs

@@ -9,13 +9,12 @@ public sealed record PurchaseReturnLineDto(int ReturnLineId, int? GrnLineId, int
 
 public sealed record PurchaseReturnDto(
     int ReturnId, string DocNo, int VendorId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
-    int CreatedBy, DateTime CreatedAt, string? GlJournalNo, DateTime? GlPostedAt,
-    IReadOnlyList<PurchaseReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
+    int CreatedBy, DateTime CreatedAt, IReadOnlyList<PurchaseReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
 
 /// <summary>Row shape for <c>GET /purchase-returns</c> — no lines/ledgerRefs (those need a per-row query).</summary>
 public sealed record PurchaseReturnSummaryDto(
     int ReturnId, string DocNo, int VendorId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
-    int CreatedBy, DateTime CreatedAt, int LineCount, string? GlJournalNo);
+    int CreatedBy, DateTime CreatedAt, int LineCount);
 
 // Requests ----------------------------------------------------------------------
 

Backend/ERPCore/Dtos/Production/RunDtos.cs

@@ -29,23 +29,17 @@ public sealed record RunSummaryDto(
 /// </summary>
 public sealed record CostPoolDto(decimal Consumed, decimal Returned, decimal Net);
 
-/// <summary>
-/// One input of a run stage. <c>PlannedQty</c> is expressed in <c>QtyUnit</c> — content
-/// (ml/g) or packs — while every consumption figure is always a pack count, so the two are
-/// not directly comparable for a Content input.
-/// </summary>
 public sealed record RunStageInputDto(
-    int RunInputId, StageInputSource Source, int? ItemId, int? FromRunOutputId, StageQtyUnit QtyUnit,
+    int RunInputId, StageInputSource Source, int? ItemId, int? FromRunOutputId, int UomId,
     decimal PlannedQty, decimal ConsumedQty, decimal ConsumedValue,
     decimal DeliveredQty, decimal ReturnedQty, decimal ReturnedValue);
 
 /// <summary>
 /// One output of a run stage. <c>AvailableToTransfer</c> is derived — produced − scrapped −
-/// transferred (FR-MFG-12) — and never stored. <c>UomId</c> is the WIP label and is null on
-/// the terminal output, whose unit is the finished item's base UOM.
+/// transferred (FR-MFG-12) — and never stored.
 /// </summary>
 public sealed record RunStageOutputDto(
-    int RunOutputId, int? ItemId, string Name, int? UomId,
+    int RunOutputId, int? ItemId, string Name, int UomId,
     decimal PlannedQty, decimal ProducedQty, decimal ScrappedQty, int? ScrapReasonCodeId,
     decimal TransferredQty, decimal AvailableToTransfer);
 
@@ -70,35 +64,6 @@ public sealed record RunEventDto(
     int EventId, int? RunStageId, RunStageEventType EventType, string? Note,
     JsonElement? Payload, int UserId, DateTime CreatedAt);
 
-/// <summary>
-/// One row of the produced-items report (<c>GET /production-runs/produced</c>) — the
-/// terminal output of a run that has produced something, costed the same way
-/// <c>PostReceiptAsync</c> costs the finished layer at approve (FR-MFG-13):
-/// <c>unitCost = (Σ ConsumedValue − Σ ReturnedValue) / (ProducedQty − ScrappedQty)</c>.
-/// One row per run — server validation (<see cref="ProductionGraphValidator"/> via
-/// FR-MFG-05) guarantees exactly one item-bearing output per run, always the terminal
-/// one, so run and produced line coincide 1:1.
-/// <para><c>UnitCost</c>/<c>TotalCost</c> are final only once <c>Status</c> is
-/// <c>Completed</c> — a leftover return can still shrink the pool between the terminal
-/// stage's Done and its Approve, same caveat as <see cref="CostPoolDto"/>.</para>
-/// </summary>
-public sealed record ProducedLineDto(
-    int RunId, string DocNo, ProductionRunStatus Status,
-    int TemplateId, string TemplateName,
-    int WarehouseId, string WarehouseName,
-    int ItemId, string ItemName,
-    decimal ProducedQty, decimal ScrappedQty, decimal GoodQty,
-    decimal UnitCost, decimal TotalCost,
-    DateTime CreatedAt, DateTime? CompletedAt);
-
-/// <summary>Aggregate footer for the produced-items report — totals over every row the filter
-/// matched, not just the current page (there is no pagination here, matching the Sales report
-/// convention of flat, filter-bounded rows).</summary>
-public sealed record ProducedSummaryDto(
-    int RunCount, decimal TotalProducedQty, decimal TotalScrappedQty, decimal TotalGoodQty, decimal TotalCost);
-
-public sealed record ProducedListResponseDto(IReadOnlyList<ProducedLineDto> Items, ProducedSummaryDto Summary);
-
 /// <summary>Full run graph (docs/30 §D.2 <c>GET /production-runs/{id}</c>).</summary>
 public sealed record RunGraphDto(
     int RunId, string DocNo, int TemplateId, string TemplateName,
@@ -128,10 +93,8 @@ public sealed class CreateRunRequest
 }
 
 /// <summary>
-/// Per-run scaling override (FR-MFG-08). Accepted before the stage starts, and — for a Stock
-/// input only — while it is running too: raising <see cref="StageQuantityLine.PlannedQty"/>
-/// draws the extra amount from FIFO, lowering it returns the excess (<c>409
-/// STAGE_NOT_EDITABLE</c> for every other status).
+/// Per-run scaling override (FR-MFG-08). Only accepted while the stage has not started
+/// (<c>409 STAGE_NOT_EDITABLE</c>).
 /// </summary>
 public sealed class UpdateStageQuantitiesRequest
 {
@@ -147,11 +110,4 @@ public sealed class StageQuantityLine
 
     [Range(0.0001, double.MaxValue)]
     public decimal PlannedQty { get; set; }
-
-    /// <summary>
-    /// Required only when this line lowers a running Stock input below what it has already
-    /// consumed — the excess is returned to stock the same way <c>ReturnLeftoverAsync</c>
-    /// does, and that always needs a reason (FR-MFG-14). Ignored otherwise.
-    /// </summary>
-    public int? ReasonCodeId { get; set; }
 }

Backend/ERPCore/Dtos/Production/TemplateDtos.cs

@@ -35,11 +35,10 @@ public sealed record FieldDefDto(
 
 public sealed record StageInputDto(
     int InputId, StageInputSource Source, int? ItemId,
-    int? FromOutputId, string? FromOutputKey, StageQtyUnit QtyUnit, decimal QtyPerBatch);
+    int? FromOutputId, string? FromOutputKey, int UomId, decimal QtyPerBatch);
 
-/// <summary><c>UomId</c> is the WIP label and is null exactly when <c>ItemId</c> is set.</summary>
 public sealed record StageOutputDto(
-    int OutputId, string Key, int? ItemId, string Name, int? UomId, decimal QtyPerBatch);
+    int OutputId, string Key, int? ItemId, string Name, int UomId, decimal QtyPerBatch);
 
 public sealed record TemplateStageDto(
     int StageId, string Key, string Name, string? RoleLabel, int EstimatedMinutes,
@@ -135,12 +134,8 @@ public sealed class SaveInputRequest
     [StringLength(60)]
     public string? FromOutputKey { get; set; }
 
-    /// <summary>
-    /// What <see cref="QtyPerBatch"/> means. <c>Content</c> (ml/g) is allowed only on a Stock
-    /// input whose item has a content size; Upstream inputs must be <c>Pack</c>.
-    /// </summary>
-    [EnumDataType(typeof(StageQtyUnit))]
-    public StageQtyUnit QtyUnit { get; set; } = StageQtyUnit.Pack;
+    [Range(1, int.MaxValue)]
+    public int UomId { get; set; }
 
     [Range(0.0001, double.MaxValue)]
     public decimal QtyPerBatch { get; set; }
@@ -158,12 +153,8 @@ public sealed class SaveOutputRequest
     [Required, StringLength(150, MinimumLength = 1)]
     public string Name { get; set; } = string.Empty;
 
-    /// <summary>
-    /// The WIP display unit. Required when <see cref="ItemId"/> is null; must be null when it
-    /// is set, because a real item's unit is its own base UOM.
-    /// </summary>
     [Range(1, int.MaxValue)]
-    public int? UomId { get; set; }
+    public int UomId { get; set; }
 
     [Range(0.0001, double.MaxValue)]
     public decimal QtyPerBatch { get; set; }

Backend/ERPCore/Dtos/Rbac/MeDtos.cs

@@ -2,13 +2,5 @@ namespace ERPCore.Dtos.Rbac;
 
 /// <summary>Response for `GET /api/v1/auth/me` — the frontend's authoritative source
 /// for the current user's role and permitted sidebar nav codes (replaces trusting
-/// the stale, client-only `roleId` cached in localStorage). <see cref="BranchId"/>/
-/// <see cref="BranchName"/> come from the caller's linked <c>Employee</c> record, when
-/// one exists — null for a login with no Employee link. <see cref="IsAdmin"/> gates
-/// branch pickers client-side only (no server-side branch enforcement exists yet,
-/// see docs/BRANCH_ISOLATION_PLAN.md). <see cref="BranchingEnabled"/> mirrors the
-/// singleton <c>BranchConfig</c> toggle — when false the frontend hides branch pickers
-/// entirely rather than merely restricting them by role.</summary>
-public sealed record MeResponseDto(
-    string? RoleCode, string? RoleName, IReadOnlyList<string> NavCodes,
-    bool IsAdmin, int? BranchId, string? BranchName, bool BranchingEnabled);
+/// the stale, client-only `roleId` cached in localStorage).</summary>
+public sealed record MeResponseDto(string? RoleCode, string? RoleName, IReadOnlyList<string> NavCodes);

Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs

@@ -4,7 +4,7 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Sales;
 
 public sealed record BundleSaleLineDto(
-    int BundleSaleLineId, int ItemId, string Description, decimal Qty, int WarehouseId,
+    int BundleSaleLineId, int ItemId, string Description, decimal Qty, int UomId, int WarehouseId,
     decimal UnitPrice, decimal LineTotal, bool IncludeInBundle, bool IsComponent, int? ParentLineId);
 
 public sealed record BundleSaleDto(
@@ -20,7 +20,7 @@ public sealed record BundleSaleSummaryDto(
     decimal ComponentSubtotal, decimal BundlePrice, decimal GrandTotal, DateTime CreatedAt);
 
 public sealed record BundleSaleTemplateLineDto(
-    int BundleSaleTemplateLineId, int ItemId, int WarehouseId, decimal Qty,
+    int BundleSaleTemplateLineId, int ItemId, int UomId, int WarehouseId, decimal Qty,
     decimal UnitPrice, bool IncludeInBundle, int SortOrder);
 
 public sealed record BundleSaleTemplateDto(
@@ -42,6 +42,7 @@ public sealed record BundleSalePostingCheckDto(
 public sealed class CreateBundleSaleTemplateLineRequest
 {
     [Required] public int ItemId { get; set; }
+    [Required] public int UomId { get; set; }
     [Required] public int WarehouseId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
     [Range(0, double.MaxValue)] public decimal UnitPrice { get; set; }
@@ -51,6 +52,7 @@ public sealed class CreateBundleSaleTemplateLineRequest
 
 public sealed class CreateBundleSaleTemplateRequest
 {
+    [Required] public string TemplateCode { get; set; } = string.Empty;
     [Required] public string TemplateName { get; set; } = string.Empty;
     public string? Description { get; set; }
     [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();

Backend/ERPCore/Dtos/Sales/SalesDayEndDtos.cs

@@ -1,51 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace ERPCore.Dtos.Sales;
-
-// Responses -----------------------------------------------------------------------
-
-/// <summary>Qty/revenue sold for one item across a closed (or about-to-close) day, for the day-end report.
-/// Merges sales-slip and bundle-sale lines for the same item into one row.</summary>
-public sealed record SalesDayEndItemLineDto(int ItemId, string Sku, string Name, decimal Qty, decimal Revenue);
-
-/// <summary>Read-only visibility into that cashier's Sales Invoices for the date — informational
-/// only, appended to <see cref="SalesDayEndDto"/> and <see cref="SalesDayEndPreviewDto"/>.
-/// Invoices post their own GL entry on Confirm (SalesPostingService.PostInvoiceAsync) and have no
-/// DayEndId, so they're never locked against a close: these fields are computed live from current
-/// data on every read, unlike the frozen Slip/Bundle totals alongside them.</summary>
-public sealed record SalesDayEndInvoiceSummaryDto(
-    int InvoiceCount, decimal InvoiceSubtotal, decimal InvoiceDiscountTotal, decimal InvoiceTaxTotal,
-    decimal InvoiceGrandTotal, IReadOnlyList<string> InvoiceNumbers);
-
-public sealed record SalesDayEndDto(
-    int SalesDayEndId, string DocNo, int CashierUserId, DateOnly BusinessDate,
-    int SlipCount, int BundleCount, decimal Subtotal, decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal,
-    decimal CostOfGoodsSold, string? GlJournalNo, DateTime? GlPostedAt, int ClosedBy, DateTime ClosedAt,
-    IReadOnlyList<string> SlipNumbers, IReadOnlyList<string> BundleNumbers, IReadOnlyList<SalesDayEndItemLineDto> ItemBreakdown,
-    SalesDayEndInvoiceSummaryDto Invoices);
-
-public sealed record SalesDayEndSummaryDto(
-    int SalesDayEndId, string DocNo, int CashierUserId, DateOnly BusinessDate,
-    int SlipCount, int BundleCount, decimal GrandTotal, string? GlJournalNo, DateTime ClosedAt);
-
-/// <summary>What closing right now would include — call before <c>POST /sales-day-end</c> so the
-/// cashier can see the day's totals, and any still-Draft slips/bundles blocking the close.</summary>
-public sealed record SalesDayEndPreviewDto(
-    int CashierUserId, DateOnly BusinessDate, bool AlreadyClosed,
-    int SlipCount, int BundleCount, decimal Subtotal, decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal,
-    IReadOnlyList<string> SlipNumbers, IReadOnlyList<string> BundleNumbers,
-    IReadOnlyList<DraftSlipBlockingCloseDto> DraftSlipsBlockingClose,
-    IReadOnlyList<DraftBundleBlockingCloseDto> DraftBundleSalesBlockingClose,
-    SalesDayEndInvoiceSummaryDto Invoices);
-
-public sealed record DraftSlipBlockingCloseDto(int SalesSlipId, string SlipNo, decimal GrandTotal);
-public sealed record DraftBundleBlockingCloseDto(int BundleSaleId, string BundleNo, decimal GrandTotal);
-
-// Requests ------------------------------------------------------------------------
-
-public sealed class CreateSalesDayEndRequest
-{
-    [Required] public int CashierUserId { get; set; }
-    /// <summary>Defaults to today (UTC) when omitted.</summary>
-    public DateOnly? BusinessDate { get; set; }
-}

Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs

@@ -4,7 +4,7 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Sales;
 
 public sealed record SalesInvoiceLineDto(
-    int SalesInvoiceLineId, int ItemId, string Description, decimal Qty, decimal FreeQty,
+    int SalesInvoiceLineId, int ItemId, string Description, decimal Qty, decimal FreeQty, int UomId,
     int WarehouseId, decimal UnitPrice, decimal BaseCost, string PriceSource, decimal DiscountPct,
     decimal DiscountAmount, SalesDiscountMode DiscountMode, decimal NetUnitPrice, decimal LineTotal,
     decimal TaxPct, decimal TaxAmount, bool IsFreeIssue, int? ParentLineId);
@@ -15,26 +15,14 @@ public sealed record SalesInvoiceTotalsDto(
 
 public sealed record SalesInvoiceDto(
     int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
-    string CustomerSnapshotName, string? CustomerSnapshotTaxNo, int WarehouseId, int BranchId,
+    string CustomerSnapshotName, string? CustomerSnapshotTaxNo, int WarehouseId,
     SalesInvoiceType InvoiceType, SalesInvoiceStatus Status, int CreatedBy, DateTime CreatedAt,
-    DateTime? UpdatedAt, string? GlJournalNo, DateTime? GlPostedAt,
-    SalesInvoiceTotalsDto Totals, IReadOnlyList<SalesInvoiceLineDto> Lines);
+    DateTime? UpdatedAt, SalesInvoiceTotalsDto Totals, IReadOnlyList<SalesInvoiceLineDto> Lines);
 
 public sealed record SalesInvoiceSummaryDto(
     int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
-    string CustomerSnapshotName, int WarehouseId, int BranchId, SalesInvoiceType InvoiceType,
-    SalesInvoiceStatus Status, SalesInvoiceTotalsDto Totals, DateTime CreatedAt, string? GlJournalNo);
-
-public sealed record SalesInvoicePaymentDto(
-    int SalesInvoicePaymentId, int SalesInvoiceId, decimal Amount, DateTime PaymentDate,
-    long GlBankAccountId, string BankAccountName, string? Reference, string? GlJournalNo, DateTime CreatedAt);
-
-public sealed class CreateSalesInvoicePaymentRequest
-{
-    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
-    [Required] public long GlBankAccountId { get; set; }
-    [StringLength(100)] public string? Reference { get; set; }
-}
+    string CustomerSnapshotName, int WarehouseId, SalesInvoiceType InvoiceType,
+    SalesInvoiceStatus Status, SalesInvoiceTotalsDto Totals, DateTime CreatedAt);
 
 public sealed record SalesInvoicePostingIssueDto(
     int SalesInvoiceLineId, int ItemId, string ItemSku, string ItemName, int WarehouseId,
@@ -47,6 +35,7 @@ public sealed record SalesInvoicePostingCheckDto(
 public sealed class CreateSalesInvoiceLineRequest
 {
     [Required] public int ItemId { get; set; }
+    [Required] public int UomId { get; set; }
     [Required] public int WarehouseId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
     [Range(0, double.MaxValue)] public decimal FreeQty { get; set; }
@@ -65,9 +54,6 @@ public sealed class CreateSalesInvoiceRequest
 {
     [Required] public int CustomerId { get; set; }
     [Required] public int WarehouseId { get; set; }
-    /// <summary>Owning branch — warehouses are shared, so this is what actually scopes the
-    /// document (resolved via IBranchConfigService).</summary>
-    [Required] public int BranchId { get; set; }
     [Required, EnumDataType(typeof(SalesInvoiceType))] public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
     [Required, MinLength(1)] public List<CreateSalesInvoiceLineRequest> Lines { get; set; } = new();
 }
@@ -76,9 +62,6 @@ public sealed class UpdateSalesInvoiceRequest
 {
     [Required] public int CustomerId { get; set; }
     [Required] public int WarehouseId { get; set; }
-    /// <summary>Owning branch — warehouses are shared, so this is what actually scopes the
-    /// document (resolved via IBranchConfigService).</summary>
-    [Required] public int BranchId { get; set; }
     [Required, EnumDataType(typeof(SalesInvoiceType))] public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
     [Required, MinLength(1)] public List<CreateSalesInvoiceLineRequest> Lines { get; set; } = new();
 }

Backend/ERPCore/Dtos/Sales/SalesPromotionSuggestionDtos.cs

@@ -4,7 +4,7 @@ public sealed record SalesFreeIssueRewardOptionDto(
     int ItemId,
     string Sku,
     string Name,
-    decimal? SellingFlatPrice);
+    decimal? SalePrice);
 
 public sealed record SalesFreeIssueSuggestionLineDto(
     int SalesSlipLineId,
@@ -20,4 +20,4 @@ public sealed record SalesFreeIssueSuggestionDto(
     int SalesSlipId,
     string SlipNo,
     DateTime SlipDate,
-    IReadOnlyList<SalesFreeIssueSuggestionLineDto> Lines);
+    IReadOnlyList<SalesFreeIssueSuggestionLineDto> Lines);